x_2\\n return F.softmax(r_hat, dim=-1)[:, 0]\\n\\n def p_hat_entropy(self, x_1: np.ndarray, x_2: np.ndarray, member: int = -1):\\n # softmaxing to get the probabilities according to eqn 1\\n with torch.no_grad():\\n r_hat1 = self.r_hat_member(x_1, member=member)\\n r_hat2 = self.r_hat_member(x_2, member=member)\\n r_hat1 = r_hat1.sum(axis=1)\\n r_hat2 = r_hat2.sum(axis=1)\\n r_hat = torch.cat([r_hat1, r_hat2], axis=-1)\\n\\n ent = F.softmax(r_hat, dim=-1) * F.log_softmax(r_hat, dim=-1)\\n ent = ent.sum(axis=-1).abs()\\n return ent\\n\\n def r_hat_member(self, x: torch.Tensor, member: int = -1) -> torch.Tensor:\\n # the network parameterizes r hat in eqn 1 from the paper\\n # return self.ensemble[member](torch.from_numpy(x).float().to(device))\\n return self.ensemble[member](x)\\n\\n def r_hat(self, x: np.ndarray):\\n # they say they average the rewards from each member of the ensemble, but I think this only makes sense if the\\n # rewards are already normalized and I don't understand how the normalization should be happening right now :(\\n r_hats = []\\n for member in range(self.ensemble_size):\\n r_hats.append(self.r_hat_member(torch.from_numpy(x).float().to(self.device), member=member).detach().cpu().numpy())\\n r_hats = np.array(r_hats)\\n return np.mean(r_hats)\\n\\n def r_hat_batch(self, x: np.ndarray):\\n # they say they average the rewards from each member of the ensemble, but I think this only makes sense if the rewards are already normalized\\n # but I don't understand how the normalization should be happening right now :(\\n r_hats = []\\n for member in range(self.ensemble_size):\\n r_hats.append(self.r_hat_member(torch.from_numpy(x).float().to(self.device), member=member).detach().cpu().numpy())\\n r_hats = np.array(r_hats)\\n return np.mean(r_hats, axis=0)\\n\\n def save(self, model_dir: str, env_id: str, step: int):\\n \\\"\\\"\\\"\\n Save the reward ensemble to disk\\n\\n Args:\\n model_dir: path where the ensemble is to be saved\\n env_id: the environment on which the ensemble has been trained\\n step: the number of policy training steps\\n \\\"\\\"\\\"\\n for member in range(self.ensemble_size):\\n torch.save(\\n self.ensemble[member].state_dict(), f'{model_dir}/{env_id}_reward_model_{step}_{member}.pt'\\n )\\n\\n def train_reward(self,\\n preference_data_loader: PreferenceTripletEnsembleDataLoader,\\n num_epoch: int):\\n \\\"\\\"\\\"\\n Train the reward model on the given preference dataset.\\n\\n Args:\\n preference_data_loader: loads batches of preference triplets. Separated handles different preference\\n dataset permutations for each member of the reward's ensemble.\\n num_epoch: the number of training epochs to execute\\n \\\"\\\"\\\"\\n # track the accuracy and loss by ensemble member per epoch\\n ensemble_accuracies = np.zeros((num_epoch, self.ensemble_size))\\n ensemble_losses = np.zeros((num_epoch, self.ensemble_size))\\n\\n # train the reward model for the specified number of epochs\\n for epoch in range(num_epoch):\\n if epoch % 10 == 0:\\n print(f\\\"Running preference training epoch {epoch} of {num_epoch}\\\")\\n epoch_ensemble_losses = np.zeros(self.ensemble_size)\\n epoch_ensemble_acc = np.zeros(self.ensemble_size)\\n # train on each batch\\n for batch_indx, batch in enumerate(preference_data_loader):\\n # confirm there is either a single batch to be shared by all networks in the reward ensemble or\\n # a batch per network in the ensemble\\n assert len(batch) == 1 or len(batch) == self.ensemble_size\\n # we need to zero out the gradients before we begin to process this batch\\n self.optimizer.zero_grad()\\n # we will need to accumulate the loss across the ensemble members\\n batch_loss = 0.0\\n for member_indx, preference_triplet_batch in enumerate(batch):\\n # the predicted reward per transition in each trajectory\\n # check if we need to collapse the batch and time dimensions into one and then reconstruct the two\\n if self.image_observations:\\n # get the rewards for each transition in the trajectories one\\n traj_one_shape = preference_triplet_batch.trajectories_one.shape\\n formatted_trajectories_one = preference_triplet_batch.trajectories_one.reshape(\\n (-1, *traj_one_shape[2:]))\\n r_hat1 = self.r_hat_member(formatted_trajectories_one,\\n member=member_indx).reshape((traj_one_shape[0],\\n traj_one_shape[1], 1))\\n # get the rewards for each transition in the trajectories two\\n traj_two_shape = preference_triplet_batch.trajectories_two.shape\\n formatted_trajectories_two = preference_triplet_batch.trajectories_two.reshape(\\n (-1, *traj_two_shape[2:]))\\n r_hat2 = self.r_hat_member(formatted_trajectories_two,\\n member=member_indx).reshape((traj_two_shape[0],\\n traj_two_shape[1], 1))\\n else:\\n r_hat1 = self.r_hat_member(preference_triplet_batch.trajectories_one,\\n member=member_indx)\\n r_hat2 = self.r_hat_member(preference_triplet_batch.trajectories_two,\\n member=member_indx)\\n # compute the return per trajectory\\n r_hat1 = r_hat1.sum(axis=1)\\n r_hat2 = r_hat2.sum(axis=1)\\n\\n r_hat = torch.cat([r_hat1, r_hat2], dim=-1)\\n\\n # compute the ensemble member's loss\\n curr_loss = self.CEloss(r_hat, preference_triplet_batch.preference_labels.squeeze())\\n # add the loss from the ensemble member to the batch loss\\n batch_loss += curr_loss\\n # track the loss for this ensemble member\\n epoch_ensemble_losses[member_indx] += curr_loss.item()\\n\\n # compute the accuracy of the ensemble member's predictions\\n _, predicted = torch.max(r_hat.data, 1)\\n correct = (predicted == preference_triplet_batch.preference_labels.squeeze()).sum().item()\\n epoch_ensemble_acc[member_indx] += correct\\n # compute the gradients\\n batch_loss.backward()\\n # apply the gradients to the model\\n self.optimizer.step()\\n # compute the ensemble accuracy for this epoch\\n ensemble_accuracies[epoch] = epoch_ensemble_acc / preference_data_loader.dataset_length()\\n # compute the mean ensemble loss for this epoch\\n ensemble_losses[epoch] = epoch_ensemble_losses / preference_data_loader.dataset_length()\\n\\n if epoch % 10 == 0:\\n print(f\\\"Epoch {epoch} mean accuracy = {np.mean(ensemble_accuracies[:epoch + 1]):.2f}\\\")\\n\\n # check the current mean accuracy, if it is greater than 0.97 then terminate training\\n if np.mean(ensemble_accuracies[epoch]) >= 0.97:\\n print(f\\\"Epoch accuracy {np.mean(ensemble_accuracies[epoch]):.2f} \\\"\\n f\\\"after {epoch} epochs triggered early stopping.\\\")\\n return ensemble_accuracies[:epoch + 1], ensemble_losses[:epoch + 1]\\n\\n print(f\\\"Epoch {num_epoch} mean accuracy = {np.mean(ensemble_accuracies):.2f}\\\")\\n\\n return ensemble_accuracies, ensemble_losses\"\n },\n {\n \"identifier\": \"PreferenceDataset\",\n \"path\": \"reed/data/preference_dataset.py\",\n \"snippet\": \"class PreferenceDataset:\\n def __init__(self, observation_dim: t.Union[t.Tuple, int], action_dim: t.Union[t.Tuple, int], capacity: int,\\n size_segment: int, out_path: Path, image_observations: bool, grayscale_images: bool,\\n collect_image_pref_dataset: bool, state_action_formatter: PreProcessInference,\\n teacher_beta: float = -1, teacher_gamma: float = 1,\\n teacher_eps_mistake: float = 0, teacher_eps_skip: float = 0, teacher_eps_equal: float = 0):\\n \\\"\\\"\\\"\\n Args:\\n observation_dim: the dimensionality of the observations\\n action_dim: the dimensionality of the actions\\n capacity: the maximum number of trajectory pairs to include in the action_dimtaset\\n size_segment: the length of the trajectory segments\\n out_path: the location where the preference action_dimtaset will be written to disk during training\\n image_observations: whether the observations given to the reward model are images\\n grayscale_images: whether the image observations should be converted to grayscale instead of color\\n collect_image_pref_dataset: whether to collect the image preference dataset separate from the observations.\\n Should NOT be set to true if the observations are images.\\n state_action_formatter: function that maps states and actions to a single input\\n teacher_beta\\n teacher_gamma: used to determine how much influence each reward has on the preference label based on\\n order within the trajectory. Used to compute the return\\n teacher_eps_mistake: the frequency with which the teacher assigns an incorrect label\\n teacher_eps_skip: the frequency with which the teacher does not assign a label\\n teacher_eps_equal: the maximum difference between trajectory returns for the two trajectories to be labelled\\n as equally preferred\\n \\\"\\\"\\\"\\n self.observation_dim = observation_dim\\n self.action_dim = action_dim\\n self.capacity = capacity\\n self.size_segment = size_segment\\n self.out_path = out_path\\n self.image_observations = image_observations\\n self.grayscale_images = grayscale_images\\n # whether to collect the preference dataset as images\\n # only needs to be set to True if we are not learning the reward function from images\\n # if we are learning the reward function from images then we have an image dataset\\n self.collect_image_pref_dataset = collect_image_pref_dataset\\n\\n # formats the state-action pairs into a single input to the reward model\\n self.state_action_formatter = state_action_formatter\\n\\n # track where each preference triplet is written to disk\\n self._preference_triplet_tracker: t.List[Path] = []\\n\\n self.buffer_index = 0\\n self.buffer_full = False\\n\\n # create the preference labeller\\n self._preference_labeller = _PreferenceLabeller(teacher_beta=teacher_beta, teacher_gamma=teacher_gamma,\\n teacher_eps_mistake=teacher_eps_mistake,\\n teacher_eps_skip=teacher_eps_skip,\\n teacher_eps_equal=teacher_eps_equal)\\n\\n # make sure the outpath where the trajectories will be written exist\\n self.out_path.mkdir(parents=True, exist_ok=True)\\n\\n def __len__(self):\\n return len(self._preference_triplet_tracker)\\n\\n def __getitem__(self, item: int) -> PREFERENCE_TRIPLET:\\n \\\"\\\"\\\"\\n Load and return the preference triplet at the specified index in the buffer\\n\\n Args:\\n item: index of the triplet in the buffer\\n Returns:\\n trajectory one\\n trajectory two\\n preference label\\n \\\"\\\"\\\"\\n # get the location of the specified preference triplet and load it into memory\\n npz_archive = np.load(self._preference_triplet_tracker[item].as_posix())\\n\\n # grab the trajectories and preference labels\\n trajectory_one = npz_archive[\\\"trajectory_one\\\"]\\n trajectory_two = npz_archive[\\\"trajectory_two\\\"]\\n preference_label = npz_archive[\\\"preference_label\\\"]\\n\\n return trajectory_one, trajectory_two, preference_label\\n\\n def get_batch(self, indices: t.List[int]) -> PREFERENCE_TRIPLET_BATCH:\\n \\\"\\\"\\\"\\n Load and return the batch of preference triplets at the given indices in the buffer\\n\\n Args:\\n indices: the buffer indices of the preference triplets to load into memory\\n Returns:\\n batch of trajectories one\\n batch of trajectories two\\n batch of preference labels\\n \\\"\\\"\\\"\\n # accumulate the trajectory pairs and preference labels\\n trajectories_one = []\\n trajectories_two = []\\n preference_labels = []\\n # grab each preference triplet\\n for index in indices:\\n trajectory_one, trajectory_two, preference_label = self[index]\\n trajectories_one.append(np.expand_dims(trajectory_one, axis=0))\\n trajectories_two.append(np.expand_dims(trajectory_two, axis=0))\\n preference_labels.append(preference_label)\\n\\n return (np.concatenate(trajectories_one, axis=0), np.concatenate(trajectories_two, axis=0),\\n np.concatenate(preference_labels, axis=0))\\n\\n def _sample_trajectory_segments_uniform(self,\\n experience_buffer: TrajectoryReplayBuffer,\\n trajectory_count: int,\\n mini_batch_size: int) -> t.Tuple[np.ndarray, np.ndarray, t.Optional[np.ndarray]]:\\n \\\"\\\"\\\"\\n Uniformly sample trajectories and then uniformly sample a segment of the trajectory.\\n\\n Format and track the state-action pairs from each trajectory segment\\n Format and track rewards from each trajectory segment\\n\\n Combine the formatted state-action pairs and the rewards across trajectory segments\\n\\n Args:\\n experience_buffer: the replay buffer from which trajectory pairs will be drawn\\n trajectory_count: the number of trajectories to be sampled from\\n mini_batch_size: the number of trajectories to sample\\n\\n Returns:\\n the formatted state-action pairs from random trajectory segments from trajectories\\n the rewards from each random trajectory segment\\n (optionally) the image observations from each random trajectory segment - only returned when the flag to\\n collect image observations in the preference dataset is true and image observations are not\\n used to train the reward model\\n \\\"\\\"\\\"\\n # select the trajectories to be included in this batch of trajectory segments\\n trajectory_indices = np.random.choice(trajectory_count, size=mini_batch_size, replace=True)\\n\\n # accumulate the formatted state-action pairs and rewards from each trajectory segment\\n state_action_pairs = []\\n rewards = []\\n # optionally accumulate image observations\\n image_observations = ([] if self.collect_image_pref_dataset and not self.image_observations else None)\\n # extract each trajectory and randomly sample a segment\\n for traj_index in trajectory_indices:\\n # grab the trajectory\\n trajectory = experience_buffer.trajectories[traj_index]\\n # select a random segment from the trajectory\\n traj_segment = trajectory.random_segment(length=self.size_segment)\\n # track the rewards associated with the random segment\\n rewards.append(np.expand_dims(traj_segment.env_rewards, axis=0))\\n # format the state and action based on whether image observations are being used\\n if self.image_observations:\\n formatted_pair = self.state_action_formatter.format_state_action(\\n traj_segment.initial_image_observations,\\n traj_segment.actions,\\n batch_sa=True)\\n else:\\n formatted_pair = self.state_action_formatter.format_state_action(\\n traj_segment.initial_observations,\\n traj_segment.actions,\\n batch_sa=True)\\n if self.collect_image_pref_dataset:\\n image_observations.append(np.expand_dims(traj_segment.initial_image_observations, axis=0))\\n # add a dimension in the front so we can concatenate later and the track\\n state_action_pairs.append(np.expand_dims(formatted_pair, axis=0))\\n return (np.concatenate(state_action_pairs, axis=0),\\n np.concatenate(rewards, axis=0),\\n (np.concatenate(image_observations, axis=0) if image_observations is not None else None))\\n\\n @staticmethod\\n def get_rank_probability(trajectories_one: np.ndarray, trajectories_two: np.ndarray,\\n reward_model: torch.nn.Module):\\n \\\"\\\"\\\"\\n Compute the preference-prediction disagreement between the ensemble members for each trajectory pair\\n\\n Args:\\n trajectories_one: the trajectories one to be evaluated for ensemble disagreement\\n trajectories_two: the trajectories two to be evaluated for ensemble disagreement\\n reward_model: the ensemble of networks that will be used to compute disagreement\\n \\\"\\\"\\\"\\n\\n # get probability x_1 > x_2\\n probs = []\\n for member in range(len(reward_model.ensemble)):\\n probs.append(reward_model.p_hat_member(trajectories_one,\\n trajectories_two,\\n member=member).cpu().numpy())\\n probs = np.array(probs)\\n\\n return np.mean(probs, axis=0), np.std(probs, axis=0)\\n\\n def get_queries(self, experience_buffer: TrajectoryReplayBuffer, mb_size=20):\\n len_traj, max_len = experience_buffer.trajectory_lengths[0], experience_buffer.trajectory_count\\n\\n # if len(self.experience_buffer.trajectory_lengths[0][-1]) < len_traj:\\n # check that the last trajectory contains at least as many transitions as the target segment length\\n # we check the last trajectory, because it may be incomplete\\n # this is a carry over from the original code. The authors had an assumption that all \\\"completed\\\" trajectories\\n # will be at least as long as the target segment length\\n if experience_buffer.trajectory_lengths[-1] < self.size_segment:\\n max_len = max_len - 1\\n\\n # grab each trajectory, select a random segment from each, format the state-action pairs, and concatenate\\n # along the batch dimension\\n state_action_pair_traj_one, r_t_1, images_traj_one = self._sample_trajectory_segments_uniform(\\n experience_buffer=experience_buffer,\\n trajectory_count=max_len,\\n mini_batch_size=mb_size)\\n state_action_pair_traj_two, r_t_2, images_traj_two = self._sample_trajectory_segments_uniform(\\n experience_buffer=experience_buffer,\\n trajectory_count=max_len,\\n mini_batch_size=mb_size)\\n # confirm the image-specific variables are only populated when they should be\\n if not self.collect_image_pref_dataset and self.image_observations:\\n assert images_traj_one is None and images_traj_two is None\\n return state_action_pair_traj_one, state_action_pair_traj_two, r_t_1, r_t_2, images_traj_one, images_traj_two\\n\\n def put_queries(self, state_action_pair_traj_one: np.ndarray, state_action_pair_traj_two: np.ndarray,\\n preference_labels: np.ndarray,\\n images_traj_one: t.Optional[np.ndarray] = None, images_traj_two: t.Optional[np.ndarray] = None):\\n \\\"\\\"\\\"\\n Args:\\n state_action_pair_traj_one: the state-action pairs that make up the trajectories one in the queries\\n state_action_pair_traj_two: the state-action pairs that make up the trajectories two in the queries\\n preference_labels: the preference labels for each pair of trajectories\\n images_traj_one: the images for trajectories one\\n images_traj_two: the images for trajectories two\\n \\\"\\\"\\\"\\n # get the number of triplets to be stored\\n total_sample = state_action_pair_traj_one.shape[0]\\n # write each preference_triplet to disk\\n for batch_indx in range(total_sample):\\n # get the index of the triplet in the \\\"buffer\\\"\\n preference_triplet_index = self.buffer_index + batch_indx\\n # check if we need to wrap the buffer\\n if preference_triplet_index >= self.capacity:\\n preference_triplet_index -= self.capacity\\n elif not self.buffer_full:\\n # this is a previously unseen preference triplet buffer index, so we need to track the triplet location\\n self._preference_triplet_tracker.append(self.out_path / f\\\"preference_triplet_{preference_triplet_index}.npz\\\")\\n # save the preference triplet\\n np.savez((self.out_path / f\\\"preference_triplet_{preference_triplet_index}.npz\\\").as_posix(),\\n trajectory_one=state_action_pair_traj_one[batch_indx],\\n trajectory_two=state_action_pair_traj_two[batch_indx],\\n preference_label=preference_labels[batch_indx],\\n image_trajectory_one=(\\n None if images_traj_one is None else images_traj_one[batch_indx]),\\n image_trajectory_two=(\\n None if images_traj_two is None else images_traj_two[batch_indx]))\\n # set the new buffer index\\n next_index = self.buffer_index + total_sample\\n # check if the buffer has wrapped\\n if next_index >= self.capacity:\\n self.buffer_full = True\\n # wrap the buffer index\\n self.buffer_index = next_index - self.capacity\\n else:\\n self.buffer_index = next_index\\n\\n def uniform_sampling(self, experience_buffer: TrajectoryReplayBuffer, mb_size: int) -> int:\\n \\\"\\\"\\\"\\n Grow the preference dataset with preference triplets uniformly sampled from the experience buffer\\n\\n Args:\\n experience_buffer: the replay buffer from which to sample trajectory pairs\\n mb_size: target number of preference triplets to add to the preference dataset. Fewer than the target may\\n be added depending on the whether labeller skips labelling some trajectories.\\n Returns:\\n number of preference triplets added to the dataset\\n \\\"\\\"\\\"\\n # get queries\\n sa_t_1, sa_t_2, r_t_1, r_t_2, img_sa_t_1, img_sa_t_2 = self.get_queries(experience_buffer=experience_buffer,\\n mb_size=mb_size)\\n\\n # get labels\\n sa_t_1, sa_t_2, r_t_1, r_t_2, labels = self._preference_labeller.get_label(sa_t_1, sa_t_2, r_t_1, r_t_2)\\n if len(labels) > 0:\\n self.put_queries(sa_t_1, sa_t_2, labels, img_sa_t_1, img_sa_t_2)\\n\\n return len(labels)\\n\\n # TODO: refactor to break the circular import that would need to happen in order to specify that reward_model here\\n # should be BPref.reward_model.RewardModel\\n def disagreement_sampling(self, experience_buffer: TrajectoryReplayBuffer, mb_size: int, large_batch: int,\\n reward_model: torch.nn.Module) -> int:\\n \\\"\\\"\\\"\\n Grow the preference dataset with preference triplets from the experience buffer that the reward ensemble\\n disagrees about\\n\\n Args:\\n experience_buffer: the replay buffer from which to sample trajectory pairs\\n mb_size: target number of preference triplets to add to the preference dataset. Fewer than the target may\\n be added depending on the whether labeller skips labelling some trajectories.\\n large_batch: scales up the number of triplets to add to the preference dataset to uniformly select a large\\n number of trajectory pairs, which are then pruned based on which ones the reward ensemble\\n has the most disagreement over\\n reward_model: the ensemble of reward networks that will be used to assess disagreement.\\n Should be BPref.reward_model.RewardModel, but cannot import and reference from here right now\\n as it would lead to circular imports\\n Returns:\\n number of preference triplets added to the dataset\\n \\\"\\\"\\\"\\n # get queries\\n sa_t_1, sa_t_2, r_t_1, r_t_2, img_sa_t_1, img_sa_t_2 = self.get_queries(\\n experience_buffer=experience_buffer, mb_size=mb_size * large_batch)\\n\\n # get final queries based on ensemble member disagreement\\n _, disagree = self.get_rank_probability(sa_t_1, sa_t_2, reward_model=reward_model)\\n top_k_index = (-disagree).argsort()[:mb_size]\\n r_t_1, sa_t_1 = r_t_1[top_k_index], sa_t_1[top_k_index]\\n r_t_2, sa_t_2 = r_t_2[top_k_index], sa_t_2[top_k_index]\\n if img_sa_t_1 is not None:\\n img_sa_t_1 = img_sa_t_1[top_k_index]\\n img_sa_t_2 = img_sa_t_2[top_k_index]\\n\\n # get labels\\n sa_t_1, sa_t_2, r_t_1, r_t_2, labels = self._preference_labeller.get_label(\\n sa_t_1, sa_t_2, r_t_1, r_t_2)\\n if len(labels) > 0:\\n self.put_queries(sa_t_1, sa_t_2, labels, img_sa_t_1, img_sa_t_2)\\n\\n return len(labels)\\n\\n def set_teacher_thres_skip(self, new_margin):\\n self._preference_labeller.teacher_thres_skip = new_margin * self._preference_labeller.teacher_eps_skip\\n\\n def set_teacher_thres_equal(self, new_margin):\\n self._preference_labeller.teacher_eps_equal = new_margin * self._preference_labeller.teacher_eps_equal\\n\\n def save(self, dataset_dir: Path, env_id: str, step: int):\\n \\\"\\\"\\\"\\n Saves the preference dataset as a zip archive and the labeller configuration as a yaml to the specified location\\n\\n Args:\\n dataset_dir: path where the dataset is to be saved\\n env_id: the environment/task within which the data was generated\\n step: the number of policy training steps taken to produce this dataset\\n \\\"\\\"\\\"\\n # create the ZipFile object\\n zip_obj = ZipFile(dataset_dir / f\\\"{env_id}_preference_dataset_{step}.zip\\\", \\\"w\\\")\\n # the configuration for the online preference dataset\\n config = {\\\"teacher_params\\\": {\\\"teacher_beta\\\": self._preference_labeller.teacher_beta,\\n \\\"teacher_gamma\\\": self._preference_labeller.teacher_gamma,\\n \\\"teacher_eps_mistake\\\": self._preference_labeller.teacher_eps_mistake,\\n \\\"teacher_eps_equal\\\": self._preference_labeller.teacher_eps_equal,\\n \\\"teacher_eps_skip\\\": self._preference_labeller.teacher_eps_skip,\\n \\\"teacher_thres_skip\\\": self._preference_labeller.teacher_thres_skip,\\n \\\"teacher_thres_equal\\\": self._preference_labeller.teacher_thres_equal,\\n \\\"label_margin\\\": self._preference_labeller.label_margin,\\n \\\"label_target\\\": self._preference_labeller.label_target}}\\n with open((dataset_dir / f\\\"preference_dataset_config.yaml\\\").as_posix(), \\\"w+\\\") as f:\\n yaml.dump(config, f)\\n # write the labeller config to the preference dataset's zip archive\\n zip_obj.write(dataset_dir / f\\\"preference_dataset_config.yaml\\\")\\n\\n # add each preference triplet to the zip archive\\n for pref_triplet_path in self._preference_triplet_tracker:\\n zip_obj.write(pref_triplet_path)\\n # move the file from it temp location to the artifact directory\\n file_dest_path = dataset_dir / pref_triplet_path.name\\n shutil.move(pref_triplet_path, file_dest_path)\\n # close the Zip File\\n zip_obj.close()\"\n },\n {\n \"identifier\": \"PreferenceTripletEnsembleDataLoader\",\n \"path\": \"reed/data/preference_data_loader.py\",\n \"snippet\": \"class PreferenceTripletEnsembleDataLoader:\\n \\\"\\\"\\\"\\n Handles loading and generating batches of preference triplets.\\n\\n The special logic needed is to handle different batch orderings for different networks in the reward ensemble\\n \\\"\\\"\\\"\\n def __init__(self, dataset: PreferenceDataset, ensemble_size: int,\\n batch_size: int = 64, num_workers: int = 0, shuffle: bool = True, device: torch.device = \\\"cuda\\\"):\\n \\\"\\\"\\\"\\n Args:\\n\\n \\\"\\\"\\\"\\n # create a data loader per ensemble network\\n self.loader_ensemble = [DataLoader(dataset=dataset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n num_workers=num_workers)\\n for _ in range(ensemble_size)]\\n\\n self.device = device\\n\\n def _format_batch(self, batch: UNFORMATTED_PREFERENCE_TRIPLET_BATCH) -> FORMATTED_PREFERENCE_TRIPLET_BATCH:\\n \\\"\\\"\\\"\\n Format the preference batch so that the tensors are longs and on the correct device\\n \\\"\\\"\\\"\\n return [PreferenceTripletBatch(trajectories_one=member[0].float().to(self.device),\\n trajectories_two=member[1].float().to(self.device),\\n preference_labels=member[2].long().to(self.device))\\n for member in batch]\\n\\n def dataset_length(self) -> int:\\n return len(self.loader_ensemble[0].dataset)\\n\\n def __iter__(self) -> FORMATTED_PREFERENCE_TRIPLET_BATCH:\\n \\\"\\\"\\\"\\n Iterate through the preference triplet data loaders and return the batch per ensemble member\\n\\n Returns:\\n list of PreferenceTripletBatch\\n \\\"\\\"\\\"\\n # set up each loader as an iterator\\n iter_loader_ensemble = [iter(loader) for loader in self.loader_ensemble]\\n # for each data loader grab the next batch until there are no more batches to grab\\n while True:\\n # check if there is a next batch to return\\n try:\\n yield self._format_batch([next(dataloader_iterator) for dataloader_iterator in iter_loader_ensemble])\\n except StopIteration:\\n break\"\n },\n {\n \"identifier\": \"PreProcessInference\",\n \"path\": \"reed/data/preprocess_images.py\",\n \"snippet\": \"class PreProcessInference:\\n \\\"\\\"\\\"\\n Preprocess the data for inference by the reward, SSC, and SFC models\\n \\\"\\\"\\\"\\n def __init__(self,\\n image_observations: bool = False,\\n grayscale_images: bool = True,\\n normalize_images: bool = True,\\n environment_id: str = \\\"dmc\\\"):\\n \\\"\\\"\\\"\\n Args:\\n image_observations: whether the observations are images\\n grayscale_images: whether images observations should be in grayscale\\n normalize_images: whether the image observations should be normalized\\n environment_id: the environment from which the data is coming\\n \\\"\\\"\\\"\\n self.image_observations = image_observations\\n self.grayscale_images = grayscale_images\\n self.normalize_images = normalize_images\\n self.environment_id = environment_id\\n\\n @staticmethod\\n def _channel_first_to_last(observation: np.ndarray,\\n batch_states: bool = False,\\n by_trajectory: bool = False) -> np.ndarray:\\n \\\"\\\"\\\"\\n Move the channel from the first dimension to the last dimension\\n \\\"\\\"\\\"\\n if batch_states and by_trajectory:\\n return np.transpose(observation, (0, 1, 3, 4, 2))\\n elif batch_states:\\n return np.transpose(observation, (0, 2, 3, 1))\\n else:\\n return np.transpose(observation, (1, 2, 0))\\n\\n @staticmethod\\n def _channel_last_to_first(observation: np.ndarray, batch_states: bool = False,\\n by_trajectory: bool = False) -> np.ndarray:\\n \\\"\\\"\\\"\\n Move the channel from the last dimension to the first dimension\\n Args:\\n observation: the state observations\\n batch_states: whether a batch of state is to be processed\\n by_trajectory: whether the batch of states is structured by trajectory -> should only be\\n True when batch_sa=True\\n Returns:\\n the image with the channel dimension moved from first to last\\n \\\"\\\"\\\"\\n # permute the input so that the channels are in the first dimension of the images\\n if batch_states and by_trajectory:\\n return np.transpose(observation, (0, 1, 4, 2, 3))\\n elif batch_states:\\n return np.transpose(observation, (0, 3, 1, 2))\\n else:\\n # permute the input so that the channels are in the first dimension\\n obs = np.transpose(observation, (2, 0, 1))\\n # add a dimension along the front for concatenation into the buffer\\n return np.expand_dims(obs, axis=0)\\n\\n def format_state(self, obs: np.ndarray, batch_states: bool = False,\\n by_trajectory: bool = False, channel_first: bool = False) -> np.ndarray:\\n \\\"\\\"\\\"\\n Args:\\n obs: the state observations\\n batch_states: whether a batch of state is to be processed\\n by_trajectory: whether the batch of states is structured by trajectory -> should only be\\n True when batch_sa=True\\n channel_first: whether the channel dimension is first when the observations are images.\\n Returns:\\n the state-action pairs as a single array\\n \\\"\\\"\\\"\\n if self.image_observations:\\n if channel_first:\\n # move the channel dimension from first to last to avoid a bunch of logic in our formatting methods\\n # that handles variable locations for the channel dimension\\n obs = self._channel_first_to_last(observation=obs,\\n batch_states=batch_states,\\n by_trajectory=by_trajectory)\\n if self.grayscale_images:\\n obs = _to_grayscale(observation=obs)\\n if self.normalize_images:\\n # TODO: add normalization based on pixel mean and standard deviation instead of scaling 0 to 1\\n obs = np.divide(obs, 255.)\\n # move the channel dimension from first to last\\n return self._channel_last_to_first(observation=obs, batch_states=batch_states, by_trajectory=by_trajectory)\\n\\n else:\\n return obs.reshape(1, obs.shape[1:]) if batch_states else obs.reshape(1, obs.shape[0])\\n\\n def format_state_action(self, obs: np.ndarray, act: np.ndarray,\\n batch_sa: bool = False, by_trajectory: bool = False,\\n channel_first: bool = False) -> np.ndarray:\\n \\\"\\\"\\\"\\n Args:\\n obs: the state observations\\n act: the actions associated with each state observation\\n batch_sa: whether a batch of state-action pairs is to be processed\\n by_trajectory: whether the batch of state-action pairs is structured by trajectory -> should only be\\n True when batch_sa=True\\n channel_first: whether the channel dimension is first when the observations are images.\\n Returns:\\n the state-action pairs as a single array\\n \\\"\\\"\\\"\\n if self.image_observations:\\n if channel_first:\\n # move the channel dimension from first to last to avoid a bunch of logic in our formatting methods\\n # that handles variable locations for the channel dimension\\n obs = self._channel_first_to_last(observation=obs,\\n batch_states=batch_sa,\\n by_trajectory=by_trajectory)\\n if self.grayscale_images:\\n obs = _to_grayscale(observation=obs)\\n if self.normalize_images:\\n # TODO: add normalization based on pixel mean and standard deviation instead of scaling 0 to 1\\n obs = np.divide(obs, 255.)\\n\\n # get the dimensions of the image\\n obs_dim = obs.shape[-3:]\\n assert len(obs_dim) == 3\\n # add the actions to the image channels and permute the input so that the channels are in the first\\n # dimension of the images\\n if batch_sa and by_trajectory:\\n repeated_actions = np.tile(act.reshape((act.shape[0], act.shape[1], 1, 1, act.shape[-1])),\\n (1, 1, obs_dim[0], obs_dim[1], 1))\\n elif batch_sa:\\n repeated_actions = np.tile(act.reshape((act.shape[0], 1, 1, act.shape[-1])),\\n (1, obs_dim[0], obs_dim[1], 1))\\n else:\\n repeated_actions = np.tile(act.reshape((1, 1, -1)), (obs_dim[0], obs_dim[1], 1))\\n sa_t = np.concatenate((obs, repeated_actions), axis=-1)\\n return self._channel_last_to_first(sa_t, batch_states=batch_sa, by_trajectory=by_trajectory)\\n else:\\n sa_t = np.concatenate([obs, act], axis=-1)\\n if batch_sa:\\n return sa_t\\n else:\\n return sa_t.reshape(1, -1)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import typing as t\nimport time\nimport numpy as np\nimport torch\nimport hydra\nfrom pathlib import Path\nfrom omegaconf import dictconfig, OmegaConf\nfrom BPref import utils\nfrom BPref.logger import Logger\nfrom BPref.replay_buffer import TrajectoryReplayBuffer\nfrom collections import deque\nfrom reed.models.reward_model import StateActionRewardModel\nfrom reed.data.preference_dataset import PreferenceDataset\nfrom reed.data.preference_data_loader import PreferenceTripletEnsembleDataLoader\nfrom reed.data.preprocess_images import PreProcessInference"},"token_num":{"kind":"number","value":19294,"string":"19,294"},"cropped_code":{"kind":"string","value":"#\n# For licensing see accompanying LICENSE file.\n# Copyright (C) 2023 Apple Inc. All Rights Reserved.\n#\n\n\n\n\n\n\n\nclass PEBBLE:\n \"\"\"\n Train a reward model in conjunction with policy training following the PEBBLE algorithm from (Lee et al. 2021)\n \"\"\"\n\n def __init__(self, experiment_config: dictconfig.DictConfig):\n \"\"\"\n Args:\n experiment_config: contains the configuration for the experiment to be run. Access like a dictionry\n \"\"\"\n # track the experimental configuration\n self.experiment_config = experiment_config\n\n # create the logger to track policy learning progress\n self.logger = Logger(\n self.experiment_config.out_dir,\n save_tb=self.experiment_config.log_save_tb,\n log_frequency=self.experiment_config.log_frequency,\n agent=self.experiment_config.agent.name)\n\n # used to track where we are in training\n # total amount of feedback the reward model has solicited\n self.total_feedback = 0\n # total amount of feedback given to the reward model\n self.labeled_feedback = 0\n # policy train step\n self.step = 0\n\n # we need to set the random seed for replication purposes\n utils.set_seed_everywhere(self.experiment_config.seed)\n\n # the device on which models will be trained\n self.device = torch.device(self.experiment_config.device)\n # flag to make sure we are handling multi-gpu training where we need to\n self.multi_gpu = torch.cuda.device_count() > 1\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(f\"There is {torch.cuda.device_count()} GPU, so models will be trained with torch.nn.DataParallel.\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n\n # make the environment\n if 'metaworld' in self.experiment_config.env:\n self.env = utils.make_metaworld_env(self.experiment_config)\n # we are not evaluating a domain where we need to log whether an agent has reached a goal state\n self.log_success = True\n else:\n self.env = utils.make_env(self.experiment_config)\n # we are not evaluating a domain where we need to log whether an agent has reached a goal state\n self.log_success = False\n print('----------------------')\n print('----------------------')\n print('----------------------')\n print('----------------------')\n print(\"observation space \", self.env.observation_space.shape[0])\n print(\"action space \", self.env.action_space.shape[0])\n print('----------------------')\n print('----------------------')\n print('----------------------')\n print('----------------------')\n # we need to set the policy's observation and action space\n self.experiment_config.agent.params.obs_dim = self.env.observation_space.shape[0]\n self.experiment_config.agent.params.action_dim = self.env.action_space.shape[0]\n self.experiment_config.agent.params.action_range = [\n float(self.env.action_space.low.min()),\n float(self.env.action_space.high.max())\n ]\n # create the agent specified in the configuration\n self.agent = hydra.utils.instantiate(self.experiment_config.agent)\n\n # the class that will format the observations and observation action pairs for consumption by the reward model\n"},"all_code":{"kind":"string","value":"#\n# For licensing see accompanying LICENSE file.\n# Copyright (C) 2023 Apple Inc. All Rights Reserved.\n#\n\n\n\n\n\n\n\nclass PEBBLE:\n \"\"\"\n Train a reward model in conjunction with policy training following the PEBBLE algorithm from (Lee et al. 2021)\n \"\"\"\n\n def __init__(self, experiment_config: dictconfig.DictConfig):\n \"\"\"\n Args:\n experiment_config: contains the configuration for the experiment to be run. Access like a dictionry\n \"\"\"\n # track the experimental configuration\n self.experiment_config = experiment_config\n\n # create the logger to track policy learning progress\n self.logger = Logger(\n self.experiment_config.out_dir,\n save_tb=self.experiment_config.log_save_tb,\n log_frequency=self.experiment_config.log_frequency,\n agent=self.experiment_config.agent.name)\n\n # used to track where we are in training\n # total amount of feedback the reward model has solicited\n self.total_feedback = 0\n # total amount of feedback given to the reward model\n self.labeled_feedback = 0\n # policy train step\n self.step = 0\n\n # we need to set the random seed for replication purposes\n utils.set_seed_everywhere(self.experiment_config.seed)\n\n # the device on which models will be trained\n self.device = torch.device(self.experiment_config.device)\n # flag to make sure we are handling multi-gpu training where we need to\n self.multi_gpu = torch.cuda.device_count() > 1\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(f\"There is {torch.cuda.device_count()} GPU, so models will be trained with torch.nn.DataParallel.\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n print(\"----------------------------------------\")\n\n # make the environment\n if 'metaworld' in self.experiment_config.env:\n self.env = utils.make_metaworld_env(self.experiment_config)\n # we are not evaluating a domain where we need to log whether an agent has reached a goal state\n self.log_success = True\n else:\n self.env = utils.make_env(self.experiment_config)\n # we are not evaluating a domain where we need to log whether an agent has reached a goal state\n self.log_success = False\n print('----------------------')\n print('----------------------')\n print('----------------------')\n print('----------------------')\n print(\"observation space \", self.env.observation_space.shape[0])\n print(\"action space \", self.env.action_space.shape[0])\n print('----------------------')\n print('----------------------')\n print('----------------------')\n print('----------------------')\n # we need to set the policy's observation and action space\n self.experiment_config.agent.params.obs_dim = self.env.observation_space.shape[0]\n self.experiment_config.agent.params.action_dim = self.env.action_space.shape[0]\n self.experiment_config.agent.params.action_range = [\n float(self.env.action_space.low.min()),\n float(self.env.action_space.high.max())\n ]\n # create the agent specified in the configuration\n self.agent = hydra.utils.instantiate(self.experiment_config.agent)\n\n # the class that will format the observations and observation action pairs for consumption by the reward model"},"next_line":{"kind":"string","value":" self._reward_input_preprocessor = PreProcessInference("},"gold_snippet_index":{"kind":"number","value":6,"string":"6"},"created_at":{"kind":"string","value":"2023-11-06 23:14:20+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5966,"cells":{"repo_name":{"kind":"string","value":"alibaba/animate-anything"},"file_path":{"kind":"string","value":"train_svd.py"},"context":{"kind":"list like","value":[{"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: str = \"./data\",\n video_json: str = \"\",\n fallback_prompt: str = \"\",\n use_bucketing: bool = False,\n cache_latents = False,\n motion_threshold = 50,\n **kwargs\n ):\n self.tokenizer = tokenizer\n self.use_bucketing = use_bucketing\n\n self.fallback_prompt = fallback_prompt\n self.video_dir = video_dir\n self.video_files = json.load(open(video_json))\n\n self.width = width\n self.height = height\n\n self.n_sample_frames = n_sample_frames\n self.fps = fps\n self.cache_latents = cache_latents\n self.motion_threshold = motion_threshold\n self.transform = T.Compose([\n #T.RandomResizedCrop(size=(height, width), scale=(0.8, 1.0), ratio=(width/height, width/height), antialias=False),\n T.Resize(min(height, width), antialias=False),\n T.CenterCrop([height, width])\n ])\n\n\n def get_frame_buckets(self, vr):\n _, h, w = vr[0].shape \n width, height = sensible_buckets(self.width, self.height, h, w)\n resize = T.transforms.Resize((height, width), antialias=True)\n\n return resize\n\n \n @staticmethod\n def __getname__(): return 'video_json'\n\n def __len__(self):\n return len(self.video_files)\n\n def __getitem__(self, index):\n mask = None\n try:\n item = self.video_files[index]\n video_path = os.path.join(self.video_dir, item['video'])\n cache_path = os.path.splitext(video_path)[0] + '.pt'\n if self.cache_latents and os.path.exists(cache_path):\n return torch.load(cache_path, map_location='cpu')\n\n prompt = item['caption']\n if self.fallback_prompt == \"<no_text>\":\n prompt = \"\"\n vr = decord.VideoReader(video_path)\n video = get_frame_batch(self.n_sample_frames, self.fps, vr, self.transform)\n except Exception as err:\n print(\"read video error\", err, video_path)\n return self.__getitem__(index+1)\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\n\n example = {\n \"pixel_values\": normalize_input(video), \n \"prompt_ids\": prompt_ids, \n \"text_prompt\": prompt, \n 'cache_path': cache_path,\n 'dataset': self.__getname__()\n }\n mask = get_moved_area_mask(video.permute([0,2,3,1]).numpy())\n example['motion'] = calculate_motion_score(video.permute([0,2,3,1]).numpy())\n if example['motion'] < self.motion_threshold:\n return self.__getitem__(random.randint(0, len(self)-1))\n return example"},{"identifier":"SingleVideoDataset","path":"utils/dataset.py","snippet":"class SingleVideoDataset(Dataset):\n def __init__(\n self,\n tokenizer = None,\n width: int = 256,\n height: int = 256,\n n_sample_frames: int = 4,\n frame_step: int = 1,\n single_video_path: str = \"\",\n single_video_prompt: str = \"\",\n use_caption: bool = False,\n use_bucketing: bool = False,\n **kwargs\n ):\n self.tokenizer = tokenizer\n self.use_bucketing = use_bucketing\n self.frames = []\n self.index = 1\n\n self.vid_types = (\".mp4\", \".avi\", \".mov\", \".webm\", \".flv\", \".mjpeg\")\n self.n_sample_frames = n_sample_frames\n self.frame_step = frame_step\n\n self.single_video_path = single_video_path\n self.single_video_prompt = single_video_prompt\n\n self.width = width\n self.height = height\n def create_video_chunks(self):\n # Create a list of frames separated by sample frames\n # [(1,2,3), (4,5,6), ...]\n vr = decord.VideoReader(self.single_video_path)\n vr_range = range(1, len(vr), self.frame_step)\n\n self.frames = list(self.chunk(vr_range, self.n_sample_frames))\n\n # Delete any list that contains an out of range index.\n for i, inner_frame_nums in enumerate(self.frames):\n for frame_num in inner_frame_nums:\n if frame_num > len(vr):\n print(f\"Removing out of range index list at position: {i}...\")\n del self.frames[i]\n\n return self.frames\n\n def chunk(self, it, size):\n it = iter(it)\n return iter(lambda: tuple(islice(it, size)), ())\n\n def get_frame_batch(self, vr, resize=None):\n index = self.index\n frames = vr.get_batch(self.frames[self.index])\n video = rearrange(frames, \"f h w c -> f c h w\")\n\n if resize is not None: video = resize(video)\n return video\n\n def get_frame_buckets(self, vr):\n _, h, w = vr[0].shape \n width, height = sensible_buckets(self.width, self.height, h, w)\n resize = T.transforms.Resize((height, width), antialias=True)\n\n return resize\n \n def process_video_wrapper(self, vid_path):\n video, vr = process_video(\n vid_path,\n self.use_bucketing,\n self.width, \n self.height, \n self.get_frame_buckets, \n self.get_frame_batch\n )\n \n return video, vr \n\n def single_video_batch(self, index):\n train_data = self.single_video_path\n self.index = index\n\n if train_data.endswith(self.vid_types):\n video, _ = self.process_video_wrapper(train_data)\n\n prompt = self.single_video_prompt\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\n\n return video, prompt, prompt_ids\n else:\n raise ValueError(f\"Single video is not a video type. Types: {self.vid_types}\")\n \n @staticmethod\n def __getname__(): return 'single_video'\n\n def __len__(self):\n \n return len(self.create_video_chunks())\n\n def __getitem__(self, index):\n\n video, prompt, prompt_ids = self.single_video_batch(index)\n\n example = {\n \"pixel_values\": normalize_input(video),\n \"prompt_ids\": prompt_ids,\n \"text_prompt\": prompt,\n 'dataset': self.__getname__()\n }\n\n return example"},{"identifier":"ImageDataset","path":"utils/dataset.py","snippet":"class ImageDataset(Dataset):\n \n def __init__(\n self,\n tokenizer = None,\n width: int = 256,\n height: int = 256,\n base_width: int = 256,\n base_height: int = 256,\n use_caption: bool = False,\n image_dir: str = '',\n single_img_prompt: str = '',\n use_bucketing: bool = False,\n fallback_prompt: str = '',\n **kwargs\n ):\n self.tokenizer = tokenizer\n self.img_types = (\".png\", \".jpg\", \".jpeg\", '.bmp')\n self.use_bucketing = use_bucketing\n #self.image_dir = self.get_images_list(image_dir)\n self.image_dir_path = image_dir\n self.image_dir = json.load(open(kwargs['image_json']))\n self.fallback_prompt = fallback_prompt\n\n self.use_caption = use_caption\n self.single_img_prompt = single_img_prompt\n\n self.width = width\n self.height = height\n\n def get_images_list(self, image_dir):\n if os.path.exists(image_dir):\n imgs = [x for x in os.listdir(image_dir) if x.endswith(self.img_types)]\n full_img_dir = []\n\n for img in imgs: \n full_img_dir.append(f\"{image_dir}/{img}\")\n\n return sorted(full_img_dir)\n\n return ['']\n\n def image_batch(self, index):\n train_data = self.image_dir[index]\n img, prompt = train_data['image'], train_data['caption']\n img = os.path.join(self.image_dir_path, img)\n try:\n img = torchvision.io.read_image(img, mode=torchvision.io.ImageReadMode.RGB)\n except:\n img = T.transforms.PILToTensor()(Image.open(img).convert(\"RGB\"))\n\n width = self.width\n height = self.height\n\n if self.use_bucketing:\n _, h, w = img.shape\n width, height = sensible_buckets(width, height, w, h)\n \n resize = T.transforms.Resize((height, width), antialias=True)\n\n img = resize(img) \n img = repeat(img, 'c h w -> f c h w', f=1)\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\n\n return img, prompt, prompt_ids\n\n @staticmethod\n def __getname__(): return 'image'\n \n def __len__(self):\n # Image directory\n return len(self.image_dir)\n\n def __getitem__(self, index):\n img, prompt, prompt_ids = self.image_batch(index)\n example = {\n \"pixel_values\": normalize_input(img),\n \"frames\": img,\n \"prompt_ids\": prompt_ids,\n \"text_prompt\": prompt, \n 'dataset': self.__getname__()\n }\n\n return example"},{"identifier":"VideoFolderDataset","path":"utils/dataset.py","snippet":"class VideoFolderDataset(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 path: str = \"./data\",\n fallback_prompt: str = \"\",\n use_bucketing: bool = False,\n **kwargs\n ):\n self.tokenizer = tokenizer\n self.use_bucketing = use_bucketing\n\n self.fallback_prompt = fallback_prompt\n\n self.video_files = glob(f\"{path}/*.mp4\")\n\n self.width = width\n self.height = height\n\n self.n_sample_frames = n_sample_frames\n self.fps = fps\n\n def get_frame_buckets(self, vr):\n _, h, w = vr[0].shape \n width, height = sensible_buckets(self.width, self.height, h, w)\n resize = T.transforms.Resize((height, width), antialias=True)\n\n return resize\n\n def get_frame_batch(self, vr, resize=None):\n n_sample_frames = self.n_sample_frames\n native_fps = vr.get_avg_fps()\n \n every_nth_frame = max(1, round(native_fps / self.fps))\n every_nth_frame = min(len(vr), every_nth_frame)\n \n effective_length = len(vr) // every_nth_frame\n if effective_length < n_sample_frames:\n n_sample_frames = effective_length\n raise RuntimeError(\"not enough frames\")\n\n effective_idx = random.randint(0, (effective_length - n_sample_frames))\n idxs = every_nth_frame * np.arange(effective_idx, effective_idx + n_sample_frames)\n\n video = vr.get_batch(idxs)\n video = rearrange(video, \"f h w c -> f c h w\")\n\n if resize is not None: video = resize(video)\n return video, vr\n \n def process_video_wrapper(self, vid_path):\n video, vr = process_video(\n vid_path,\n self.use_bucketing,\n self.width, \n self.height, \n self.get_frame_buckets, \n self.get_frame_batch\n )\n return video, vr\n \n @staticmethod\n def __getname__(): return 'folder'\n\n def __len__(self):\n return len(self.video_files)\n\n def __getitem__(self, index):\n try:\n video, _ = self.process_video_wrapper(self.video_files[index])\n except Exception as err:\n print(\"read video error\", self.video_files[index])\n video, _ = self.process_video_wrapper(self.video_files[index+1])\n\n if os.path.exists(self.video_files[index].replace(\".mp4\", \".txt\")):\n with open(self.video_files[index].replace(\".mp4\", \".txt\"), \"r\") as f:\n lines = f.readlines()\n prompt = random.choice(lines)\n else:\n prompt = self.fallback_prompt\n\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\n\n return {\"pixel_values\": normalize_input(video[0]), \"frames\": video[0],\n \"prompt_ids\": prompt_ids, \"text_prompt\": prompt, 'dataset': self.__getname__()}"},{"identifier":"CachedDataset","path":"utils/dataset.py","snippet":"class CachedDataset(Dataset):\n def __init__(self,cache_dir: str = ''):\n self.cache_dir = cache_dir\n self.cached_data_list = self.get_files_list()\n\n def get_files_list(self):\n tensors_list = [f\"{self.cache_dir}/{x}\" for x in os.listdir(self.cache_dir) if x.endswith('.pt')]\n return sorted(tensors_list)\n\n def __len__(self):\n return len(self.cached_data_list)\n\n def __getitem__(self, index):\n cached_latent = torch.load(self.cached_data_list[index], map_location='cuda:0')\n return cached_latent"},{"identifier":"VideoBLIPDataset","path":"utils/dataset.py","snippet":"class VideoBLIPDataset(Dataset):\n def __init__(\n self,\n tokenizer = None,\n width: int = 256,\n height: int = 256,\n n_sample_frames: int = 4,\n sample_start_idx: int = 1,\n fps: int = 1,\n json_path: str =\"\",\n json_data = None,\n vid_data_key: str = \"video_path\",\n preprocessed: bool = False,\n use_bucketing: bool = False,\n cache_latents: bool = False,\n motion_threshold = 50,\n **kwargs\n ):\n self.vid_types = (\".mp4\", \".avi\", \".mov\", \".webm\", \".flv\", \".mjpeg\")\n self.use_bucketing = use_bucketing\n self.tokenizer = tokenizer\n self.preprocessed = preprocessed\n \n self.vid_data_key = vid_data_key\n self.train_data = self.load_from_json(json_path, json_data)\n self.cache_latents = cache_latents\n self.motion_threshold = motion_threshold\n self.width = width\n self.height = height\n\n self.n_sample_frames = n_sample_frames\n self.sample_start_idx = sample_start_idx\n self.fps = fps\n self.transform = T.Compose([\n #T.RandomResizedCrop(size=(height, width), scale=(0.8, 1.0), ratio=(width/height, width/height), antialias=False)\n T.Resize(min(height, width), antialias=False),\n T.CenterCrop([height, width])\n ])\n\n def build_json(self, json_data):\n extended_data = []\n for data in json_data['data']:\n for nested_data in data['data']:\n self.build_json_dict(\n data, \n nested_data, \n extended_data\n )\n json_data = extended_data\n return json_data\n\n def build_json_dict(self, data, nested_data, extended_data):\n clip_path = nested_data['clip_path'] if 'clip_path' in nested_data else None\n \n extended_data.append({\n self.vid_data_key: data[self.vid_data_key],\n 'frame_index': nested_data['frame_index'],\n 'prompt': nested_data['prompt'],\n 'clip_path': clip_path\n })\n \n def load_from_json(self, path, json_data):\n try:\n with open(path) as jpath:\n print(f\"Loading JSON from {path}\")\n json_data = json.load(jpath)\n\n return self.build_json(json_data)\n\n except:\n import traceback\n traceback.print_exc()\n self.train_data = []\n print(\"Non-existant JSON path. Skipping.\")\n \n def validate_json(self, base_path, path):\n return os.path.exists(f\"{base_path}/{path}\")\n\n def get_frame_buckets(self, vr):\n _, h, w = vr[0].shape \n width, height = sensible_buckets(self.width, self.height, h, w)\n resize = T.transforms.Resize((height, width), antialias=True)\n\n return resize\n\n def train_data_batch(self, index):\n vid_data = self.train_data[index]\n # Get video prompt\n prompt = vid_data['prompt']\n # If we are training on individual clips.\n if 'clip_path' in self.train_data[index] and \\\n self.train_data[index]['clip_path'] is not None:\n clip_path = vid_data['clip_path']\n else:\n clip_path = vid_data[self.vid_data_key]\n # Get the frame of the current index.\n self.sample_start_idx = vid_data['frame_index']\n cache_path = os.path.splitext(clip_path)[0] + '.pt'\n if self.cache_latents and os.path.exists(cache_path):\n return torch.load(cache_path, map_location='cpu')\n\n vr = decord.VideoReader(clip_path)\n video = get_frame_batch(self.n_sample_frames, self.fps, vr, self.transform)\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\n example = {\n \"pixel_values\": normalize_input(video),\n \"prompt_ids\": prompt_ids,\n \"text_prompt\": prompt,\n 'dataset': self.__getname__(),\n 'cache_path': cache_path,\n }\n mask = get_moved_area_mask(video.permute([0,2,3,1]).numpy())\n example['mask'] = mask\n example['motion'] = calculate_motion_score(video.permute([0,2,3,1]).numpy())\n return example\n \n\n @staticmethod\n def __getname__(): return 'video_blip'\n\n def __len__(self):\n if self.train_data is not None:\n return len(self.train_data)\n else: \n return 0\n\n def __getitem__(self, index):\n example = self.train_data_batch(index)\n if example['motion'] < self.motion_threshold:\n return self.__getitem__(random.randint(0, len(self)-1))\n return example"},{"identifier":"UNet3DConditionModel","path":"models/unet_3d_condition_mask.py","snippet":"class UNet3DConditionModel(ModelMixin, ConfigMixin):\n r\"\"\"\n UNet3DConditionModel is a conditional 2D UNet model that takes in a noisy sample, conditional state, and a timestep\n and returns sample shaped output.\n\n This model inherits from [`ModelMixin`]. Check the superclass documentation for the generic methods the library\n implements for all the models (such as downloading or saving, etc.)\n\n Parameters:\n sample_size (`int` or `Tuple[int, int]`, *optional*, defaults to `None`):\n Height and width of input/output sample.\n in_channels (`int`, *optional*, defaults to 4): The number of channels in the input sample.\n out_channels (`int`, *optional*, defaults to 4): The number of channels in the output.\n down_block_types (`Tuple[str]`, *optional*, defaults to `(\"CrossAttnDownBlock2D\", \"CrossAttnDownBlock2D\", \"CrossAttnDownBlock2D\", \"DownBlock2D\")`):\n The tuple of downsample blocks to use.\n up_block_types (`Tuple[str]`, *optional*, defaults to `(\"UpBlock2D\", \"CrossAttnUpBlock2D\", \"CrossAttnUpBlock2D\", \"CrossAttnUpBlock2D\",)`):\n The tuple of upsample blocks to use.\n block_out_channels (`Tuple[int]`, *optional*, defaults to `(320, 640, 1280, 1280)`):\n The tuple of output channels for each block.\n layers_per_block (`int`, *optional*, defaults to 2): The number of layers per block.\n downsample_padding (`int`, *optional*, defaults to 1): The padding to use for the downsampling convolution.\n mid_block_scale_factor (`float`, *optional*, defaults to 1.0): The scale factor to use for the mid block.\n act_fn (`str`, *optional*, defaults to `\"silu\"`): The activation function to use.\n norm_num_groups (`int`, *optional*, defaults to 32): The number of groups to use for the normalization.\n If `None`, it will skip the normalization and activation layers in post-processing\n norm_eps (`float`, *optional*, defaults to 1e-5): The epsilon to use for the normalization.\n cross_attention_dim (`int`, *optional*, defaults to 1280): The dimension of the cross attention features.\n attention_head_dim (`int`, *optional*, defaults to 8): The dimension of the attention heads.\n \"\"\"\n\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 down_block_types: Tuple[str] = (\n \"CrossAttnDownBlock3D\",\n \"CrossAttnDownBlock3D\",\n \"CrossAttnDownBlock3D\",\n \"DownBlock3D\",\n ),\n up_block_types: Tuple[str] = (\"UpBlock3D\", \"CrossAttnUpBlock3D\", \"CrossAttnUpBlock3D\", \"CrossAttnUpBlock3D\"),\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: Optional[int] = 32,\n norm_eps: float = 1e-5,\n cross_attention_dim: int = 1024,\n attention_head_dim: Union[int, Tuple[int]] = 64,\n motion_mask = False,\n motion_strength = False,\n ):\n super().__init__()\n self.motion_mask = motion_mask\n self.motion_strength = motion_strength\n print(f\"motion mask {self.motion_mask}, motion_strength {self.motion_strength}\")\n self.sample_size = sample_size\n self.gradient_checkpointing = False\n # Check inputs\n if len(down_block_types) != len(up_block_types):\n raise ValueError(\n f\"Must provide the same number of `down_block_types` as `up_block_types`. `down_block_types`: {down_block_types}. `up_block_types`: {up_block_types}.\"\n )\n\n if len(block_out_channels) != len(down_block_types):\n raise ValueError(\n f\"Must provide the same number of `block_out_channels` as `down_block_types`. `block_out_channels`: {block_out_channels}. `down_block_types`: {down_block_types}.\"\n )\n\n if not isinstance(attention_head_dim, int) and len(attention_head_dim) != len(down_block_types):\n raise ValueError(\n f\"Must provide the same number of `attention_head_dim` as `down_block_types`. `attention_head_dim`: {attention_head_dim}. `down_block_types`: {down_block_types}.\"\n )\n\n # input\n conv_in_kernel = 3\n conv_out_kernel = 3\n conv_in_padding = (conv_in_kernel - 1) // 2\n self.conv_in = nn.Conv2d(\n in_channels, block_out_channels[0], kernel_size=conv_in_kernel, padding=conv_in_padding\n )\n self.conv_in2 = nn.Conv2d(\n 5, block_out_channels[0], kernel_size=conv_in_kernel, padding=conv_in_padding\n )\n\n # time\n time_embed_dim = block_out_channels[0] * 4\n self.time_proj = Timesteps(block_out_channels[0], True, 0)\n timestep_input_dim = block_out_channels[0]\n\n self.time_embedding = TimestepEmbedding(\n timestep_input_dim,\n time_embed_dim,\n act_fn=act_fn,\n cond_proj_dim=block_out_channels[0],\n )\n\n self.motion_proj = Timesteps(block_out_channels[0], True, 0)\n self.motion_embedding = nn.Sequential(\n nn.Linear(timestep_input_dim, time_embed_dim), nn.SiLU(),\n nn.Linear(time_embed_dim, time_embed_dim))\n nn.init.zeros_(self.motion_embedding[-1].weight)\n nn.init.zeros_(self.motion_embedding[-1].bias)\n\n self.transformer_in = TransformerTemporalModel(\n num_attention_heads=8,\n attention_head_dim=attention_head_dim,\n in_channels=block_out_channels[0],\n num_layers=1,\n )\n\n # class embedding\n self.down_blocks = nn.ModuleList([])\n self.up_blocks = nn.ModuleList([])\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 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=False,\n )\n self.down_blocks.append(down_block)\n\n # mid\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 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=False,\n )\n # count how many layers upsample the images\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\n output_channel = reversed_block_out_channels[0]\n for i, up_block_type in enumerate(up_block_types):\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=False,\n )\n self.up_blocks.append(up_block)\n prev_output_channel = output_channel\n\n # out\n if norm_num_groups is not None:\n self.conv_norm_out = nn.GroupNorm(\n num_channels=block_out_channels[0], num_groups=norm_num_groups, eps=norm_eps\n )\n self.conv_act = nn.SiLU()\n else:\n self.conv_norm_out = None\n self.conv_act = None\n\n conv_out_padding = (conv_out_kernel - 1) // 2\n self.conv_out = nn.Conv2d(\n block_out_channels[0], out_channels, kernel_size=conv_out_kernel, padding=conv_out_padding\n )\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, value=False):\n self.gradient_checkpointing = value\n self.mid_block.gradient_checkpointing = value\n for module in self.down_blocks + self.up_blocks:\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 condition_latent: torch.Tensor,\n mask: torch.Tensor,\n class_labels: Optional[torch.Tensor] = None,\n timestep_cond: Optional[torch.Tensor] = None,\n attention_mask: Optional[torch.Tensor] = None,\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\n down_block_additional_residuals: Optional[Tuple[torch.Tensor]] = None,\n mid_block_additional_residual: Optional[torch.Tensor] = None,\n motion = None,\n return_dict: bool = True,\n ) -> Union[UNet3DConditionOutput, Tuple]:\n r\"\"\"\n Args:\n sample (`torch.FloatTensor`): (batch, num_frames, 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.UNet3DConditionOutput`] instead of a plain tuple.\n cross_attention_kwargs (`dict`, *optional*):\n A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under\n `self.processor` in\n [diffusers.cross_attention](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py).\n\n Returns:\n [`~models.unet_2d_condition.UNet3DConditionOutput`] or `tuple`:\n [`~models.unet_2d_condition.UNet3DConditionOutput`] 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 sample = torch.cat([condition_latent, sample], dim=2)\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 # 1. time\n timesteps = timestep\n if not torch.is_tensor(timesteps):\n # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can\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 num_frames = sample.shape[2]\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 if self.motion_strength and motion is not None:\n timestep_cond = self.motion_proj(motion).to(dtype=self.dtype)\n emb = self.time_embedding(t_emb, timestep_cond)\n #emb += self.motion_embedding(m_emb)\n else:\n emb = self.time_embedding(t_emb, timestep_cond)\n emb = emb.repeat_interleave(repeats=num_frames, dim=0)\n encoder_hidden_states = encoder_hidden_states.repeat_interleave(repeats=num_frames, dim=0)\n\n # 2. pre-process\n if self.motion_mask and mask is not None:\n mask = repeat(mask , 'b 1 1 h w -> (t b) 1 f h w', t=sample.shape[0]//mask.shape[0], f=sample.shape[2])\n sample = torch.cat([mask, sample], dim=1)\n sample = sample.permute(0, 2, 1, 3, 4).reshape((sample.shape[0] * num_frames, -1) + sample.shape[3:])\n sample = self.conv_in2(sample)\n else:\n sample = sample.permute(0, 2, 1, 3, 4).reshape((sample.shape[0] * num_frames, -1) + sample.shape[3:])\n sample = self.conv_in(sample)\n\n if num_frames > 1:\n if self.gradient_checkpointing:\n sample = transformer_g_c(self.transformer_in, sample, num_frames)\n else:\n sample = self.transformer_in(sample, num_frames=num_frames).sample\n\n # 3. down\n down_block_res_samples = (sample,)\n for i, downsample_block in enumerate(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 num_frames=num_frames,\n cross_attention_kwargs=cross_attention_kwargs,\n )\n else:\n sample, res_samples = downsample_block(hidden_states=sample, temb=emb, num_frames=num_frames)\n \n down_block_res_samples += res_samples\n\n if down_block_additional_residuals is not None:\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 += (down_block_res_sample,)\n\n down_block_res_samples = new_down_block_res_samples\n\n # 4. mid\n if self.mid_block is not None:\n sample = self.mid_block(\n sample,\n emb,\n encoder_hidden_states=encoder_hidden_states,\n attention_mask=attention_mask,\n num_frames=num_frames,\n cross_attention_kwargs=cross_attention_kwargs,\n )\n\n if mid_block_additional_residual is not None:\n sample = sample + mid_block_additional_residual\n\n # 5. 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 num_frames=num_frames,\n cross_attention_kwargs=cross_attention_kwargs,\n )\n else:\n sample = upsample_block(\n hidden_states=sample,\n temb=emb,\n res_hidden_states_tuple=res_samples,\n upsample_size=upsample_size,\n num_frames=num_frames,\n )\n\n # 6. post-process\n if self.conv_norm_out:\n sample = self.conv_norm_out(sample)\n sample = self.conv_act(sample)\n\n sample = self.conv_out(sample)\n\n # reshape to (batch, channel, framerate, width, height)\n sample = sample[None, :].reshape((-1, num_frames) + sample.shape[1:]).permute(0, 2, 1, 3, 4)\n sample = sample[:,:,1:]\n if not return_dict:\n return (sample,)\n\n return UNet3DConditionOutput(sample=sample)"},{"identifier":"MaskStableVideoDiffusionPipeline","path":"models/pipeline.py","snippet":"class MaskStableVideoDiffusionPipeline(StableVideoDiffusionPipeline):\n @torch.no_grad()\n def __call__(\n self,\n image,\n height: int = 576,\n width: int = 1024,\n num_frames: Optional[int] = None,\n num_inference_steps: int = 25,\n min_guidance_scale: float = 1.0,\n max_guidance_scale: float = 3.0,\n fps: int = 7,\n motion_bucket_id: int = 127,\n noise_aug_strength: int = 0.02,\n decode_chunk_size: Optional[int] = None,\n num_videos_per_prompt: Optional[int] = 1,\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\n latents: Optional[torch.FloatTensor] = None,\n output_type: Optional[str] = \"pil\",\n callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,\n callback_on_step_end_tensor_inputs: List[str] = [\"latents\"],\n return_dict: bool = True,\n mask = None,\n ):\n r\"\"\"\n The call function to the pipeline for generation.\n\n Args:\n image (`PIL.Image.Image` or `List[PIL.Image.Image]` or `torch.FloatTensor`):\n Image or images to guide image generation. If you provide a tensor, it needs to be compatible with\n [`CLIPImageProcessor`](https://huggingface.co/lambdalabs/sd-image-variations-diffusers/blob/main/feature_extractor/preprocessor_config.json).\n height (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):\n The height in pixels of the generated image.\n width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):\n The width in pixels of the generated image.\n num_frames (`int`, *optional*):\n The number of video frames to generate. Defaults to 14 for `stable-video-diffusion-img2vid` and to 25 for `stable-video-diffusion-img2vid-xt`\n num_inference_steps (`int`, *optional*, defaults to 25):\n The number of denoising steps. More denoising steps usually lead to a higher quality image at the\n expense of slower inference. This parameter is modulated by `strength`.\n min_guidance_scale (`float`, *optional*, defaults to 1.0):\n The minimum guidance scale. Used for the classifier free guidance with first frame.\n max_guidance_scale (`float`, *optional*, defaults to 3.0):\n The maximum guidance scale. Used for the classifier free guidance with last frame.\n fps (`int`, *optional*, defaults to 7):\n Frames per second. The rate at which the generated images shall be exported to a video after generation.\n Note that Stable Diffusion Video's UNet was micro-conditioned on fps-1 during training.\n motion_bucket_id (`int`, *optional*, defaults to 127):\n The motion bucket ID. Used as conditioning for the generation. The higher the number the more motion will be in the video.\n noise_aug_strength (`int`, *optional*, defaults to 0.02):\n The amount of noise added to the init image, the higher it is the less the video will look like the init image. Increase it for more motion.\n decode_chunk_size (`int`, *optional*):\n The number of frames to decode at a time. The higher the chunk size, the higher the temporal consistency\n between frames, but also the higher the memory consumption. By default, the decoder will decode all frames at once\n for maximal quality. Reduce `decode_chunk_size` to reduce memory usage.\n num_videos_per_prompt (`int`, *optional*, defaults to 1):\n The number of images to generate per prompt.\n generator (`torch.Generator` or `List[torch.Generator]`, *optional*):\n A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make\n generation deterministic.\n latents (`torch.FloatTensor`, *optional*):\n Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image\n generation. Can be used to tweak the same generation with different prompts. If not provided, a latents\n tensor is generated by sampling using the supplied random `generator`.\n output_type (`str`, *optional*, defaults to `\"pil\"`):\n The output format of the generated image. Choose between `PIL.Image` or `np.array`.\n callback_on_step_end (`Callable`, *optional*):\n A function that calls at the end of each denoising steps during the inference. The function is called\n with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int,\n callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by\n `callback_on_step_end_tensor_inputs`.\n callback_on_step_end_tensor_inputs (`List`, *optional*):\n The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list\n will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the\n `._callback_tensor_inputs` attribute of your pipeline class.\n return_dict (`bool`, *optional*, defaults to `True`):\n Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a\n plain tuple.\n\n Returns:\n [`~pipelines.stable_diffusion.StableVideoDiffusionPipelineOutput`] or `tuple`:\n If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableVideoDiffusionPipelineOutput`] is returned,\n otherwise a `tuple` is returned where the first element is a list of list with the generated frames.\n\n Examples:\n\n ```py\n from diffusers import StableVideoDiffusionPipeline\n from diffusers.utils import load_image, export_to_video\n\n pipe = StableVideoDiffusionPipeline.from_pretrained(\"stabilityai/stable-video-diffusion-img2vid-xt\", torch_dtype=torch.float16, variant=\"fp16\")\n pipe.to(\"cuda\")\n\n image = load_image(\"https://lh3.googleusercontent.com/y-iFOHfLTwkuQSUegpwDdgKmOjRSTvPxat63dQLB25xkTs4lhIbRUFeNBWZzYf370g=s1200\")\n image = image.resize((1024, 576))\n\n frames = pipe(image, num_frames=25, decode_chunk_size=8).frames[0]\n export_to_video(frames, \"generated.mp4\", fps=7)\n ```\n \"\"\"\n # 0. Default height and width to unet\n height = height or self.unet.config.sample_size * self.vae_scale_factor\n width = width or self.unet.config.sample_size * self.vae_scale_factor\n\n num_frames = num_frames if num_frames is not None else self.unet.config.num_frames\n decode_chunk_size = decode_chunk_size if decode_chunk_size is not None else num_frames\n\n # 1. Check inputs. Raise error if not correct\n self.check_inputs(image, height, width)\n\n # 2. Define call parameters\n if isinstance(image, PIL.Image.Image):\n batch_size = 1\n elif isinstance(image, list):\n batch_size = len(image)\n else:\n batch_size = image.shape[0]\n device = self._execution_device\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\n # corresponds to doing no classifier free guidance.\n do_classifier_free_guidance = max_guidance_scale > 1.0\n\n # 3. Encode input image\n image_embeddings = self._encode_image(image, device, num_videos_per_prompt, do_classifier_free_guidance)\n\n # NOTE: Stable Diffusion Video was conditioned on fps - 1, which\n # is why it is reduced here.\n # See: https://github.com/Stability-AI/generative-models/blob/ed0997173f98eaf8f4edf7ba5fe8f15c6b877fd3/scripts/sampling/simple_video_sample.py#L188\n fps = fps - 1\n\n # 4. Encode input image using VAE\n image = self.image_processor.preprocess(image, height=height, width=width)\n noise = randn_tensor(image.shape, generator=generator, device=image.device, dtype=image.dtype)\n image = image + noise_aug_strength * noise\n\n needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast\n if needs_upcasting:\n self.vae.to(dtype=torch.float32)\n\n image_latents = self._encode_vae_image(image, device, num_videos_per_prompt, do_classifier_free_guidance)\n image_latents = image_latents.to(image_embeddings.dtype)\n\n # cast back to fp16 if needed\n if needs_upcasting:\n self.vae.to(dtype=torch.float16)\n\n # Repeat the image latents for each frame so we can concatenate them with the noise\n # image_latents [batch, channels, height, width] ->[batch, num_frames, channels, height, width]\n image_latents = image_latents.unsqueeze(1).repeat(1, num_frames, 1, 1, 1)\n mask = repeat(mask, '1 h w -> 2 f 1 h w', f=num_frames)\n # 5. Get Added Time IDs\n added_time_ids = self._get_add_time_ids(\n fps,\n motion_bucket_id,\n noise_aug_strength,\n image_embeddings.dtype,\n batch_size,\n num_videos_per_prompt,\n do_classifier_free_guidance,\n )\n added_time_ids = added_time_ids.to(device)\n\n # 4. Prepare timesteps\n self.scheduler.set_timesteps(num_inference_steps, device=device)\n timesteps = self.scheduler.timesteps\n\n # 5. Prepare latent variables\n num_channels_latents = self.unet.config.in_channels\n latents = self.prepare_latents(\n batch_size * num_videos_per_prompt,\n num_frames,\n num_channels_latents,\n height,\n width,\n image_embeddings.dtype,\n device,\n generator,\n latents,\n )\n\n # 7. Prepare guidance scale\n guidance_scale = torch.linspace(min_guidance_scale, max_guidance_scale, num_frames).unsqueeze(0)\n guidance_scale = guidance_scale.to(device, latents.dtype)\n guidance_scale = guidance_scale.repeat(batch_size * num_videos_per_prompt, 1)\n guidance_scale = _append_dims(guidance_scale, latents.ndim)\n\n self._guidance_scale = guidance_scale\n\n # 8. Denoising loop\n num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order\n self._num_timesteps = len(timesteps)\n with self.progress_bar(total=num_inference_steps) as progress_bar:\n for i, t in enumerate(timesteps):\n # expand the latents if we are doing classifier free guidance\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\n\n # Concatenate image_latents over channels dimention\n latent_model_input = torch.cat([mask, latent_model_input, image_latents], dim=2)\n\n # predict the noise residual\n noise_pred = self.unet(\n latent_model_input,\n t,\n encoder_hidden_states=image_embeddings,\n added_time_ids=added_time_ids,\n return_dict=False,\n )[0]\n\n # perform guidance\n if do_classifier_free_guidance:\n noise_pred_uncond, noise_pred_cond = noise_pred.chunk(2)\n noise_pred = noise_pred_uncond + self.guidance_scale * (noise_pred_cond - noise_pred_uncond)\n\n # compute the previous noisy sample x_t -> x_t-1\n latents = self.scheduler.step(noise_pred, t, latents).prev_sample\n\n if callback_on_step_end is not None:\n callback_kwargs = {}\n for k in callback_on_step_end_tensor_inputs:\n callback_kwargs[k] = locals()[k]\n callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)\n\n latents = callback_outputs.pop(\"latents\", latents)\n\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\n progress_bar.update()\n\n if not output_type == \"latent\":\n # cast back to fp16 if needed\n if needs_upcasting:\n self.vae.to(dtype=torch.float16)\n frames = self.decode_latents(latents, num_frames, decode_chunk_size)\n frames = svd_tensor2vid(frames, self.image_processor, output_type=output_type)\n else:\n frames = latents\n\n self.maybe_free_model_hooks()\n\n if not return_dict:\n return frames\n\n return StableVideoDiffusionPipelineOutput(frames=frames)"},{"identifier":"LoraHandler","path":"utils/lora_handler.py","snippet":"class LoraHandler(object):\n def __init__(\n self, \n version: LORA_VERSIONS = LoraVersions.cloneofsimo, \n use_unet_lora: bool = False,\n use_text_lora: bool = False,\n save_for_webui: bool = False,\n only_for_webui: bool = False,\n lora_bias: str = 'none',\n unet_replace_modules: list = ['UNet3DConditionModel'],\n text_encoder_replace_modules: list = ['CLIPEncoderLayer']\n ):\n self.version = version\n self.lora_loader = self.get_lora_func(func_type=LoraFuncTypes.loader)\n self.lora_injector = self.get_lora_func(func_type=LoraFuncTypes.injector)\n self.lora_bias = lora_bias\n self.use_unet_lora = use_unet_lora\n self.use_text_lora = use_text_lora\n self.save_for_webui = save_for_webui\n self.only_for_webui = only_for_webui\n self.unet_replace_modules = unet_replace_modules\n self.text_encoder_replace_modules = text_encoder_replace_modules\n self.use_lora = any([use_text_lora, use_unet_lora])\n\n if self.use_lora:\n print(f\"Using LoRA Version: {self.version}\")\n\n def is_cloneofsimo_lora(self):\n return self.version == LoraVersions.cloneofsimo\n\n def is_stable_lora(self):\n return self.version == LoraVersions.stable_lora\n\n def get_lora_func(self, func_type: LORA_FUNC_TYPES = LoraFuncTypes.loader):\n\n if self.is_cloneofsimo_lora():\n\n if func_type == LoraFuncTypes.loader:\n return monkeypatch_or_replace_lora_extended\n\n if func_type == LoraFuncTypes.injector:\n return inject_trainable_lora_extended\n\n if self.is_stable_lora():\n\n if func_type == LoraFuncTypes.loader:\n return load_lora\n\n if func_type == LoraFuncTypes.injector:\n return add_lora_to\n \n assert \"LoRA Version does not exist.\"\n\n def check_lora_ext(self, lora_file: str):\n return lora_file.endswith(tuple(LORA_FILE_TYPES))\n\n def get_lora_file_path(\n self, \n lora_path: str, \n model: Union[UNet3DConditionModel, CLIPTextModel]\n ):\n if os.path.exists(lora_path):\n lora_filenames = [fns for fns in os.listdir(lora_path)]\n is_lora = self.check_lora_ext(lora_path)\n\n is_unet = isinstance(model, UNet3DConditionModel)\n is_text = isinstance(model, CLIPTextModel)\n idx = 0 if is_unet else 1\n\n base_name = FILE_BASENAMES[idx]\n \n for lora_filename in lora_filenames:\n is_lora = self.check_lora_ext(lora_filename)\n if not is_lora:\n continue\n \n if base_name in lora_filename:\n return os.path.join(lora_path, lora_filename)\n\n return None\n\n def handle_lora_load(self, file_name:str, lora_loader_args: dict = None):\n self.lora_loader(**lora_loader_args)\n print(f\"Successfully loaded LoRA from: {file_name}\")\n \n def load_lora(self, model, lora_path: str = '', lora_loader_args: dict = None,):\n try:\n lora_file = self.get_lora_file_path(lora_path, model)\n\n if lora_file is not None:\n lora_loader_args.update({\"lora_path\": lora_file})\n self.handle_lora_load(lora_file, lora_loader_args)\n\n else:\n print(f\"Could not load LoRAs for {model.__class__.__name__}. Injecting new ones instead...\")\n\n except Exception as e:\n print(f\"An error occured while loading a LoRA file: {e}\")\n \n def get_lora_func_args(self, lora_path, use_lora, model, replace_modules, r, dropout, lora_bias):\n return_dict = lora_args.copy()\n \n if self.is_cloneofsimo_lora():\n return_dict = filter_dict(return_dict, keys=CLONE_OF_SIMO_KEYS)\n return_dict.update({\n \"model\": model,\n \"loras\": self.get_lora_file_path(lora_path, model),\n \"target_replace_module\": replace_modules,\n \"r\": r\n })\n\n if self.is_stable_lora():\n KEYS = ['model', 'lora_path']\n return_dict = filter_dict(return_dict, KEYS)\n \n return_dict.update({'model': model, 'lora_path': lora_path})\n\n return return_dict\n\n def do_lora_injection(\n self, \n model, \n replace_modules, \n bias='none',\n dropout=0,\n r=4,\n lora_loader_args=None,\n ): \n REPLACE_MODULES = replace_modules\n\n params = None\n negation = None\n is_injection_hybrid = False\n \n if self.is_cloneofsimo_lora():\n is_injection_hybrid = True\n injector_args = lora_loader_args\n\n params, negation = self.lora_injector(**injector_args) \n for _up, _down in extract_lora_ups_down(\n model, \n target_replace_module=REPLACE_MODULES):\n\n if all(x is not None for x in [_up, _down]):\n print(f\"Lora successfully injected into {model.__class__.__name__}.\")\n\n break\n\n return params, negation, is_injection_hybrid\n\n if self.is_stable_lora():\n injector_args = lora_args.copy()\n injector_args = filter_dict(injector_args, keys=STABLE_LORA_KEYS)\n\n SEARCH_CLASS = [torch.nn.Linear, torch.nn.Conv2d, torch.nn.Conv3d, torch.nn.Embedding]\n\n injector_args.update({\n \"model\": model,\n \"target_module\": REPLACE_MODULES,\n \"search_class\": SEARCH_CLASS,\n \"r\": r,\n \"dropout\": dropout,\n \"lora_bias\": self.lora_bias\n })\n\n activator = self.lora_injector(**injector_args)\n activator()\n\n return params, negation, is_injection_hybrid\n\n def add_lora_to_model(self, use_lora, model, replace_modules, dropout=0.0, lora_path='', r=16):\n\n params = None\n negation = None\n\n lora_loader_args = self.get_lora_func_args(\n lora_path,\n use_lora,\n model,\n replace_modules,\n r,\n dropout,\n self.lora_bias\n )\n if use_lora:\n params, negation, is_injection_hybrid = self.do_lora_injection(\n model, \n replace_modules, \n bias=self.lora_bias,\n lora_loader_args=lora_loader_args,\n dropout=dropout,\n r=r\n )\n\n if not is_injection_hybrid:\n self.load_lora(model, lora_path=lora_path, lora_loader_args=lora_loader_args)\n \n params = model if params is None else params\n return params, negation\n \n\n def deactivate_lora_train(self, models, deactivate=True):\n \"\"\"\n Usage: Use before and after sampling previews.\n Currently only available for Stable LoRA.\n \"\"\"\n if self.is_stable_lora():\n set_mode_group(models, not deactivate)\n\n def save_cloneofsimo_lora(self, model, save_path, step):\n \n def save_lora(model, name, condition, replace_modules, step, save_path): \n if condition and replace_modules is not None:\n save_path = f\"{save_path}/{step}_{name}.pt\"\n save_lora_weight(model, save_path, replace_modules)\n\n save_lora(\n model.unet, \n FILE_BASENAMES[0], \n self.use_unet_lora, \n self.unet_replace_modules, \n step,\n save_path, \n )\n save_lora(\n model.text_encoder, \n FILE_BASENAMES[1], \n self.use_text_lora, \n self.text_encoder_replace_modules, \n step, \n save_path\n )\n\n train_patch_pipe(model, self.use_unet_lora, self.use_text_lora)\n\n def save_stable_lora(\n self, \n model, \n step, \n name, \n save_path = '', \n save_for_webui=False,\n only_for_webui=False\n ):\n import uuid\n\n save_filename = f\"{step}_{name}\"\n lora_metadata = metadata = {\n \"stable_lora_text_to_video\": \"v1\", \n \"lora_name\": name + \"_\" + uuid.uuid4().hex.lower()[:5]\n }\n save_lora(\n unet=model.unet,\n text_encoder=model.text_encoder,\n save_text_weights=self.use_text_lora,\n output_dir=save_path,\n lora_filename=save_filename,\n lora_bias=self.lora_bias,\n save_for_webui=self.save_for_webui,\n only_webui=self.only_for_webui,\n metadata=lora_metadata,\n unet_dict_converter=convert_unet_state_dict,\n text_dict_converter=convert_text_enc_state_dict_v20\n )\n\n def save_lora_weights(self, model: None, save_path: str ='',step: str = ''):\n save_path = f\"{save_path}/lora\"\n os.makedirs(save_path, exist_ok=True)\n\n if self.is_cloneofsimo_lora():\n if any([self.save_for_webui, self.only_for_webui]):\n warnings.warn(\n \"\"\"\n You have 'save_for_webui' enabled, but are using cloneofsimo's LoRA implemention.\n Only 'stable_lora' is supported for saving to a compatible webui file.\n \"\"\"\n )\n self.save_cloneofsimo_lora(model, save_path, step)\n\n if self.is_stable_lora():\n name = 'lora_text_to_video'\n self.save_stable_lora(model, step, name, save_path)"},{"identifier":"LORA_VERSIONS","path":"utils/lora_handler.py","snippet":"LORA_VERSIONS = [LoraVersions.stable_lora, LoraVersions.cloneofsimo]"},{"identifier":"read_mask","path":"utils/common.py","snippet":"def read_mask(json_path, label=[\"mask\"]):\n j = json.load(open(json_path)) \n if type(label) != list:\n labels = [label]\n height = j['imageHeight']\n width = j['imageWidth']\n mask = np.zeros([height, width], dtype=np.uint8)\n for shape in j['shapes']:\n if shape['label'] in label:\n x1, y1 = shape['points'][0]\n x2, y2 = shape['points'][1]\n mask[int(y1):int(y2), int(x1):int(x2)] = 255\n return mask"},{"identifier":"generate_random_mask","path":"utils/common.py","snippet":"def generate_random_mask(image):\n # Create a blank mask with the same size as the image\n b, c , h, w = image.shape\n mask = np.zeros([b, h, w], dtype=np.uint8)\n \n # Generate random coordinates for the mask\n num_points = np.random.randint(3, 10) # Randomly choose the number of points to generate\n points = np.random.randint(0, min(h, w), size=(num_points, 2)) # Randomly generate the points\n # Draw a filled polygon on the mask using the random points\n for i in range(b):\n width = random.randint(w//4, w)\n height = random.randint(h//4, h)\n x = random.randint(0, w-width)\n y = random.randint(0, h-height)\n points=np.array([[x, y], [x+width, y], [x+width, y+height], [x, y+height]])\n mask[i] = cv2.fillPoly(mask[i], [points], 255)\n \n # Apply the mask to the image\n #masked_image = cv2.bitwise_and(image, image, mask=mask)\n return mask "},{"identifier":"slerp","path":"utils/common.py","snippet":"def slerp(z1, z2, alpha):\n theta = torch.acos(torch.sum(z1 * z2) / (torch.norm(z1) * torch.norm(z2)))\n return (\n torch.sin((1 - alpha) * theta) / torch.sin(theta) * z1\n + torch.sin(alpha * theta) / torch.sin(theta) * z2\n )"},{"identifier":"calculate_motion_score","path":"utils/common.py","snippet":"def calculate_motion_score(frame_imgs, calculate_edges=False, color=\"RGB\") -> float:\n # Convert image into HSV colorspace.\n _last_frame = None\n\n _weights = [1.0, 1.0, 1.0, 0.0]\n score = 0\n for frame_img in frame_imgs:\n if color == \"RGB\":\n hue, sat, lum = cv2.split(cv2.cvtColor(frame_img, cv2.COLOR_RGB2HSV))\n else:\n hue, sat, lum = cv2.split(cv2.cvtColor(frame_img, cv2.COLOR_BGR2HSV))\n # Performance: Only calculate edges if we have to.\n edges = _detect_edges(lum) if calculate_edges else None\n if _last_frame == None:\n _last_frame = (hue, sat, lum, edges)\n continue\n\n score_components = [\n _mean_pixel_distance(hue, _last_frame[0]),\n _mean_pixel_distance(sat, _last_frame[1]),\n _mean_pixel_distance(lum, _last_frame[2]),\n 0.0 if edges is None else _mean_pixel_distance(edges, _last_frame[3]),\n ]\n\n frame_score: float = (\n sum(component * weight for (component, weight) in zip(score_components, _weights))\n / sum(abs(weight) for weight in _weights))\n score += frame_score\n _last_frame = (hue, sat, lum, edges)\n\n return round(score/(len(frame_imgs)-1) * 10)"},{"identifier":"read_video","path":"utils/common.py","snippet":"def read_video(video_path, frame_number=-1):\n # Open the video file\n cap = cv2.VideoCapture(video_path)\n count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) \n if frame_number == -1:\n frame_number = count\n else:\n frame_number = min(frame_number, count)\n frames = []\n for i in range(frame_number):\n ret, ref_frame = cap.read()\n ref_frame = cv2.cvtColor(ref_frame, cv2.COLOR_BGR2RGB)\n if not ret:\n raise ValueError(\"Failed to read video file\")\n frames.append(ref_frame)\n return frames"},{"identifier":"calculate_motion_precision","path":"utils/common.py","snippet":"def calculate_motion_precision(frames, mask):\n moved_mask = get_moved_area_mask(frames, move_th=20, th=0)\n moved = moved_mask == 255\n gt = mask == 255\n precision = np.sum(moved & gt) / np.sum(moved)\n return precision"},{"identifier":"calculate_latent_motion_score","path":"utils/common.py","snippet":"def calculate_latent_motion_score(latents):\n #latents b, c f, h, w\n diff=torch.abs(latents[:,:,1:]-latents[:,:,:-1])\n motion_score = torch.sum(torch.mean(diff, dim=[2,3,4]), dim=1) * 10\n return motion_score"},{"identifier":"DDPM_forward","path":"utils/common.py","snippet":"def DDPM_forward(x0, step, num_frames, scheduler):\n device = x0.device\n t = scheduler.timesteps[-1]\n xt = repeat(x0, 'b c 1 h w -> b c f h w', f = num_frames)\n\n eps = torch.randn_like(xt)\n alpha_vec = torch.prod(scheduler.alphas[t:])\n xt = torch.sqrt(alpha_vec) * xt + torch.sqrt(1-alpha_vec) * eps\n return xt, None"},{"identifier":"DDPM_forward_timesteps","path":"utils/common.py","snippet":"def DDPM_forward_timesteps(x0, step, num_frames, scheduler):\n '''larger step -> smaller t -> smaller alphas[t:] -> smaller xt -> smaller x0'''\n\n device = x0.device\n # timesteps are reversed\n timesteps = scheduler.timesteps[len(scheduler.timesteps)-step:]\n t = timesteps[0]\n\n if x0.shape[2] == 1:\n xt = repeat(x0, 'b c 1 h w -> b c f h w', f = num_frames)\n else:\n xt = x0\n noise = torch.randn(xt.shape, dtype=xt.dtype, device=device)\n # t to tensor of batch size \n t = torch.tensor([t]*xt.shape[0], device=device)\n xt = scheduler.add_noise(xt, noise, t)\n return xt, timesteps"},{"identifier":"motion_mask_loss","path":"utils/common.py","snippet":"def motion_mask_loss(latents, mask):\n diff = torch.abs(latents[:,:,1:] - latents[:,:,:-1])\n loss = torch.sum(torch.mean(diff * (1-mask), dim=[2,3,4]), dim=1)\n return loss"}],"string":"[\n {\n \"identifier\": \"VideoJsonDataset\",\n \"path\": \"utils/dataset.py\",\n \"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: str = \\\"./data\\\",\\n video_json: str = \\\"\\\",\\n fallback_prompt: str = \\\"\\\",\\n use_bucketing: bool = False,\\n cache_latents = False,\\n motion_threshold = 50,\\n **kwargs\\n ):\\n self.tokenizer = tokenizer\\n self.use_bucketing = use_bucketing\\n\\n self.fallback_prompt = fallback_prompt\\n self.video_dir = video_dir\\n self.video_files = json.load(open(video_json))\\n\\n self.width = width\\n self.height = height\\n\\n self.n_sample_frames = n_sample_frames\\n self.fps = fps\\n self.cache_latents = cache_latents\\n self.motion_threshold = motion_threshold\\n self.transform = T.Compose([\\n #T.RandomResizedCrop(size=(height, width), scale=(0.8, 1.0), ratio=(width/height, width/height), antialias=False),\\n T.Resize(min(height, width), antialias=False),\\n T.CenterCrop([height, width])\\n ])\\n\\n\\n def get_frame_buckets(self, vr):\\n _, h, w = vr[0].shape \\n width, height = sensible_buckets(self.width, self.height, h, w)\\n resize = T.transforms.Resize((height, width), antialias=True)\\n\\n return resize\\n\\n \\n @staticmethod\\n def __getname__(): return 'video_json'\\n\\n def __len__(self):\\n return len(self.video_files)\\n\\n def __getitem__(self, index):\\n mask = None\\n try:\\n item = self.video_files[index]\\n video_path = os.path.join(self.video_dir, item['video'])\\n cache_path = os.path.splitext(video_path)[0] + '.pt'\\n if self.cache_latents and os.path.exists(cache_path):\\n return torch.load(cache_path, map_location='cpu')\\n\\n prompt = item['caption']\\n if self.fallback_prompt == \\\"<no_text>\\\":\\n prompt = \\\"\\\"\\n vr = decord.VideoReader(video_path)\\n video = get_frame_batch(self.n_sample_frames, self.fps, vr, self.transform)\\n except Exception as err:\\n print(\\\"read video error\\\", err, video_path)\\n return self.__getitem__(index+1)\\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\\n\\n example = {\\n \\\"pixel_values\\\": normalize_input(video), \\n \\\"prompt_ids\\\": prompt_ids, \\n \\\"text_prompt\\\": prompt, \\n 'cache_path': cache_path,\\n 'dataset': self.__getname__()\\n }\\n mask = get_moved_area_mask(video.permute([0,2,3,1]).numpy())\\n example['motion'] = calculate_motion_score(video.permute([0,2,3,1]).numpy())\\n if example['motion'] < self.motion_threshold:\\n return self.__getitem__(random.randint(0, len(self)-1))\\n return example\"\n },\n {\n \"identifier\": \"SingleVideoDataset\",\n \"path\": \"utils/dataset.py\",\n \"snippet\": \"class SingleVideoDataset(Dataset):\\n def __init__(\\n self,\\n tokenizer = None,\\n width: int = 256,\\n height: int = 256,\\n n_sample_frames: int = 4,\\n frame_step: int = 1,\\n single_video_path: str = \\\"\\\",\\n single_video_prompt: str = \\\"\\\",\\n use_caption: bool = False,\\n use_bucketing: bool = False,\\n **kwargs\\n ):\\n self.tokenizer = tokenizer\\n self.use_bucketing = use_bucketing\\n self.frames = []\\n self.index = 1\\n\\n self.vid_types = (\\\".mp4\\\", \\\".avi\\\", \\\".mov\\\", \\\".webm\\\", \\\".flv\\\", \\\".mjpeg\\\")\\n self.n_sample_frames = n_sample_frames\\n self.frame_step = frame_step\\n\\n self.single_video_path = single_video_path\\n self.single_video_prompt = single_video_prompt\\n\\n self.width = width\\n self.height = height\\n def create_video_chunks(self):\\n # Create a list of frames separated by sample frames\\n # [(1,2,3), (4,5,6), ...]\\n vr = decord.VideoReader(self.single_video_path)\\n vr_range = range(1, len(vr), self.frame_step)\\n\\n self.frames = list(self.chunk(vr_range, self.n_sample_frames))\\n\\n # Delete any list that contains an out of range index.\\n for i, inner_frame_nums in enumerate(self.frames):\\n for frame_num in inner_frame_nums:\\n if frame_num > len(vr):\\n print(f\\\"Removing out of range index list at position: {i}...\\\")\\n del self.frames[i]\\n\\n return self.frames\\n\\n def chunk(self, it, size):\\n it = iter(it)\\n return iter(lambda: tuple(islice(it, size)), ())\\n\\n def get_frame_batch(self, vr, resize=None):\\n index = self.index\\n frames = vr.get_batch(self.frames[self.index])\\n video = rearrange(frames, \\\"f h w c -> f c h w\\\")\\n\\n if resize is not None: video = resize(video)\\n return video\\n\\n def get_frame_buckets(self, vr):\\n _, h, w = vr[0].shape \\n width, height = sensible_buckets(self.width, self.height, h, w)\\n resize = T.transforms.Resize((height, width), antialias=True)\\n\\n return resize\\n \\n def process_video_wrapper(self, vid_path):\\n video, vr = process_video(\\n vid_path,\\n self.use_bucketing,\\n self.width, \\n self.height, \\n self.get_frame_buckets, \\n self.get_frame_batch\\n )\\n \\n return video, vr \\n\\n def single_video_batch(self, index):\\n train_data = self.single_video_path\\n self.index = index\\n\\n if train_data.endswith(self.vid_types):\\n video, _ = self.process_video_wrapper(train_data)\\n\\n prompt = self.single_video_prompt\\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\\n\\n return video, prompt, prompt_ids\\n else:\\n raise ValueError(f\\\"Single video is not a video type. Types: {self.vid_types}\\\")\\n \\n @staticmethod\\n def __getname__(): return 'single_video'\\n\\n def __len__(self):\\n \\n return len(self.create_video_chunks())\\n\\n def __getitem__(self, index):\\n\\n video, prompt, prompt_ids = self.single_video_batch(index)\\n\\n example = {\\n \\\"pixel_values\\\": normalize_input(video),\\n \\\"prompt_ids\\\": prompt_ids,\\n \\\"text_prompt\\\": prompt,\\n 'dataset': self.__getname__()\\n }\\n\\n return example\"\n },\n {\n \"identifier\": \"ImageDataset\",\n \"path\": \"utils/dataset.py\",\n \"snippet\": \"class ImageDataset(Dataset):\\n \\n def __init__(\\n self,\\n tokenizer = None,\\n width: int = 256,\\n height: int = 256,\\n base_width: int = 256,\\n base_height: int = 256,\\n use_caption: bool = False,\\n image_dir: str = '',\\n single_img_prompt: str = '',\\n use_bucketing: bool = False,\\n fallback_prompt: str = '',\\n **kwargs\\n ):\\n self.tokenizer = tokenizer\\n self.img_types = (\\\".png\\\", \\\".jpg\\\", \\\".jpeg\\\", '.bmp')\\n self.use_bucketing = use_bucketing\\n #self.image_dir = self.get_images_list(image_dir)\\n self.image_dir_path = image_dir\\n self.image_dir = json.load(open(kwargs['image_json']))\\n self.fallback_prompt = fallback_prompt\\n\\n self.use_caption = use_caption\\n self.single_img_prompt = single_img_prompt\\n\\n self.width = width\\n self.height = height\\n\\n def get_images_list(self, image_dir):\\n if os.path.exists(image_dir):\\n imgs = [x for x in os.listdir(image_dir) if x.endswith(self.img_types)]\\n full_img_dir = []\\n\\n for img in imgs: \\n full_img_dir.append(f\\\"{image_dir}/{img}\\\")\\n\\n return sorted(full_img_dir)\\n\\n return ['']\\n\\n def image_batch(self, index):\\n train_data = self.image_dir[index]\\n img, prompt = train_data['image'], train_data['caption']\\n img = os.path.join(self.image_dir_path, img)\\n try:\\n img = torchvision.io.read_image(img, mode=torchvision.io.ImageReadMode.RGB)\\n except:\\n img = T.transforms.PILToTensor()(Image.open(img).convert(\\\"RGB\\\"))\\n\\n width = self.width\\n height = self.height\\n\\n if self.use_bucketing:\\n _, h, w = img.shape\\n width, height = sensible_buckets(width, height, w, h)\\n \\n resize = T.transforms.Resize((height, width), antialias=True)\\n\\n img = resize(img) \\n img = repeat(img, 'c h w -> f c h w', f=1)\\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\\n\\n return img, prompt, prompt_ids\\n\\n @staticmethod\\n def __getname__(): return 'image'\\n \\n def __len__(self):\\n # Image directory\\n return len(self.image_dir)\\n\\n def __getitem__(self, index):\\n img, prompt, prompt_ids = self.image_batch(index)\\n example = {\\n \\\"pixel_values\\\": normalize_input(img),\\n \\\"frames\\\": img,\\n \\\"prompt_ids\\\": prompt_ids,\\n \\\"text_prompt\\\": prompt, \\n 'dataset': self.__getname__()\\n }\\n\\n return example\"\n },\n {\n \"identifier\": \"VideoFolderDataset\",\n \"path\": \"utils/dataset.py\",\n \"snippet\": \"class VideoFolderDataset(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 path: str = \\\"./data\\\",\\n fallback_prompt: str = \\\"\\\",\\n use_bucketing: bool = False,\\n **kwargs\\n ):\\n self.tokenizer = tokenizer\\n self.use_bucketing = use_bucketing\\n\\n self.fallback_prompt = fallback_prompt\\n\\n self.video_files = glob(f\\\"{path}/*.mp4\\\")\\n\\n self.width = width\\n self.height = height\\n\\n self.n_sample_frames = n_sample_frames\\n self.fps = fps\\n\\n def get_frame_buckets(self, vr):\\n _, h, w = vr[0].shape \\n width, height = sensible_buckets(self.width, self.height, h, w)\\n resize = T.transforms.Resize((height, width), antialias=True)\\n\\n return resize\\n\\n def get_frame_batch(self, vr, resize=None):\\n n_sample_frames = self.n_sample_frames\\n native_fps = vr.get_avg_fps()\\n \\n every_nth_frame = max(1, round(native_fps / self.fps))\\n every_nth_frame = min(len(vr), every_nth_frame)\\n \\n effective_length = len(vr) // every_nth_frame\\n if effective_length < n_sample_frames:\\n n_sample_frames = effective_length\\n raise RuntimeError(\\\"not enough frames\\\")\\n\\n effective_idx = random.randint(0, (effective_length - n_sample_frames))\\n idxs = every_nth_frame * np.arange(effective_idx, effective_idx + n_sample_frames)\\n\\n video = vr.get_batch(idxs)\\n video = rearrange(video, \\\"f h w c -> f c h w\\\")\\n\\n if resize is not None: video = resize(video)\\n return video, vr\\n \\n def process_video_wrapper(self, vid_path):\\n video, vr = process_video(\\n vid_path,\\n self.use_bucketing,\\n self.width, \\n self.height, \\n self.get_frame_buckets, \\n self.get_frame_batch\\n )\\n return video, vr\\n \\n @staticmethod\\n def __getname__(): return 'folder'\\n\\n def __len__(self):\\n return len(self.video_files)\\n\\n def __getitem__(self, index):\\n try:\\n video, _ = self.process_video_wrapper(self.video_files[index])\\n except Exception as err:\\n print(\\\"read video error\\\", self.video_files[index])\\n video, _ = self.process_video_wrapper(self.video_files[index+1])\\n\\n if os.path.exists(self.video_files[index].replace(\\\".mp4\\\", \\\".txt\\\")):\\n with open(self.video_files[index].replace(\\\".mp4\\\", \\\".txt\\\"), \\\"r\\\") as f:\\n lines = f.readlines()\\n prompt = random.choice(lines)\\n else:\\n prompt = self.fallback_prompt\\n\\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\\n\\n return {\\\"pixel_values\\\": normalize_input(video[0]), \\\"frames\\\": video[0],\\n \\\"prompt_ids\\\": prompt_ids, \\\"text_prompt\\\": prompt, 'dataset': self.__getname__()}\"\n },\n {\n \"identifier\": \"CachedDataset\",\n \"path\": \"utils/dataset.py\",\n \"snippet\": \"class CachedDataset(Dataset):\\n def __init__(self,cache_dir: str = ''):\\n self.cache_dir = cache_dir\\n self.cached_data_list = self.get_files_list()\\n\\n def get_files_list(self):\\n tensors_list = [f\\\"{self.cache_dir}/{x}\\\" for x in os.listdir(self.cache_dir) if x.endswith('.pt')]\\n return sorted(tensors_list)\\n\\n def __len__(self):\\n return len(self.cached_data_list)\\n\\n def __getitem__(self, index):\\n cached_latent = torch.load(self.cached_data_list[index], map_location='cuda:0')\\n return cached_latent\"\n },\n {\n \"identifier\": \"VideoBLIPDataset\",\n \"path\": \"utils/dataset.py\",\n \"snippet\": \"class VideoBLIPDataset(Dataset):\\n def __init__(\\n self,\\n tokenizer = None,\\n width: int = 256,\\n height: int = 256,\\n n_sample_frames: int = 4,\\n sample_start_idx: int = 1,\\n fps: int = 1,\\n json_path: str =\\\"\\\",\\n json_data = None,\\n vid_data_key: str = \\\"video_path\\\",\\n preprocessed: bool = False,\\n use_bucketing: bool = False,\\n cache_latents: bool = False,\\n motion_threshold = 50,\\n **kwargs\\n ):\\n self.vid_types = (\\\".mp4\\\", \\\".avi\\\", \\\".mov\\\", \\\".webm\\\", \\\".flv\\\", \\\".mjpeg\\\")\\n self.use_bucketing = use_bucketing\\n self.tokenizer = tokenizer\\n self.preprocessed = preprocessed\\n \\n self.vid_data_key = vid_data_key\\n self.train_data = self.load_from_json(json_path, json_data)\\n self.cache_latents = cache_latents\\n self.motion_threshold = motion_threshold\\n self.width = width\\n self.height = height\\n\\n self.n_sample_frames = n_sample_frames\\n self.sample_start_idx = sample_start_idx\\n self.fps = fps\\n self.transform = T.Compose([\\n #T.RandomResizedCrop(size=(height, width), scale=(0.8, 1.0), ratio=(width/height, width/height), antialias=False)\\n T.Resize(min(height, width), antialias=False),\\n T.CenterCrop([height, width])\\n ])\\n\\n def build_json(self, json_data):\\n extended_data = []\\n for data in json_data['data']:\\n for nested_data in data['data']:\\n self.build_json_dict(\\n data, \\n nested_data, \\n extended_data\\n )\\n json_data = extended_data\\n return json_data\\n\\n def build_json_dict(self, data, nested_data, extended_data):\\n clip_path = nested_data['clip_path'] if 'clip_path' in nested_data else None\\n \\n extended_data.append({\\n self.vid_data_key: data[self.vid_data_key],\\n 'frame_index': nested_data['frame_index'],\\n 'prompt': nested_data['prompt'],\\n 'clip_path': clip_path\\n })\\n \\n def load_from_json(self, path, json_data):\\n try:\\n with open(path) as jpath:\\n print(f\\\"Loading JSON from {path}\\\")\\n json_data = json.load(jpath)\\n\\n return self.build_json(json_data)\\n\\n except:\\n import traceback\\n traceback.print_exc()\\n self.train_data = []\\n print(\\\"Non-existant JSON path. Skipping.\\\")\\n \\n def validate_json(self, base_path, path):\\n return os.path.exists(f\\\"{base_path}/{path}\\\")\\n\\n def get_frame_buckets(self, vr):\\n _, h, w = vr[0].shape \\n width, height = sensible_buckets(self.width, self.height, h, w)\\n resize = T.transforms.Resize((height, width), antialias=True)\\n\\n return resize\\n\\n def train_data_batch(self, index):\\n vid_data = self.train_data[index]\\n # Get video prompt\\n prompt = vid_data['prompt']\\n # If we are training on individual clips.\\n if 'clip_path' in self.train_data[index] and \\\\\\n self.train_data[index]['clip_path'] is not None:\\n clip_path = vid_data['clip_path']\\n else:\\n clip_path = vid_data[self.vid_data_key]\\n # Get the frame of the current index.\\n self.sample_start_idx = vid_data['frame_index']\\n cache_path = os.path.splitext(clip_path)[0] + '.pt'\\n if self.cache_latents and os.path.exists(cache_path):\\n return torch.load(cache_path, map_location='cpu')\\n\\n vr = decord.VideoReader(clip_path)\\n video = get_frame_batch(self.n_sample_frames, self.fps, vr, self.transform)\\n prompt_ids = get_prompt_ids(prompt, self.tokenizer)\\n example = {\\n \\\"pixel_values\\\": normalize_input(video),\\n \\\"prompt_ids\\\": prompt_ids,\\n \\\"text_prompt\\\": prompt,\\n 'dataset': self.__getname__(),\\n 'cache_path': cache_path,\\n }\\n mask = get_moved_area_mask(video.permute([0,2,3,1]).numpy())\\n example['mask'] = mask\\n example['motion'] = calculate_motion_score(video.permute([0,2,3,1]).numpy())\\n return example\\n \\n\\n @staticmethod\\n def __getname__(): return 'video_blip'\\n\\n def __len__(self):\\n if self.train_data is not None:\\n return len(self.train_data)\\n else: \\n return 0\\n\\n def __getitem__(self, index):\\n example = self.train_data_batch(index)\\n if example['motion'] < self.motion_threshold:\\n return self.__getitem__(random.randint(0, len(self)-1))\\n return example\"\n },\n {\n \"identifier\": \"UNet3DConditionModel\",\n \"path\": \"models/unet_3d_condition_mask.py\",\n \"snippet\": \"class UNet3DConditionModel(ModelMixin, ConfigMixin):\\n r\\\"\\\"\\\"\\n UNet3DConditionModel is a conditional 2D UNet model that takes in a noisy sample, conditional state, and a timestep\\n and returns sample shaped output.\\n\\n This model inherits from [`ModelMixin`]. Check the superclass documentation for the generic methods the library\\n implements for all the models (such as downloading or saving, etc.)\\n\\n Parameters:\\n sample_size (`int` or `Tuple[int, int]`, *optional*, defaults to `None`):\\n Height and width of input/output sample.\\n in_channels (`int`, *optional*, defaults to 4): The number of channels in the input sample.\\n out_channels (`int`, *optional*, defaults to 4): The number of channels in the output.\\n down_block_types (`Tuple[str]`, *optional*, defaults to `(\\\"CrossAttnDownBlock2D\\\", \\\"CrossAttnDownBlock2D\\\", \\\"CrossAttnDownBlock2D\\\", \\\"DownBlock2D\\\")`):\\n The tuple of downsample blocks to use.\\n up_block_types (`Tuple[str]`, *optional*, defaults to `(\\\"UpBlock2D\\\", \\\"CrossAttnUpBlock2D\\\", \\\"CrossAttnUpBlock2D\\\", \\\"CrossAttnUpBlock2D\\\",)`):\\n The tuple of upsample blocks to use.\\n block_out_channels (`Tuple[int]`, *optional*, defaults to `(320, 640, 1280, 1280)`):\\n The tuple of output channels for each block.\\n layers_per_block (`int`, *optional*, defaults to 2): The number of layers per block.\\n downsample_padding (`int`, *optional*, defaults to 1): The padding to use for the downsampling convolution.\\n mid_block_scale_factor (`float`, *optional*, defaults to 1.0): The scale factor to use for the mid block.\\n act_fn (`str`, *optional*, defaults to `\\\"silu\\\"`): The activation function to use.\\n norm_num_groups (`int`, *optional*, defaults to 32): The number of groups to use for the normalization.\\n If `None`, it will skip the normalization and activation layers in post-processing\\n norm_eps (`float`, *optional*, defaults to 1e-5): The epsilon to use for the normalization.\\n cross_attention_dim (`int`, *optional*, defaults to 1280): The dimension of the cross attention features.\\n attention_head_dim (`int`, *optional*, defaults to 8): The dimension of the attention heads.\\n \\\"\\\"\\\"\\n\\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 down_block_types: Tuple[str] = (\\n \\\"CrossAttnDownBlock3D\\\",\\n \\\"CrossAttnDownBlock3D\\\",\\n \\\"CrossAttnDownBlock3D\\\",\\n \\\"DownBlock3D\\\",\\n ),\\n up_block_types: Tuple[str] = (\\\"UpBlock3D\\\", \\\"CrossAttnUpBlock3D\\\", \\\"CrossAttnUpBlock3D\\\", \\\"CrossAttnUpBlock3D\\\"),\\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: Optional[int] = 32,\\n norm_eps: float = 1e-5,\\n cross_attention_dim: int = 1024,\\n attention_head_dim: Union[int, Tuple[int]] = 64,\\n motion_mask = False,\\n motion_strength = False,\\n ):\\n super().__init__()\\n self.motion_mask = motion_mask\\n self.motion_strength = motion_strength\\n print(f\\\"motion mask {self.motion_mask}, motion_strength {self.motion_strength}\\\")\\n self.sample_size = sample_size\\n self.gradient_checkpointing = False\\n # Check inputs\\n if len(down_block_types) != len(up_block_types):\\n raise ValueError(\\n f\\\"Must provide the same number of `down_block_types` as `up_block_types`. `down_block_types`: {down_block_types}. `up_block_types`: {up_block_types}.\\\"\\n )\\n\\n if len(block_out_channels) != len(down_block_types):\\n raise ValueError(\\n f\\\"Must provide the same number of `block_out_channels` as `down_block_types`. `block_out_channels`: {block_out_channels}. `down_block_types`: {down_block_types}.\\\"\\n )\\n\\n if not isinstance(attention_head_dim, int) and len(attention_head_dim) != len(down_block_types):\\n raise ValueError(\\n f\\\"Must provide the same number of `attention_head_dim` as `down_block_types`. `attention_head_dim`: {attention_head_dim}. `down_block_types`: {down_block_types}.\\\"\\n )\\n\\n # input\\n conv_in_kernel = 3\\n conv_out_kernel = 3\\n conv_in_padding = (conv_in_kernel - 1) // 2\\n self.conv_in = nn.Conv2d(\\n in_channels, block_out_channels[0], kernel_size=conv_in_kernel, padding=conv_in_padding\\n )\\n self.conv_in2 = nn.Conv2d(\\n 5, block_out_channels[0], kernel_size=conv_in_kernel, padding=conv_in_padding\\n )\\n\\n # time\\n time_embed_dim = block_out_channels[0] * 4\\n self.time_proj = Timesteps(block_out_channels[0], True, 0)\\n timestep_input_dim = block_out_channels[0]\\n\\n self.time_embedding = TimestepEmbedding(\\n timestep_input_dim,\\n time_embed_dim,\\n act_fn=act_fn,\\n cond_proj_dim=block_out_channels[0],\\n )\\n\\n self.motion_proj = Timesteps(block_out_channels[0], True, 0)\\n self.motion_embedding = nn.Sequential(\\n nn.Linear(timestep_input_dim, time_embed_dim), nn.SiLU(),\\n nn.Linear(time_embed_dim, time_embed_dim))\\n nn.init.zeros_(self.motion_embedding[-1].weight)\\n nn.init.zeros_(self.motion_embedding[-1].bias)\\n\\n self.transformer_in = TransformerTemporalModel(\\n num_attention_heads=8,\\n attention_head_dim=attention_head_dim,\\n in_channels=block_out_channels[0],\\n num_layers=1,\\n )\\n\\n # class embedding\\n self.down_blocks = nn.ModuleList([])\\n self.up_blocks = nn.ModuleList([])\\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 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=False,\\n )\\n self.down_blocks.append(down_block)\\n\\n # mid\\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 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=False,\\n )\\n # count how many layers upsample the images\\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\\n output_channel = reversed_block_out_channels[0]\\n for i, up_block_type in enumerate(up_block_types):\\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=False,\\n )\\n self.up_blocks.append(up_block)\\n prev_output_channel = output_channel\\n\\n # out\\n if norm_num_groups is not None:\\n self.conv_norm_out = nn.GroupNorm(\\n num_channels=block_out_channels[0], num_groups=norm_num_groups, eps=norm_eps\\n )\\n self.conv_act = nn.SiLU()\\n else:\\n self.conv_norm_out = None\\n self.conv_act = None\\n\\n conv_out_padding = (conv_out_kernel - 1) // 2\\n self.conv_out = nn.Conv2d(\\n block_out_channels[0], out_channels, kernel_size=conv_out_kernel, padding=conv_out_padding\\n )\\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, value=False):\\n self.gradient_checkpointing = value\\n self.mid_block.gradient_checkpointing = value\\n for module in self.down_blocks + self.up_blocks:\\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 condition_latent: torch.Tensor,\\n mask: torch.Tensor,\\n class_labels: Optional[torch.Tensor] = None,\\n timestep_cond: Optional[torch.Tensor] = None,\\n attention_mask: Optional[torch.Tensor] = None,\\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\\n down_block_additional_residuals: Optional[Tuple[torch.Tensor]] = None,\\n mid_block_additional_residual: Optional[torch.Tensor] = None,\\n motion = None,\\n return_dict: bool = True,\\n ) -> Union[UNet3DConditionOutput, Tuple]:\\n r\\\"\\\"\\\"\\n Args:\\n sample (`torch.FloatTensor`): (batch, num_frames, 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.UNet3DConditionOutput`] instead of a plain tuple.\\n cross_attention_kwargs (`dict`, *optional*):\\n A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under\\n `self.processor` in\\n [diffusers.cross_attention](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py).\\n\\n Returns:\\n [`~models.unet_2d_condition.UNet3DConditionOutput`] or `tuple`:\\n [`~models.unet_2d_condition.UNet3DConditionOutput`] 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 sample = torch.cat([condition_latent, sample], dim=2)\\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 # 1. time\\n timesteps = timestep\\n if not torch.is_tensor(timesteps):\\n # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can\\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 num_frames = sample.shape[2]\\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 if self.motion_strength and motion is not None:\\n timestep_cond = self.motion_proj(motion).to(dtype=self.dtype)\\n emb = self.time_embedding(t_emb, timestep_cond)\\n #emb += self.motion_embedding(m_emb)\\n else:\\n emb = self.time_embedding(t_emb, timestep_cond)\\n emb = emb.repeat_interleave(repeats=num_frames, dim=0)\\n encoder_hidden_states = encoder_hidden_states.repeat_interleave(repeats=num_frames, dim=0)\\n\\n # 2. pre-process\\n if self.motion_mask and mask is not None:\\n mask = repeat(mask , 'b 1 1 h w -> (t b) 1 f h w', t=sample.shape[0]//mask.shape[0], f=sample.shape[2])\\n sample = torch.cat([mask, sample], dim=1)\\n sample = sample.permute(0, 2, 1, 3, 4).reshape((sample.shape[0] * num_frames, -1) + sample.shape[3:])\\n sample = self.conv_in2(sample)\\n else:\\n sample = sample.permute(0, 2, 1, 3, 4).reshape((sample.shape[0] * num_frames, -1) + sample.shape[3:])\\n sample = self.conv_in(sample)\\n\\n if num_frames > 1:\\n if self.gradient_checkpointing:\\n sample = transformer_g_c(self.transformer_in, sample, num_frames)\\n else:\\n sample = self.transformer_in(sample, num_frames=num_frames).sample\\n\\n # 3. down\\n down_block_res_samples = (sample,)\\n for i, downsample_block in enumerate(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 num_frames=num_frames,\\n cross_attention_kwargs=cross_attention_kwargs,\\n )\\n else:\\n sample, res_samples = downsample_block(hidden_states=sample, temb=emb, num_frames=num_frames)\\n \\n down_block_res_samples += res_samples\\n\\n if down_block_additional_residuals is not None:\\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 += (down_block_res_sample,)\\n\\n down_block_res_samples = new_down_block_res_samples\\n\\n # 4. mid\\n if self.mid_block is not None:\\n sample = self.mid_block(\\n sample,\\n emb,\\n encoder_hidden_states=encoder_hidden_states,\\n attention_mask=attention_mask,\\n num_frames=num_frames,\\n cross_attention_kwargs=cross_attention_kwargs,\\n )\\n\\n if mid_block_additional_residual is not None:\\n sample = sample + mid_block_additional_residual\\n\\n # 5. 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 num_frames=num_frames,\\n cross_attention_kwargs=cross_attention_kwargs,\\n )\\n else:\\n sample = upsample_block(\\n hidden_states=sample,\\n temb=emb,\\n res_hidden_states_tuple=res_samples,\\n upsample_size=upsample_size,\\n num_frames=num_frames,\\n )\\n\\n # 6. post-process\\n if self.conv_norm_out:\\n sample = self.conv_norm_out(sample)\\n sample = self.conv_act(sample)\\n\\n sample = self.conv_out(sample)\\n\\n # reshape to (batch, channel, framerate, width, height)\\n sample = sample[None, :].reshape((-1, num_frames) + sample.shape[1:]).permute(0, 2, 1, 3, 4)\\n sample = sample[:,:,1:]\\n if not return_dict:\\n return (sample,)\\n\\n return UNet3DConditionOutput(sample=sample)\"\n },\n {\n \"identifier\": \"MaskStableVideoDiffusionPipeline\",\n \"path\": \"models/pipeline.py\",\n \"snippet\": \"class MaskStableVideoDiffusionPipeline(StableVideoDiffusionPipeline):\\n @torch.no_grad()\\n def __call__(\\n self,\\n image,\\n height: int = 576,\\n width: int = 1024,\\n num_frames: Optional[int] = None,\\n num_inference_steps: int = 25,\\n min_guidance_scale: float = 1.0,\\n max_guidance_scale: float = 3.0,\\n fps: int = 7,\\n motion_bucket_id: int = 127,\\n noise_aug_strength: int = 0.02,\\n decode_chunk_size: Optional[int] = None,\\n num_videos_per_prompt: Optional[int] = 1,\\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\\n latents: Optional[torch.FloatTensor] = None,\\n output_type: Optional[str] = \\\"pil\\\",\\n callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,\\n callback_on_step_end_tensor_inputs: List[str] = [\\\"latents\\\"],\\n return_dict: bool = True,\\n mask = None,\\n ):\\n r\\\"\\\"\\\"\\n The call function to the pipeline for generation.\\n\\n Args:\\n image (`PIL.Image.Image` or `List[PIL.Image.Image]` or `torch.FloatTensor`):\\n Image or images to guide image generation. If you provide a tensor, it needs to be compatible with\\n [`CLIPImageProcessor`](https://huggingface.co/lambdalabs/sd-image-variations-diffusers/blob/main/feature_extractor/preprocessor_config.json).\\n height (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):\\n The height in pixels of the generated image.\\n width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):\\n The width in pixels of the generated image.\\n num_frames (`int`, *optional*):\\n The number of video frames to generate. Defaults to 14 for `stable-video-diffusion-img2vid` and to 25 for `stable-video-diffusion-img2vid-xt`\\n num_inference_steps (`int`, *optional*, defaults to 25):\\n The number of denoising steps. More denoising steps usually lead to a higher quality image at the\\n expense of slower inference. This parameter is modulated by `strength`.\\n min_guidance_scale (`float`, *optional*, defaults to 1.0):\\n The minimum guidance scale. Used for the classifier free guidance with first frame.\\n max_guidance_scale (`float`, *optional*, defaults to 3.0):\\n The maximum guidance scale. Used for the classifier free guidance with last frame.\\n fps (`int`, *optional*, defaults to 7):\\n Frames per second. The rate at which the generated images shall be exported to a video after generation.\\n Note that Stable Diffusion Video's UNet was micro-conditioned on fps-1 during training.\\n motion_bucket_id (`int`, *optional*, defaults to 127):\\n The motion bucket ID. Used as conditioning for the generation. The higher the number the more motion will be in the video.\\n noise_aug_strength (`int`, *optional*, defaults to 0.02):\\n The amount of noise added to the init image, the higher it is the less the video will look like the init image. Increase it for more motion.\\n decode_chunk_size (`int`, *optional*):\\n The number of frames to decode at a time. The higher the chunk size, the higher the temporal consistency\\n between frames, but also the higher the memory consumption. By default, the decoder will decode all frames at once\\n for maximal quality. Reduce `decode_chunk_size` to reduce memory usage.\\n num_videos_per_prompt (`int`, *optional*, defaults to 1):\\n The number of images to generate per prompt.\\n generator (`torch.Generator` or `List[torch.Generator]`, *optional*):\\n A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make\\n generation deterministic.\\n latents (`torch.FloatTensor`, *optional*):\\n Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image\\n generation. Can be used to tweak the same generation with different prompts. If not provided, a latents\\n tensor is generated by sampling using the supplied random `generator`.\\n output_type (`str`, *optional*, defaults to `\\\"pil\\\"`):\\n The output format of the generated image. Choose between `PIL.Image` or `np.array`.\\n callback_on_step_end (`Callable`, *optional*):\\n A function that calls at the end of each denoising steps during the inference. The function is called\\n with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int,\\n callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by\\n `callback_on_step_end_tensor_inputs`.\\n callback_on_step_end_tensor_inputs (`List`, *optional*):\\n The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list\\n will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the\\n `._callback_tensor_inputs` attribute of your pipeline class.\\n return_dict (`bool`, *optional*, defaults to `True`):\\n Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a\\n plain tuple.\\n\\n Returns:\\n [`~pipelines.stable_diffusion.StableVideoDiffusionPipelineOutput`] or `tuple`:\\n If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableVideoDiffusionPipelineOutput`] is returned,\\n otherwise a `tuple` is returned where the first element is a list of list with the generated frames.\\n\\n Examples:\\n\\n ```py\\n from diffusers import StableVideoDiffusionPipeline\\n from diffusers.utils import load_image, export_to_video\\n\\n pipe = StableVideoDiffusionPipeline.from_pretrained(\\\"stabilityai/stable-video-diffusion-img2vid-xt\\\", torch_dtype=torch.float16, variant=\\\"fp16\\\")\\n pipe.to(\\\"cuda\\\")\\n\\n image = load_image(\\\"https://lh3.googleusercontent.com/y-iFOHfLTwkuQSUegpwDdgKmOjRSTvPxat63dQLB25xkTs4lhIbRUFeNBWZzYf370g=s1200\\\")\\n image = image.resize((1024, 576))\\n\\n frames = pipe(image, num_frames=25, decode_chunk_size=8).frames[0]\\n export_to_video(frames, \\\"generated.mp4\\\", fps=7)\\n ```\\n \\\"\\\"\\\"\\n # 0. Default height and width to unet\\n height = height or self.unet.config.sample_size * self.vae_scale_factor\\n width = width or self.unet.config.sample_size * self.vae_scale_factor\\n\\n num_frames = num_frames if num_frames is not None else self.unet.config.num_frames\\n decode_chunk_size = decode_chunk_size if decode_chunk_size is not None else num_frames\\n\\n # 1. Check inputs. Raise error if not correct\\n self.check_inputs(image, height, width)\\n\\n # 2. Define call parameters\\n if isinstance(image, PIL.Image.Image):\\n batch_size = 1\\n elif isinstance(image, list):\\n batch_size = len(image)\\n else:\\n batch_size = image.shape[0]\\n device = self._execution_device\\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\\n # corresponds to doing no classifier free guidance.\\n do_classifier_free_guidance = max_guidance_scale > 1.0\\n\\n # 3. Encode input image\\n image_embeddings = self._encode_image(image, device, num_videos_per_prompt, do_classifier_free_guidance)\\n\\n # NOTE: Stable Diffusion Video was conditioned on fps - 1, which\\n # is why it is reduced here.\\n # See: https://github.com/Stability-AI/generative-models/blob/ed0997173f98eaf8f4edf7ba5fe8f15c6b877fd3/scripts/sampling/simple_video_sample.py#L188\\n fps = fps - 1\\n\\n # 4. Encode input image using VAE\\n image = self.image_processor.preprocess(image, height=height, width=width)\\n noise = randn_tensor(image.shape, generator=generator, device=image.device, dtype=image.dtype)\\n image = image + noise_aug_strength * noise\\n\\n needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast\\n if needs_upcasting:\\n self.vae.to(dtype=torch.float32)\\n\\n image_latents = self._encode_vae_image(image, device, num_videos_per_prompt, do_classifier_free_guidance)\\n image_latents = image_latents.to(image_embeddings.dtype)\\n\\n # cast back to fp16 if needed\\n if needs_upcasting:\\n self.vae.to(dtype=torch.float16)\\n\\n # Repeat the image latents for each frame so we can concatenate them with the noise\\n # image_latents [batch, channels, height, width] ->[batch, num_frames, channels, height, width]\\n image_latents = image_latents.unsqueeze(1).repeat(1, num_frames, 1, 1, 1)\\n mask = repeat(mask, '1 h w -> 2 f 1 h w', f=num_frames)\\n # 5. Get Added Time IDs\\n added_time_ids = self._get_add_time_ids(\\n fps,\\n motion_bucket_id,\\n noise_aug_strength,\\n image_embeddings.dtype,\\n batch_size,\\n num_videos_per_prompt,\\n do_classifier_free_guidance,\\n )\\n added_time_ids = added_time_ids.to(device)\\n\\n # 4. Prepare timesteps\\n self.scheduler.set_timesteps(num_inference_steps, device=device)\\n timesteps = self.scheduler.timesteps\\n\\n # 5. Prepare latent variables\\n num_channels_latents = self.unet.config.in_channels\\n latents = self.prepare_latents(\\n batch_size * num_videos_per_prompt,\\n num_frames,\\n num_channels_latents,\\n height,\\n width,\\n image_embeddings.dtype,\\n device,\\n generator,\\n latents,\\n )\\n\\n # 7. Prepare guidance scale\\n guidance_scale = torch.linspace(min_guidance_scale, max_guidance_scale, num_frames).unsqueeze(0)\\n guidance_scale = guidance_scale.to(device, latents.dtype)\\n guidance_scale = guidance_scale.repeat(batch_size * num_videos_per_prompt, 1)\\n guidance_scale = _append_dims(guidance_scale, latents.ndim)\\n\\n self._guidance_scale = guidance_scale\\n\\n # 8. Denoising loop\\n num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order\\n self._num_timesteps = len(timesteps)\\n with self.progress_bar(total=num_inference_steps) as progress_bar:\\n for i, t in enumerate(timesteps):\\n # expand the latents if we are doing classifier free guidance\\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\\n\\n # Concatenate image_latents over channels dimention\\n latent_model_input = torch.cat([mask, latent_model_input, image_latents], dim=2)\\n\\n # predict the noise residual\\n noise_pred = self.unet(\\n latent_model_input,\\n t,\\n encoder_hidden_states=image_embeddings,\\n added_time_ids=added_time_ids,\\n return_dict=False,\\n )[0]\\n\\n # perform guidance\\n if do_classifier_free_guidance:\\n noise_pred_uncond, noise_pred_cond = noise_pred.chunk(2)\\n noise_pred = noise_pred_uncond + self.guidance_scale * (noise_pred_cond - noise_pred_uncond)\\n\\n # compute the previous noisy sample x_t -> x_t-1\\n latents = self.scheduler.step(noise_pred, t, latents).prev_sample\\n\\n if callback_on_step_end is not None:\\n callback_kwargs = {}\\n for k in callback_on_step_end_tensor_inputs:\\n callback_kwargs[k] = locals()[k]\\n callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)\\n\\n latents = callback_outputs.pop(\\\"latents\\\", latents)\\n\\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\\n progress_bar.update()\\n\\n if not output_type == \\\"latent\\\":\\n # cast back to fp16 if needed\\n if needs_upcasting:\\n self.vae.to(dtype=torch.float16)\\n frames = self.decode_latents(latents, num_frames, decode_chunk_size)\\n frames = svd_tensor2vid(frames, self.image_processor, output_type=output_type)\\n else:\\n frames = latents\\n\\n self.maybe_free_model_hooks()\\n\\n if not return_dict:\\n return frames\\n\\n return StableVideoDiffusionPipelineOutput(frames=frames)\"\n },\n {\n \"identifier\": \"LoraHandler\",\n \"path\": \"utils/lora_handler.py\",\n \"snippet\": \"class LoraHandler(object):\\n def __init__(\\n self, \\n version: LORA_VERSIONS = LoraVersions.cloneofsimo, \\n use_unet_lora: bool = False,\\n use_text_lora: bool = False,\\n save_for_webui: bool = False,\\n only_for_webui: bool = False,\\n lora_bias: str = 'none',\\n unet_replace_modules: list = ['UNet3DConditionModel'],\\n text_encoder_replace_modules: list = ['CLIPEncoderLayer']\\n ):\\n self.version = version\\n self.lora_loader = self.get_lora_func(func_type=LoraFuncTypes.loader)\\n self.lora_injector = self.get_lora_func(func_type=LoraFuncTypes.injector)\\n self.lora_bias = lora_bias\\n self.use_unet_lora = use_unet_lora\\n self.use_text_lora = use_text_lora\\n self.save_for_webui = save_for_webui\\n self.only_for_webui = only_for_webui\\n self.unet_replace_modules = unet_replace_modules\\n self.text_encoder_replace_modules = text_encoder_replace_modules\\n self.use_lora = any([use_text_lora, use_unet_lora])\\n\\n if self.use_lora:\\n print(f\\\"Using LoRA Version: {self.version}\\\")\\n\\n def is_cloneofsimo_lora(self):\\n return self.version == LoraVersions.cloneofsimo\\n\\n def is_stable_lora(self):\\n return self.version == LoraVersions.stable_lora\\n\\n def get_lora_func(self, func_type: LORA_FUNC_TYPES = LoraFuncTypes.loader):\\n\\n if self.is_cloneofsimo_lora():\\n\\n if func_type == LoraFuncTypes.loader:\\n return monkeypatch_or_replace_lora_extended\\n\\n if func_type == LoraFuncTypes.injector:\\n return inject_trainable_lora_extended\\n\\n if self.is_stable_lora():\\n\\n if func_type == LoraFuncTypes.loader:\\n return load_lora\\n\\n if func_type == LoraFuncTypes.injector:\\n return add_lora_to\\n \\n assert \\\"LoRA Version does not exist.\\\"\\n\\n def check_lora_ext(self, lora_file: str):\\n return lora_file.endswith(tuple(LORA_FILE_TYPES))\\n\\n def get_lora_file_path(\\n self, \\n lora_path: str, \\n model: Union[UNet3DConditionModel, CLIPTextModel]\\n ):\\n if os.path.exists(lora_path):\\n lora_filenames = [fns for fns in os.listdir(lora_path)]\\n is_lora = self.check_lora_ext(lora_path)\\n\\n is_unet = isinstance(model, UNet3DConditionModel)\\n is_text = isinstance(model, CLIPTextModel)\\n idx = 0 if is_unet else 1\\n\\n base_name = FILE_BASENAMES[idx]\\n \\n for lora_filename in lora_filenames:\\n is_lora = self.check_lora_ext(lora_filename)\\n if not is_lora:\\n continue\\n \\n if base_name in lora_filename:\\n return os.path.join(lora_path, lora_filename)\\n\\n return None\\n\\n def handle_lora_load(self, file_name:str, lora_loader_args: dict = None):\\n self.lora_loader(**lora_loader_args)\\n print(f\\\"Successfully loaded LoRA from: {file_name}\\\")\\n \\n def load_lora(self, model, lora_path: str = '', lora_loader_args: dict = None,):\\n try:\\n lora_file = self.get_lora_file_path(lora_path, model)\\n\\n if lora_file is not None:\\n lora_loader_args.update({\\\"lora_path\\\": lora_file})\\n self.handle_lora_load(lora_file, lora_loader_args)\\n\\n else:\\n print(f\\\"Could not load LoRAs for {model.__class__.__name__}. Injecting new ones instead...\\\")\\n\\n except Exception as e:\\n print(f\\\"An error occured while loading a LoRA file: {e}\\\")\\n \\n def get_lora_func_args(self, lora_path, use_lora, model, replace_modules, r, dropout, lora_bias):\\n return_dict = lora_args.copy()\\n \\n if self.is_cloneofsimo_lora():\\n return_dict = filter_dict(return_dict, keys=CLONE_OF_SIMO_KEYS)\\n return_dict.update({\\n \\\"model\\\": model,\\n \\\"loras\\\": self.get_lora_file_path(lora_path, model),\\n \\\"target_replace_module\\\": replace_modules,\\n \\\"r\\\": r\\n })\\n\\n if self.is_stable_lora():\\n KEYS = ['model', 'lora_path']\\n return_dict = filter_dict(return_dict, KEYS)\\n \\n return_dict.update({'model': model, 'lora_path': lora_path})\\n\\n return return_dict\\n\\n def do_lora_injection(\\n self, \\n model, \\n replace_modules, \\n bias='none',\\n dropout=0,\\n r=4,\\n lora_loader_args=None,\\n ): \\n REPLACE_MODULES = replace_modules\\n\\n params = None\\n negation = None\\n is_injection_hybrid = False\\n \\n if self.is_cloneofsimo_lora():\\n is_injection_hybrid = True\\n injector_args = lora_loader_args\\n\\n params, negation = self.lora_injector(**injector_args) \\n for _up, _down in extract_lora_ups_down(\\n model, \\n target_replace_module=REPLACE_MODULES):\\n\\n if all(x is not None for x in [_up, _down]):\\n print(f\\\"Lora successfully injected into {model.__class__.__name__}.\\\")\\n\\n break\\n\\n return params, negation, is_injection_hybrid\\n\\n if self.is_stable_lora():\\n injector_args = lora_args.copy()\\n injector_args = filter_dict(injector_args, keys=STABLE_LORA_KEYS)\\n\\n SEARCH_CLASS = [torch.nn.Linear, torch.nn.Conv2d, torch.nn.Conv3d, torch.nn.Embedding]\\n\\n injector_args.update({\\n \\\"model\\\": model,\\n \\\"target_module\\\": REPLACE_MODULES,\\n \\\"search_class\\\": SEARCH_CLASS,\\n \\\"r\\\": r,\\n \\\"dropout\\\": dropout,\\n \\\"lora_bias\\\": self.lora_bias\\n })\\n\\n activator = self.lora_injector(**injector_args)\\n activator()\\n\\n return params, negation, is_injection_hybrid\\n\\n def add_lora_to_model(self, use_lora, model, replace_modules, dropout=0.0, lora_path='', r=16):\\n\\n params = None\\n negation = None\\n\\n lora_loader_args = self.get_lora_func_args(\\n lora_path,\\n use_lora,\\n model,\\n replace_modules,\\n r,\\n dropout,\\n self.lora_bias\\n )\\n if use_lora:\\n params, negation, is_injection_hybrid = self.do_lora_injection(\\n model, \\n replace_modules, \\n bias=self.lora_bias,\\n lora_loader_args=lora_loader_args,\\n dropout=dropout,\\n r=r\\n )\\n\\n if not is_injection_hybrid:\\n self.load_lora(model, lora_path=lora_path, lora_loader_args=lora_loader_args)\\n \\n params = model if params is None else params\\n return params, negation\\n \\n\\n def deactivate_lora_train(self, models, deactivate=True):\\n \\\"\\\"\\\"\\n Usage: Use before and after sampling previews.\\n Currently only available for Stable LoRA.\\n \\\"\\\"\\\"\\n if self.is_stable_lora():\\n set_mode_group(models, not deactivate)\\n\\n def save_cloneofsimo_lora(self, model, save_path, step):\\n \\n def save_lora(model, name, condition, replace_modules, step, save_path): \\n if condition and replace_modules is not None:\\n save_path = f\\\"{save_path}/{step}_{name}.pt\\\"\\n save_lora_weight(model, save_path, replace_modules)\\n\\n save_lora(\\n model.unet, \\n FILE_BASENAMES[0], \\n self.use_unet_lora, \\n self.unet_replace_modules, \\n step,\\n save_path, \\n )\\n save_lora(\\n model.text_encoder, \\n FILE_BASENAMES[1], \\n self.use_text_lora, \\n self.text_encoder_replace_modules, \\n step, \\n save_path\\n )\\n\\n train_patch_pipe(model, self.use_unet_lora, self.use_text_lora)\\n\\n def save_stable_lora(\\n self, \\n model, \\n step, \\n name, \\n save_path = '', \\n save_for_webui=False,\\n only_for_webui=False\\n ):\\n import uuid\\n\\n save_filename = f\\\"{step}_{name}\\\"\\n lora_metadata = metadata = {\\n \\\"stable_lora_text_to_video\\\": \\\"v1\\\", \\n \\\"lora_name\\\": name + \\\"_\\\" + uuid.uuid4().hex.lower()[:5]\\n }\\n save_lora(\\n unet=model.unet,\\n text_encoder=model.text_encoder,\\n save_text_weights=self.use_text_lora,\\n output_dir=save_path,\\n lora_filename=save_filename,\\n lora_bias=self.lora_bias,\\n save_for_webui=self.save_for_webui,\\n only_webui=self.only_for_webui,\\n metadata=lora_metadata,\\n unet_dict_converter=convert_unet_state_dict,\\n text_dict_converter=convert_text_enc_state_dict_v20\\n )\\n\\n def save_lora_weights(self, model: None, save_path: str ='',step: str = ''):\\n save_path = f\\\"{save_path}/lora\\\"\\n os.makedirs(save_path, exist_ok=True)\\n\\n if self.is_cloneofsimo_lora():\\n if any([self.save_for_webui, self.only_for_webui]):\\n warnings.warn(\\n \\\"\\\"\\\"\\n You have 'save_for_webui' enabled, but are using cloneofsimo's LoRA implemention.\\n Only 'stable_lora' is supported for saving to a compatible webui file.\\n \\\"\\\"\\\"\\n )\\n self.save_cloneofsimo_lora(model, save_path, step)\\n\\n if self.is_stable_lora():\\n name = 'lora_text_to_video'\\n self.save_stable_lora(model, step, name, save_path)\"\n },\n {\n \"identifier\": \"LORA_VERSIONS\",\n \"path\": \"utils/lora_handler.py\",\n \"snippet\": \"LORA_VERSIONS = [LoraVersions.stable_lora, LoraVersions.cloneofsimo]\"\n },\n {\n \"identifier\": \"read_mask\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def read_mask(json_path, label=[\\\"mask\\\"]):\\n j = json.load(open(json_path)) \\n if type(label) != list:\\n labels = [label]\\n height = j['imageHeight']\\n width = j['imageWidth']\\n mask = np.zeros([height, width], dtype=np.uint8)\\n for shape in j['shapes']:\\n if shape['label'] in label:\\n x1, y1 = shape['points'][0]\\n x2, y2 = shape['points'][1]\\n mask[int(y1):int(y2), int(x1):int(x2)] = 255\\n return mask\"\n },\n {\n \"identifier\": \"generate_random_mask\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def generate_random_mask(image):\\n # Create a blank mask with the same size as the image\\n b, c , h, w = image.shape\\n mask = np.zeros([b, h, w], dtype=np.uint8)\\n \\n # Generate random coordinates for the mask\\n num_points = np.random.randint(3, 10) # Randomly choose the number of points to generate\\n points = np.random.randint(0, min(h, w), size=(num_points, 2)) # Randomly generate the points\\n # Draw a filled polygon on the mask using the random points\\n for i in range(b):\\n width = random.randint(w//4, w)\\n height = random.randint(h//4, h)\\n x = random.randint(0, w-width)\\n y = random.randint(0, h-height)\\n points=np.array([[x, y], [x+width, y], [x+width, y+height], [x, y+height]])\\n mask[i] = cv2.fillPoly(mask[i], [points], 255)\\n \\n # Apply the mask to the image\\n #masked_image = cv2.bitwise_and(image, image, mask=mask)\\n return mask \"\n },\n {\n \"identifier\": \"slerp\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def slerp(z1, z2, alpha):\\n theta = torch.acos(torch.sum(z1 * z2) / (torch.norm(z1) * torch.norm(z2)))\\n return (\\n torch.sin((1 - alpha) * theta) / torch.sin(theta) * z1\\n + torch.sin(alpha * theta) / torch.sin(theta) * z2\\n )\"\n },\n {\n \"identifier\": \"calculate_motion_score\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def calculate_motion_score(frame_imgs, calculate_edges=False, color=\\\"RGB\\\") -> float:\\n # Convert image into HSV colorspace.\\n _last_frame = None\\n\\n _weights = [1.0, 1.0, 1.0, 0.0]\\n score = 0\\n for frame_img in frame_imgs:\\n if color == \\\"RGB\\\":\\n hue, sat, lum = cv2.split(cv2.cvtColor(frame_img, cv2.COLOR_RGB2HSV))\\n else:\\n hue, sat, lum = cv2.split(cv2.cvtColor(frame_img, cv2.COLOR_BGR2HSV))\\n # Performance: Only calculate edges if we have to.\\n edges = _detect_edges(lum) if calculate_edges else None\\n if _last_frame == None:\\n _last_frame = (hue, sat, lum, edges)\\n continue\\n\\n score_components = [\\n _mean_pixel_distance(hue, _last_frame[0]),\\n _mean_pixel_distance(sat, _last_frame[1]),\\n _mean_pixel_distance(lum, _last_frame[2]),\\n 0.0 if edges is None else _mean_pixel_distance(edges, _last_frame[3]),\\n ]\\n\\n frame_score: float = (\\n sum(component * weight for (component, weight) in zip(score_components, _weights))\\n / sum(abs(weight) for weight in _weights))\\n score += frame_score\\n _last_frame = (hue, sat, lum, edges)\\n\\n return round(score/(len(frame_imgs)-1) * 10)\"\n },\n {\n \"identifier\": \"read_video\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def read_video(video_path, frame_number=-1):\\n # Open the video file\\n cap = cv2.VideoCapture(video_path)\\n count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) \\n if frame_number == -1:\\n frame_number = count\\n else:\\n frame_number = min(frame_number, count)\\n frames = []\\n for i in range(frame_number):\\n ret, ref_frame = cap.read()\\n ref_frame = cv2.cvtColor(ref_frame, cv2.COLOR_BGR2RGB)\\n if not ret:\\n raise ValueError(\\\"Failed to read video file\\\")\\n frames.append(ref_frame)\\n return frames\"\n },\n {\n \"identifier\": \"calculate_motion_precision\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def calculate_motion_precision(frames, mask):\\n moved_mask = get_moved_area_mask(frames, move_th=20, th=0)\\n moved = moved_mask == 255\\n gt = mask == 255\\n precision = np.sum(moved & gt) / np.sum(moved)\\n return precision\"\n },\n {\n \"identifier\": \"calculate_latent_motion_score\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def calculate_latent_motion_score(latents):\\n #latents b, c f, h, w\\n diff=torch.abs(latents[:,:,1:]-latents[:,:,:-1])\\n motion_score = torch.sum(torch.mean(diff, dim=[2,3,4]), dim=1) * 10\\n return motion_score\"\n },\n {\n \"identifier\": \"DDPM_forward\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def DDPM_forward(x0, step, num_frames, scheduler):\\n device = x0.device\\n t = scheduler.timesteps[-1]\\n xt = repeat(x0, 'b c 1 h w -> b c f h w', f = num_frames)\\n\\n eps = torch.randn_like(xt)\\n alpha_vec = torch.prod(scheduler.alphas[t:])\\n xt = torch.sqrt(alpha_vec) * xt + torch.sqrt(1-alpha_vec) * eps\\n return xt, None\"\n },\n {\n \"identifier\": \"DDPM_forward_timesteps\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def DDPM_forward_timesteps(x0, step, num_frames, scheduler):\\n '''larger step -> smaller t -> smaller alphas[t:] -> smaller xt -> smaller x0'''\\n\\n device = x0.device\\n # timesteps are reversed\\n timesteps = scheduler.timesteps[len(scheduler.timesteps)-step:]\\n t = timesteps[0]\\n\\n if x0.shape[2] == 1:\\n xt = repeat(x0, 'b c 1 h w -> b c f h w', f = num_frames)\\n else:\\n xt = x0\\n noise = torch.randn(xt.shape, dtype=xt.dtype, device=device)\\n # t to tensor of batch size \\n t = torch.tensor([t]*xt.shape[0], device=device)\\n xt = scheduler.add_noise(xt, noise, t)\\n return xt, timesteps\"\n },\n {\n \"identifier\": \"motion_mask_loss\",\n \"path\": \"utils/common.py\",\n \"snippet\": \"def motion_mask_loss(latents, mask):\\n diff = torch.abs(latents[:,:,1:] - latents[:,:,:-1])\\n loss = torch.sum(torch.mean(diff * (1-mask), dim=[2,3,4]), dim=1)\\n return loss\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import argparse\nimport datetime\nimport logging\nimport inspect\nimport math\nimport os\nimport random\nimport gc\nimport copy\nimport json\nimport numpy as np\nimport cv2\nimport torch\nimport torch.nn.functional as F\nimport torch.utils.checkpoint\nimport torchvision.transforms as T\nimport diffusers\nimport transformers\nimport imageio\n import itertools\n import bitsandbytes as bnb\nfrom typing import Dict, Optional, Tuple\nfrom omegaconf import OmegaConf\nfrom tqdm.auto import tqdm\nfrom PIL import Image\nfrom accelerate import Accelerator\nfrom accelerate.logging import get_logger\nfrom accelerate.utils import set_seed\nfrom diffusers.models import AutoencoderKL, UNetSpatioTemporalConditionModel\nfrom diffusers import DPMSolverMultistepScheduler, DDPMScheduler, EulerDiscreteScheduler\nfrom diffusers.image_processor import VaeImageProcessor\nfrom diffusers.optimization import get_scheduler\nfrom diffusers.utils import check_min_version, export_to_video\nfrom diffusers.utils.import_utils import is_xformers_available\nfrom diffusers.models.attention_processor import AttnProcessor2_0, Attention\nfrom diffusers.models.attention import BasicTransformerBlock\nfrom diffusers.pipelines.text_to_video_synthesis.pipeline_text_to_video_synth import tensor2vid\nfrom diffusers import StableVideoDiffusionPipeline\nfrom diffusers.pipelines.stable_video_diffusion.pipeline_stable_video_diffusion import _resize_with_antialiasing\nfrom transformers import CLIPTextModel, CLIPTokenizer, CLIPVisionModel, CLIPImageProcessor, CLIPTextConfig\nfrom transformers.models.clip.modeling_clip import CLIPEncoder\nfrom utils.dataset import VideoJsonDataset, SingleVideoDataset, \\\n ImageDataset, VideoFolderDataset, CachedDataset, VideoBLIPDataset\nfrom einops import rearrange, repeat\nfrom models.unet_3d_condition_mask import UNet3DConditionModel\nfrom models.pipeline import MaskStableVideoDiffusionPipeline\nfrom utils.lora_handler import LoraHandler, LORA_VERSIONS\nfrom utils.common import read_mask, generate_random_mask, slerp, calculate_motion_score, \\\n read_video, calculate_motion_precision, calculate_latent_motion_score, \\\n DDPM_forward, DDPM_forward_timesteps, motion_mask_loss\n from xformers.ops import MemoryEfficientAttentionFlashAttentionOp"},"token_num":{"kind":"number","value":20491,"string":"20,491"},"cropped_code":{"kind":"string","value":" pixel_values = batch[\"pixel_values\"]\n bsz, num_frames = pixel_values.shape[:2]\n frames = rearrange(pixel_values, 'b f c h w-> (b f) c h w')\n latents = vae.encode(frames).latent_dist.mode()\n latents = rearrange(latents, '(b f) c h w-> b f c h w', b=bsz)\n latents = latents * vae.config.scaling_factor\n if motion_mask:\n mask = batch[\"mask\"]\n mask = mask.div(255).to(latents.device)\n h, w = latents.shape[-2:]\n mask = T.Resize((h, w), antialias=False)(mask)\n mask[mask<0.5] = 0\n mask[mask>=0.5] = 1\n mask = rearrange(mask, 'b h w -> b 1 1 h w')\n freeze = repeat(latents[:,0], 'b c h w -> b f c h w', f=num_frames)\n latents = freeze * (1-mask) + latents * mask\n\n # enocde image latent\n image = pixel_values[:,0]\n image = image + noise_aug_strength * torch.randn_like(image)\n image_latents = vae.encode(image).latent_dist.mode()\n image_latents = repeat(image_latents, 'b c h w->b f c h w',f=num_frames)\n\n # vae image to clip image\n images = _resize_with_antialiasing(pixel_values[:,0], (224, 224))\n images = (images + 1.0) / 2.0 # [-1, 1] -> [0, 1]\n images = pipeline.feature_extractor(\n images=images,\n do_normalize=True,\n do_center_crop=False,\n do_resize=False,\n do_rescale=False,\n return_tensors=\"pt\",\n ).pixel_values \n image_embeddings = pipeline._encode_image(images, device, 1, False)\n negative_image_embeddings = torch.zeros_like(image_embeddings)\n\n # Add noise to the latents according to the noise magnitude at each timestep\n # (this is the forward diffusion process) #[bsz, f, c, h , w]\n rnd_normal = torch.randn([bsz, 1, 1, 1, 1], device=device)\n sigma = (rnd_normal * P_std + P_mean).exp()\n c_skip = 1 / (sigma**2 + 1)\n c_out = -sigma / (sigma**2 + 1) ** 0.5\n c_in = 1 / (sigma**2 + 1) ** 0.5\n c_noise = sigma.log() / 4\n loss_weight = (sigma ** 2 + 1) / sigma ** 2\n\n noisy_latents = latents + torch.randn_like(latents) * sigma\n input_latents = c_in * noisy_latents\n input_latents = torch.cat([input_latents, image_latents], dim=2)\n if motion_mask:\n mask = repeat(mask, 'b 1 1 h w -> b f 1 h w', f=num_frames)\n input_latents = torch.cat([mask, input_latents], dim=2)\n\n motion_bucket_id = 127\n fps = 7\n added_time_ids = pipeline._get_add_time_ids(fps, motion_bucket_id, \n noise_aug_strength, image_embeddings.dtype, bsz, 1, False)\n added_time_ids = added_time_ids.to(device)\n\n losses = []\n for i in range(2):\n encoder_hidden_states = (\n negative_image_embeddings if i==0 else image_embeddings\n )\n model_pred = unet(input_latents, c_noise.reshape([bsz]), encoder_hidden_states=encoder_hidden_states, \n added_time_ids=added_time_ids,).sample\n predict_x0 = c_out * model_pred + c_skip * noisy_latents \n loss = ((predict_x0 - latents)**2 * loss_weight).mean()\n '''\n if motion_mask:\n loss += F.mse_loss(predict_x0*(1-mask), freeze*(1-mask))\n ''' \n losses.append(loss)\n loss = losses[0] if len(losses) == 1 else losses[0] + losses[1] \n return loss\n\n\ndef main(\n pretrained_model_path: str,\n output_dir: str,\n train_data: Dict,\n validation_data: Dict,\n extra_train_data: list = [],\n dataset_types: Tuple[str] = ('json'),\n shuffle: bool = True,\n validation_steps: int = 100,\n trainable_modules: Tuple[str] = None, # Eg: (\"attn1\", \"attn2\")\n trainable_text_modules: Tuple[str] = None, # Eg: (\"all\"), this also applies to trainable_modules\n extra_unet_params = None,\n extra_text_encoder_params = None,\n train_batch_size: int = 1,\n max_train_steps: int = 500,\n learning_rate: float = 5e-5,\n scale_lr: bool = False,\n lr_scheduler: str = \"constant\",\n lr_warmup_steps: int = 0,\n adam_beta1: float = 0.9,\n adam_beta2: float = 0.999,\n adam_weight_decay: float = 1e-2,\n adam_epsilon: float = 1e-08,\n max_grad_norm: float = 1.0,\n gradient_accumulation_steps: int = 1,\n gradient_checkpointing: bool = False,\n text_encoder_gradient_checkpointing: bool = False,\n checkpointing_steps: int = 500,\n resume_from_checkpoint: Optional[str] = None,\n resume_step: Optional[int] = None,\n mixed_precision: Optional[str] = \"fp16\",\n use_8bit_adam: bool = False,\n enable_xformers_memory_efficient_attention: bool = True,\n enable_torch_2_attn: bool = False,\n seed: Optional[int] = None,\n train_text_encoder: bool = False,\n use_offset_noise: bool = False,\n rescale_schedule: bool = False,\n offset_noise_strength: float = 0.1,\n extend_dataset: bool = False,\n cache_latents: bool = False,\n cached_latent_dir = None,\n"},"all_code":{"kind":"string","value":"\n\n\n\n\n\n\n\nalready_printed_trainables = False\n\nlogger = get_logger(__name__, log_level=\"INFO\")\n\ndef create_logging(logging, logger, accelerator):\n logging.basicConfig(\n format=\"%(asctime)s - %(levelname)s - %(name)s - %(message)s\",\n datefmt=\"%m/%d/%Y %H:%M:%S\",\n level=logging.INFO,\n )\n logger.info(accelerator.state, main_process_only=False)\n\ndef accelerate_set_verbose(accelerator):\n if accelerator.is_local_main_process:\n transformers.utils.logging.set_verbosity_warning()\n diffusers.utils.logging.set_verbosity_info()\n else:\n transformers.utils.logging.set_verbosity_error()\n diffusers.utils.logging.set_verbosity_error()\n\ndef get_train_dataset(dataset_types, train_data, tokenizer):\n train_datasets = []\n dataset_cls = [VideoJsonDataset, SingleVideoDataset, ImageDataset, VideoFolderDataset, VideoBLIPDataset]\n dataset_map = {d.__getname__(): d for d in dataset_cls}\n\n # Loop through all available datasets, get the name, then add to list of data to process.\n for dataset in dataset_types:\n if dataset in dataset_map:\n train_datasets.append(dataset_map[dataset](**train_data, tokenizer=tokenizer))\n else:\n raise ValueError(f\"Dataset type not found: {dataset} not in {dataset_map.keys()}\")\n return train_datasets\n\ndef extend_datasets(datasets, dataset_items, extend=False):\n biggest_data_len = max(x.__len__() for x in datasets)\n extended = []\n for dataset in datasets:\n if dataset.__len__() == 0:\n del dataset\n continue\n if dataset.__len__() < biggest_data_len:\n for item in dataset_items:\n if extend and item not in extended and hasattr(dataset, item):\n print(f\"Extending {item}\")\n\n value = getattr(dataset, item)\n value *= biggest_data_len\n value = value[:biggest_data_len]\n\n setattr(dataset, item, value)\n\n print(f\"New {item} dataset length: {dataset.__len__()}\")\n extended.append(item)\n\ndef export_to_video(video_frames, output_video_path, fps):\n fourcc = cv2.VideoWriter_fourcc(*\"mp4v\")\n h, w, _ = video_frames[0].shape\n video_writer = cv2.VideoWriter(output_video_path, fourcc, fps=fps, frameSize=(w, h))\n for i in range(len(video_frames)):\n img = cv2.cvtColor(video_frames[i], cv2.COLOR_RGB2BGR)\n video_writer.write(img)\n\ndef create_output_folders(output_dir, config):\n now = datetime.datetime.now().strftime(\"%Y-%m-%dT%H-%M-%S\")\n out_dir = os.path.join(output_dir, f\"train_{now}\")\n \n os.makedirs(out_dir, exist_ok=True)\n os.makedirs(f\"{out_dir}/samples\", exist_ok=True)\n OmegaConf.save(config, os.path.join(out_dir, 'config.yaml'))\n\n return out_dir\n\ndef load_primary_models(pretrained_model_path, eval=False):\n if eval:\n pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path, torch_dtype=torch.float16, variant='fp16')\n else:\n pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path)\n return pipeline, None, pipeline.feature_extractor, pipeline.scheduler, pipeline.image_processor, \\\n pipeline.image_encoder, pipeline.vae, pipeline.unet\n\ndef convert_svd(pretrained_model_path, out_path):\n pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path)\n\n unet = UNetSpatioTemporalConditionModel.from_pretrained(\n pretrained_model_path, subfolder=\"unet_mask\", low_cpu_mem_usage=False, ignore_mismatched_sizes=True)\n unet.conv_in.bias.data = copy.deepcopy(pipeline.unet.conv_in.bias)\n torch.nn.init.zeros_(unet.conv_in.weight)\n unet.conv_in.weight.data[:,1:]= copy.deepcopy(pipeline.unet.conv_in.weight)\n new_pipeline = StableVideoDiffusionPipeline.from_pretrained(\n pretrained_model_path, unet=unet)\n new_pipeline.save_pretrained(out_path)\n\ndef handle_cache_latents(\n should_cache, \n output_dir, \n train_dataloader, \n train_batch_size, \n pipeline,\n device,\n cached_latent_dir=None,\n shuffle=False,\n ):\n\n # Cache latents by storing them in VRAM. \n # Speeds up training and saves memory by not encoding during the train loop.\n if not should_cache: return None\n pipeline.to(device, dtype=torch.half) \n cached_latent_dir = (\n os.path.abspath(cached_latent_dir) if cached_latent_dir is not None else None \n )\n\n if cached_latent_dir is None:\n cache_save_dir = f\"{output_dir}/cached_latents\"\n os.makedirs(cache_save_dir, exist_ok=True)\n\n for i, batch in enumerate(tqdm(train_dataloader, desc=\"Caching Latents.\")):\n save_name = f\"cached_{i}\"\n full_out_path = f\"{cache_save_dir}/{save_name}.pt\"\n\n pixel_values = batch['pixel_values'].to(device)\n bsz, num_frames = pixel_values.shape[:2]\n frames = rearrange(pixel_values, 'b f c h w-> (b f) c h w').to(torch.half)\n latents = pipeline.vae.encode(frames).latent_dist.mode()\n latents = rearrange(latents, '(b f) c h w-> b f c h w', b=bsz)\n latents = latents * pipeline.vae.config.scaling_factor\n batch['latent'] = latents\n # vae image to clip image\n images = _resize_with_antialiasing(pixel_values[:,0], (224, 224)).to(torch.half)\n images = (images + 1.0) / 2.0 # [-1, 1] -> [0, 1]\n images = pipeline.feature_extractor(\n images=images,\n do_normalize=True,\n do_center_crop=False,\n do_resize=False,\n do_rescale=False,\n return_tensors=\"pt\",\n ).pixel_values \n\n image_embeddings = pipeline._encode_image(images, device, 1, False)\n batch['image_embeddings'] = image_embeddings\n\n for k, v in batch.items(): batch[k] = v[0]\n torch.save(batch, full_out_path)\n del pixel_values\n del batch\n\n # We do this to avoid fragmentation from casting latents between devices.\n torch.cuda.empty_cache()\n else:\n cache_save_dir = cached_latent_dir\n \n\n return torch.utils.data.DataLoader(\n CachedDataset(cache_dir=cache_save_dir), \n batch_size=train_batch_size, \n shuffle=shuffle,\n num_workers=0\n ) \n\ndef _set_gradient_checkpointing(self, value=False):\n self.gradient_checkpointing = value\n self.mid_block.gradient_checkpointing = value\n for module in self.down_blocks + self.up_blocks:\n module.gradient_checkpointing = value \n \ndef unet_and_text_g_c(unet, text_encoder, unet_enable, text_enable):\n _set_gradient_checkpointing(unet, value=unet_enable)\n if text_enable:\n text_encoder.gradient_checkpointing_enable()\n else:\n text_encoder.gradient_checkpointing_disable()\n\ndef freeze_models(models_to_freeze):\n for model in models_to_freeze:\n if model is not None: model.requires_grad_(False) \n \ndef is_attn(name):\n return ('attn1' or 'attn2' == name.split('.')[-1])\n\ndef set_processors(attentions):\n for attn in attentions: attn.set_processor(AttnProcessor2_0()) \n\ndef set_torch_2_attn(unet):\n optim_count = 0\n \n for name, module in unet.named_modules():\n if is_attn(name):\n if isinstance(module, torch.nn.ModuleList):\n for m in module:\n if isinstance(m, BasicTransformerBlock):\n set_processors([m.attn1, m.attn2])\n optim_count += 1\n if optim_count > 0: \n print(f\"{optim_count} Attention layers using Scaled Dot Product Attention.\")\n\ndef handle_memory_attention(enable_xformers_memory_efficient_attention, enable_torch_2_attn, unet): \n try:\n is_torch_2 = hasattr(F, 'scaled_dot_product_attention')\n enable_torch_2 = is_torch_2 and enable_torch_2_attn\n \n if enable_xformers_memory_efficient_attention and not enable_torch_2:\n if is_xformers_available():\n unet.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)\n else:\n raise ValueError(\"xformers is not available. Make sure it is installed correctly\")\n \n if enable_torch_2:\n set_torch_2_attn(unet)\n \n except:\n print(\"Could not enable memory efficient attention for xformers or Torch 2.0.\")\n\ndef param_optim(model, condition, extra_params=None, is_lora=False, negation=None):\n extra_params = extra_params if len(extra_params.keys()) > 0 else None\n return {\n \"model\": model, \n \"condition\": condition, \n 'extra_params': extra_params,\n 'is_lora': is_lora,\n \"negation\": negation\n }\n \n\ndef create_optim_params(name='param', params=None, lr=5e-6, extra_params=None):\n params = {\n \"name\": name, \n \"params\": params, \n \"lr\": lr\n }\n if extra_params is not None:\n for k, v in extra_params.items():\n params[k] = v\n \n return params\n\ndef negate_params(name, negation):\n # We have to do this if we are co-training with LoRA.\n # This ensures that parameter groups aren't duplicated.\n if negation is None: return False\n for n in negation:\n if n in name and 'temp' not in name:\n return True\n return False\n\n\ndef create_optimizer_params(model_list, lr):\n optimizer_params = []\n\n for optim in model_list:\n model, condition, extra_params, is_lora, negation = optim.values()\n # Check if we are doing LoRA training.\n if is_lora and condition and isinstance(model, list): \n params = create_optim_params(\n params=itertools.chain(*model), \n extra_params=extra_params\n )\n optimizer_params.append(params)\n continue\n \n if is_lora and condition and not isinstance(model, list):\n for n, p in model.named_parameters():\n if 'lora' in n:\n params = create_optim_params(n, p, lr, extra_params)\n optimizer_params.append(params)\n continue\n\n # If this is true, we can train it.\n if condition:\n for n, p in model.named_parameters():\n should_negate = 'lora' in n and not is_lora\n if should_negate: continue\n\n params = create_optim_params(n, p, lr, extra_params)\n optimizer_params.append(params)\n \n return optimizer_params\n\ndef get_optimizer(use_8bit_adam):\n if use_8bit_adam:\n try:\n except ImportError:\n raise ImportError(\n \"Please install bitsandbytes to use 8-bit Adam. You can do so by running `pip install bitsandbytes`\"\n )\n\n return bnb.optim.AdamW8bit\n else:\n return torch.optim.AdamW\n\ndef is_mixed_precision(accelerator):\n weight_dtype = torch.float32\n\n if accelerator.mixed_precision == \"fp16\":\n weight_dtype = torch.float16\n\n elif accelerator.mixed_precision == \"bf16\":\n weight_dtype = torch.bfloat16\n\n return weight_dtype\n\ndef cast_to_gpu_and_type(model_list, device, weight_dtype):\n for model in model_list:\n if model is not None: model.to(device, dtype=weight_dtype)\n\ndef handle_trainable_modules(model, trainable_modules=None, is_enabled=True, negation=None):\n global already_printed_trainables\n\n # This can most definitely be refactored :-)\n unfrozen_params = 0\n if trainable_modules is not None:\n for name, module in model.named_modules():\n for tm in tuple(trainable_modules):\n if tm == 'all':\n model.requires_grad_(is_enabled)\n unfrozen_params =len(list(model.parameters()))\n break\n \n if tm in name and 'lora' not in name:\n for m in module.parameters():\n m.requires_grad_(is_enabled)\n if is_enabled: unfrozen_params +=1\n\n if unfrozen_params > 0 and not already_printed_trainables:\n already_printed_trainables = True \n print(f\"{unfrozen_params} params have been unfrozen for training.\")\n\ndef sample_noise(latents, noise_strength, use_offset_noise=False):\n b ,c, f, *_ = latents.shape\n noise_latents = torch.randn_like(latents, device=latents.device)\n offset_noise = None\n\n if use_offset_noise:\n offset_noise = torch.randn(b, c, f, 1, 1, device=latents.device)\n noise_latents = noise_latents + noise_strength * offset_noise\n\n return noise_latents\n\ndef enforce_zero_terminal_snr(betas):\n \"\"\"\n Corrects noise in diffusion schedulers.\n From: Common Diffusion Noise Schedules and Sample Steps are Flawed\n https://arxiv.org/pdf/2305.08891.pdf\n \"\"\"\n # Convert betas to alphas_bar_sqrt\n alphas = 1 - betas\n alphas_bar = alphas.cumprod(0)\n alphas_bar_sqrt = alphas_bar.sqrt()\n\n # Store old values.\n alphas_bar_sqrt_0 = alphas_bar_sqrt[0].clone()\n alphas_bar_sqrt_T = alphas_bar_sqrt[-1].clone()\n\n # Shift so the last timestep is zero.\n alphas_bar_sqrt -= alphas_bar_sqrt_T\n\n # Scale so the first timestep is back to the old value.\n alphas_bar_sqrt *= alphas_bar_sqrt_0 / (\n alphas_bar_sqrt_0 - alphas_bar_sqrt_T\n )\n\n # Convert alphas_bar_sqrt to betas\n alphas_bar = alphas_bar_sqrt ** 2\n alphas = alphas_bar[1:] / alphas_bar[:-1]\n alphas = torch.cat([alphas_bar[0:1], alphas])\n betas = 1 - alphas\n\n return betas\n\ndef should_sample(global_step, validation_steps, validation_data):\n return (global_step % validation_steps == 0 or global_step == 5) \\\n and validation_data.sample_preview\n\ndef save_pipe(\n path, \n global_step,\n accelerator, \n unet, \n text_encoder, \n vae, \n output_dir,\n lora_manager: LoraHandler,\n unet_target_replace_module=None,\n text_target_replace_module=None,\n is_checkpoint=False,\n save_pretrained_model=True\n ):\n\n if is_checkpoint:\n save_path = os.path.join(output_dir, f\"checkpoint-{global_step}\")\n os.makedirs(save_path, exist_ok=True)\n else:\n save_path = output_dir\n\n # Save the dtypes so we can continue training at the same precision.\n u_dtype, t_dtype, v_dtype = unet.dtype, text_encoder.dtype, vae.dtype \n\n # Copy the model without creating a reference to it. This allows keeping the state of our lora training if enabled.\n unet_save = copy.deepcopy(unet.cpu())\n text_encoder_save = copy.deepcopy(text_encoder.cpu())\n\n unet_out = copy.deepcopy(accelerator.unwrap_model(unet_save, keep_fp32_wrapper=False))\n text_encoder_out = copy.deepcopy(accelerator.unwrap_model(text_encoder_save, keep_fp32_wrapper=False))\n\n pipeline = StableVideoDiffusionPipeline.from_pretrained(\n path, unet=unet_out).to(torch_dtype=torch.float32)\n \n if save_pretrained_model:\n pipeline.save_pretrained(save_path)\n\n if is_checkpoint:\n unet, text_encoder = accelerator.prepare(unet, text_encoder)\n models_to_cast_back = [(unet, u_dtype), (text_encoder, t_dtype), (vae, v_dtype)]\n [x[0].to(accelerator.device, dtype=x[1]) for x in models_to_cast_back]\n\n logger.info(f\"Saved model at {save_path} on step {global_step}\")\n \n del pipeline\n del unet_out\n del text_encoder_out\n torch.cuda.empty_cache()\n gc.collect()\n\n\ndef replace_prompt(prompt, token, wlist):\n for w in wlist:\n if w in prompt: return prompt.replace(w, token)\n return prompt \n\n\ndef prompt_image(image, processor, encoder):\n if type(image) == str:\n image = Image.open(image)\n image = processor(images=image, return_tensors=\"pt\")['pixel_values']\n \n image = image.to(encoder.device).to(encoder.dtype)\n inputs = encoder(image).pooler_output.to(encoder.dtype).unsqueeze(1)\n #inputs = encoder(image).last_hidden_state.to(encoder.dtype)\n return inputs\n \ndef finetune_unet(pipeline, batch, use_offset_noise,\n rescale_schedule, offset_noise_strength, unet, motion_mask, \n P_mean=0.7, P_std=1.6, noise_aug_strength=0.02):\n pipeline.vae.eval()\n pipeline.image_encoder.eval()\n vae = pipeline.vae\n device = vae.device\n # Convert videos to latent space\n pixel_values = batch[\"pixel_values\"]\n bsz, num_frames = pixel_values.shape[:2]\n frames = rearrange(pixel_values, 'b f c h w-> (b f) c h w')\n latents = vae.encode(frames).latent_dist.mode()\n latents = rearrange(latents, '(b f) c h w-> b f c h w', b=bsz)\n latents = latents * vae.config.scaling_factor\n if motion_mask:\n mask = batch[\"mask\"]\n mask = mask.div(255).to(latents.device)\n h, w = latents.shape[-2:]\n mask = T.Resize((h, w), antialias=False)(mask)\n mask[mask<0.5] = 0\n mask[mask>=0.5] = 1\n mask = rearrange(mask, 'b h w -> b 1 1 h w')\n freeze = repeat(latents[:,0], 'b c h w -> b f c h w', f=num_frames)\n latents = freeze * (1-mask) + latents * mask\n\n # enocde image latent\n image = pixel_values[:,0]\n image = image + noise_aug_strength * torch.randn_like(image)\n image_latents = vae.encode(image).latent_dist.mode()\n image_latents = repeat(image_latents, 'b c h w->b f c h w',f=num_frames)\n\n # vae image to clip image\n images = _resize_with_antialiasing(pixel_values[:,0], (224, 224))\n images = (images + 1.0) / 2.0 # [-1, 1] -> [0, 1]\n images = pipeline.feature_extractor(\n images=images,\n do_normalize=True,\n do_center_crop=False,\n do_resize=False,\n do_rescale=False,\n return_tensors=\"pt\",\n ).pixel_values \n image_embeddings = pipeline._encode_image(images, device, 1, False)\n negative_image_embeddings = torch.zeros_like(image_embeddings)\n\n # Add noise to the latents according to the noise magnitude at each timestep\n # (this is the forward diffusion process) #[bsz, f, c, h , w]\n rnd_normal = torch.randn([bsz, 1, 1, 1, 1], device=device)\n sigma = (rnd_normal * P_std + P_mean).exp()\n c_skip = 1 / (sigma**2 + 1)\n c_out = -sigma / (sigma**2 + 1) ** 0.5\n c_in = 1 / (sigma**2 + 1) ** 0.5\n c_noise = sigma.log() / 4\n loss_weight = (sigma ** 2 + 1) / sigma ** 2\n\n noisy_latents = latents + torch.randn_like(latents) * sigma\n input_latents = c_in * noisy_latents\n input_latents = torch.cat([input_latents, image_latents], dim=2)\n if motion_mask:\n mask = repeat(mask, 'b 1 1 h w -> b f 1 h w', f=num_frames)\n input_latents = torch.cat([mask, input_latents], dim=2)\n\n motion_bucket_id = 127\n fps = 7\n added_time_ids = pipeline._get_add_time_ids(fps, motion_bucket_id, \n noise_aug_strength, image_embeddings.dtype, bsz, 1, False)\n added_time_ids = added_time_ids.to(device)\n\n losses = []\n for i in range(2):\n encoder_hidden_states = (\n negative_image_embeddings if i==0 else image_embeddings\n )\n model_pred = unet(input_latents, c_noise.reshape([bsz]), encoder_hidden_states=encoder_hidden_states, \n added_time_ids=added_time_ids,).sample\n predict_x0 = c_out * model_pred + c_skip * noisy_latents \n loss = ((predict_x0 - latents)**2 * loss_weight).mean()\n '''\n if motion_mask:\n loss += F.mse_loss(predict_x0*(1-mask), freeze*(1-mask))\n ''' \n losses.append(loss)\n loss = losses[0] if len(losses) == 1 else losses[0] + losses[1] \n return loss\n\n\ndef main(\n pretrained_model_path: str,\n output_dir: str,\n train_data: Dict,\n validation_data: Dict,\n extra_train_data: list = [],\n dataset_types: Tuple[str] = ('json'),\n shuffle: bool = True,\n validation_steps: int = 100,\n trainable_modules: Tuple[str] = None, # Eg: (\"attn1\", \"attn2\")\n trainable_text_modules: Tuple[str] = None, # Eg: (\"all\"), this also applies to trainable_modules\n extra_unet_params = None,\n extra_text_encoder_params = None,\n train_batch_size: int = 1,\n max_train_steps: int = 500,\n learning_rate: float = 5e-5,\n scale_lr: bool = False,\n lr_scheduler: str = \"constant\",\n lr_warmup_steps: int = 0,\n adam_beta1: float = 0.9,\n adam_beta2: float = 0.999,\n adam_weight_decay: float = 1e-2,\n adam_epsilon: float = 1e-08,\n max_grad_norm: float = 1.0,\n gradient_accumulation_steps: int = 1,\n gradient_checkpointing: bool = False,\n text_encoder_gradient_checkpointing: bool = False,\n checkpointing_steps: int = 500,\n resume_from_checkpoint: Optional[str] = None,\n resume_step: Optional[int] = None,\n mixed_precision: Optional[str] = \"fp16\",\n use_8bit_adam: bool = False,\n enable_xformers_memory_efficient_attention: bool = True,\n enable_torch_2_attn: bool = False,\n seed: Optional[int] = None,\n train_text_encoder: bool = False,\n use_offset_noise: bool = False,\n rescale_schedule: bool = False,\n offset_noise_strength: float = 0.1,\n extend_dataset: bool = False,\n cache_latents: bool = False,\n cached_latent_dir = None,"},"next_line":{"kind":"string","value":" lora_version: LORA_VERSIONS = LORA_VERSIONS[0],"},"gold_snippet_index":{"kind":"number","value":9,"string":"9"},"created_at":{"kind":"string","value":"2023-12-07 08:26:29+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5967,"cells":{"repo_name":{"kind":"string","value":"rehg-lab/RAVE"},"file_path":{"kind":"string","value":"annotator/oneformer/detectron2/modeling/meta_arch/retinanet.py"},"context":{"kind":"list like","value":[{"identifier":"configurable","path":"annotator/oneformer/detectron2/config/config.py","snippet":"def configurable(init_func=None, *, from_config=None):\r\n \"\"\"\r\n Decorate a function or a class's __init__ method so that it can be called\r\n with a :class:`CfgNode` object using a :func:`from_config` function that translates\r\n :class:`CfgNode` to arguments.\r\n\r\n Examples:\r\n ::\r\n # Usage 1: Decorator on __init__:\r\n class A:\r\n @configurable\r\n def __init__(self, a, b=2, c=3):\r\n pass\r\n\r\n @classmethod\r\n def from_config(cls, cfg): # 'cfg' must be the first argument\r\n # Returns kwargs to be passed to __init__\r\n return {\"a\": cfg.A, \"b\": cfg.B}\r\n\r\n a1 = A(a=1, b=2) # regular construction\r\n a2 = A(cfg) # construct with a cfg\r\n a3 = A(cfg, b=3, c=4) # construct with extra overwrite\r\n\r\n # Usage 2: Decorator on any function. Needs an extra from_config argument:\r\n @configurable(from_config=lambda cfg: {\"a: cfg.A, \"b\": cfg.B})\r\n def a_func(a, b=2, c=3):\r\n pass\r\n\r\n a1 = a_func(a=1, b=2) # regular call\r\n a2 = a_func(cfg) # call with a cfg\r\n a3 = a_func(cfg, b=3, c=4) # call with extra overwrite\r\n\r\n Args:\r\n init_func (callable): a class's ``__init__`` method in usage 1. The\r\n class must have a ``from_config`` classmethod which takes `cfg` as\r\n the first argument.\r\n from_config (callable): the from_config function in usage 2. It must take `cfg`\r\n as its first argument.\r\n \"\"\"\r\n\r\n if init_func is not None:\r\n assert (\r\n inspect.isfunction(init_func)\r\n and from_config is None\r\n and init_func.__name__ == \"__init__\"\r\n ), \"Incorrect use of @configurable. Check API documentation for examples.\"\r\n\r\n @functools.wraps(init_func)\r\n def wrapped(self, *args, **kwargs):\r\n try:\r\n from_config_func = type(self).from_config\r\n except AttributeError as e:\r\n raise AttributeError(\r\n \"Class with @configurable must have a 'from_config' classmethod.\"\r\n ) from e\r\n if not inspect.ismethod(from_config_func):\r\n raise TypeError(\"Class with @configurable must have a 'from_config' classmethod.\")\r\n\r\n if _called_with_cfg(*args, **kwargs):\r\n explicit_args = _get_args_from_config(from_config_func, *args, **kwargs)\r\n init_func(self, **explicit_args)\r\n else:\r\n init_func(self, *args, **kwargs)\r\n\r\n return wrapped\r\n\r\n else:\r\n if from_config is None:\r\n return configurable # @configurable() is made equivalent to @configurable\r\n assert inspect.isfunction(\r\n from_config\r\n ), \"from_config argument of configurable must be a function!\"\r\n\r\n def wrapper(orig_func):\r\n @functools.wraps(orig_func)\r\n def wrapped(*args, **kwargs):\r\n if _called_with_cfg(*args, **kwargs):\r\n explicit_args = _get_args_from_config(from_config, *args, **kwargs)\r\n return orig_func(**explicit_args)\r\n else:\r\n return orig_func(*args, **kwargs)\r\n\r\n wrapped.from_config = from_config\r\n return wrapped\r\n\r\n return wrapper\r"},{"identifier":"get_norm","path":"annotator/oneformer/detectron2/layers/batch_norm.py","snippet":"def get_norm(norm, out_channels):\r\n \"\"\"\r\n Args:\r\n norm (str or callable): either one of BN, SyncBN, FrozenBN, GN;\r\n or a callable that takes a channel number and returns\r\n the normalization layer as a nn.Module.\r\n\r\n Returns:\r\n nn.Module or None: the normalization layer\r\n \"\"\"\r\n if norm is None:\r\n return None\r\n if isinstance(norm, str):\r\n if len(norm) == 0:\r\n return None\r\n norm = {\r\n \"BN\": BatchNorm2d,\r\n # Fixed in https://github.com/pytorch/pytorch/pull/36382\r\n \"SyncBN\": NaiveSyncBatchNorm if env.TORCH_VERSION <= (1, 5) else nn.SyncBatchNorm,\r\n \"FrozenBN\": FrozenBatchNorm2d,\r\n \"GN\": lambda channels: nn.GroupNorm(32, channels),\r\n # for debugging:\r\n \"nnSyncBN\": nn.SyncBatchNorm,\r\n \"naiveSyncBN\": NaiveSyncBatchNorm,\r\n # expose stats_mode N as an option to caller, required for zero-len inputs\r\n \"naiveSyncBN_N\": lambda channels: NaiveSyncBatchNorm(channels, stats_mode=\"N\"),\r\n \"LN\": lambda channels: LayerNorm(channels),\r\n }[norm]\r\n return norm(out_channels)\r"},{"identifier":"CycleBatchNormList","path":"annotator/oneformer/detectron2/layers/batch_norm.py","snippet":"class CycleBatchNormList(nn.ModuleList):\r\n \"\"\"\r\n Implement domain-specific BatchNorm by cycling.\r\n\r\n When a BatchNorm layer is used for multiple input domains or input\r\n features, it might need to maintain a separate test-time statistics\r\n for each domain. See Sec 5.2 in :paper:`rethinking-batchnorm`.\r\n\r\n This module implements it by using N separate BN layers\r\n and it cycles through them every time a forward() is called.\r\n\r\n NOTE: The caller of this module MUST guarantee to always call\r\n this module by multiple of N times. Otherwise its test-time statistics\r\n will be incorrect.\r\n \"\"\"\r\n\r\n def __init__(self, length: int, bn_class=nn.BatchNorm2d, **kwargs):\r\n \"\"\"\r\n Args:\r\n length: number of BatchNorm layers to cycle.\r\n bn_class: the BatchNorm class to use\r\n kwargs: arguments of the BatchNorm class, such as num_features.\r\n \"\"\"\r\n self._affine = kwargs.pop(\"affine\", True)\r\n super().__init__([bn_class(**kwargs, affine=False) for k in range(length)])\r\n if self._affine:\r\n # shared affine, domain-specific BN\r\n channels = self[0].num_features\r\n self.weight = nn.Parameter(torch.ones(channels))\r\n self.bias = nn.Parameter(torch.zeros(channels))\r\n self._pos = 0\r\n\r\n def forward(self, x):\r\n ret = self[self._pos](x)\r\n self._pos = (self._pos + 1) % len(self)\r\n\r\n if self._affine:\r\n w = self.weight.reshape(1, -1, 1, 1)\r\n b = self.bias.reshape(1, -1, 1, 1)\r\n return ret * w + b\r\n else:\r\n return ret\r\n\r\n def extra_repr(self):\r\n return f\"affine={self._affine}\"\r"},{"identifier":"batched_nms","path":"annotator/oneformer/detectron2/layers/nms.py","snippet":"def batched_nms(\r\n boxes: torch.Tensor, scores: torch.Tensor, idxs: torch.Tensor, iou_threshold: float\r\n):\r\n \"\"\"\r\n Same as torchvision.ops.boxes.batched_nms, but with float().\r\n \"\"\"\r\n assert boxes.shape[-1] == 4\r\n # Note: Torchvision already has a strategy (https://github.com/pytorch/vision/issues/1311)\r\n # to decide whether to use coordinate trick or for loop to implement batched_nms. So we\r\n # just call it directly.\r\n # Fp16 does not have enough range for batched NMS, so adding float().\r\n return box_ops.batched_nms(boxes.float(), scores, idxs, iou_threshold)\r"},{"identifier":"ShapeSpec","path":"annotator/oneformer/detectron2/layers/shape_spec.py","snippet":"class ShapeSpec:\r\n \"\"\"\r\n A simple structure that contains basic shape specification about a tensor.\r\n It is often used as the auxiliary inputs/outputs of models,\r\n to complement the lack of shape inference ability among pytorch modules.\r\n \"\"\"\r\n\r\n channels: Optional[int] = None\r\n height: Optional[int] = None\r\n width: Optional[int] = None\r\n stride: Optional[int] = None\r"},{"identifier":"cat","path":"annotator/oneformer/detectron2/layers/wrappers.py","snippet":"def cat(tensors: List[torch.Tensor], dim: int = 0):\r\n \"\"\"\r\n Efficient version of torch.cat that avoids a copy if there is only a single element in a list\r\n \"\"\"\r\n assert isinstance(tensors, (list, tuple))\r\n if len(tensors) == 1:\r\n return tensors[0]\r\n return torch.cat(tensors, dim)\r"},{"identifier":"Boxes","path":"annotator/oneformer/detectron2/structures/boxes.py","snippet":"class Boxes:\r\n \"\"\"\r\n This structure stores a list of boxes as a Nx4 torch.Tensor.\r\n It supports some common methods about boxes\r\n (`area`, `clip`, `nonempty`, etc),\r\n and also behaves like a Tensor\r\n (support indexing, `to(device)`, `.device`, and iteration over all boxes)\r\n\r\n Attributes:\r\n tensor (torch.Tensor): float matrix of Nx4. Each row is (x1, y1, x2, y2).\r\n \"\"\"\r\n\r\n def __init__(self, tensor: torch.Tensor):\r\n \"\"\"\r\n Args:\r\n tensor (Tensor[float]): a Nx4 matrix. Each row is (x1, y1, x2, y2).\r\n \"\"\"\r\n if not isinstance(tensor, torch.Tensor):\r\n tensor = torch.as_tensor(tensor, dtype=torch.float32, device=torch.device(\"cpu\"))\r\n else:\r\n tensor = tensor.to(torch.float32)\r\n if tensor.numel() == 0:\r\n # Use reshape, so we don't end up creating a new tensor that does not depend on\r\n # the inputs (and consequently confuses jit)\r\n tensor = tensor.reshape((-1, 4)).to(dtype=torch.float32)\r\n assert tensor.dim() == 2 and tensor.size(-1) == 4, tensor.size()\r\n\r\n self.tensor = tensor\r\n\r\n def clone(self) -> \"Boxes\":\r\n \"\"\"\r\n Clone the Boxes.\r\n\r\n Returns:\r\n Boxes\r\n \"\"\"\r\n return Boxes(self.tensor.clone())\r\n\r\n def to(self, device: torch.device):\r\n # Boxes are assumed float32 and does not support to(dtype)\r\n return Boxes(self.tensor.to(device=device))\r\n\r\n def area(self) -> torch.Tensor:\r\n \"\"\"\r\n Computes the area of all the boxes.\r\n\r\n Returns:\r\n torch.Tensor: a vector with areas of each box.\r\n \"\"\"\r\n box = self.tensor\r\n area = (box[:, 2] - box[:, 0]) * (box[:, 3] - box[:, 1])\r\n return area\r\n\r\n def clip(self, box_size: Tuple[int, int]) -> None:\r\n \"\"\"\r\n Clip (in place) the boxes by limiting x coordinates to the range [0, width]\r\n and y coordinates to the range [0, height].\r\n\r\n Args:\r\n box_size (height, width): The clipping box's size.\r\n \"\"\"\r\n assert torch.isfinite(self.tensor).all(), \"Box tensor contains infinite or NaN!\"\r\n h, w = box_size\r\n x1 = self.tensor[:, 0].clamp(min=0, max=w)\r\n y1 = self.tensor[:, 1].clamp(min=0, max=h)\r\n x2 = self.tensor[:, 2].clamp(min=0, max=w)\r\n y2 = self.tensor[:, 3].clamp(min=0, max=h)\r\n self.tensor = torch.stack((x1, y1, x2, y2), dim=-1)\r\n\r\n def nonempty(self, threshold: float = 0.0) -> torch.Tensor:\r\n \"\"\"\r\n Find boxes that are non-empty.\r\n A box is considered empty, if either of its side is no larger than threshold.\r\n\r\n Returns:\r\n Tensor:\r\n a binary vector which represents whether each box is empty\r\n (False) or non-empty (True).\r\n \"\"\"\r\n box = self.tensor\r\n widths = box[:, 2] - box[:, 0]\r\n heights = box[:, 3] - box[:, 1]\r\n keep = (widths > threshold) & (heights > threshold)\r\n return keep\r\n\r\n def __getitem__(self, item) -> \"Boxes\":\r\n \"\"\"\r\n Args:\r\n item: int, slice, or a BoolTensor\r\n\r\n Returns:\r\n Boxes: Create a new :class:`Boxes` by indexing.\r\n\r\n The following usage are allowed:\r\n\r\n 1. `new_boxes = boxes[3]`: return a `Boxes` which contains only one box.\r\n 2. `new_boxes = boxes[2:10]`: return a slice of boxes.\r\n 3. `new_boxes = boxes[vector]`, where vector is a torch.BoolTensor\r\n with `length = len(boxes)`. Nonzero elements in the vector will be selected.\r\n\r\n Note that the returned Boxes might share storage with this Boxes,\r\n subject to Pytorch's indexing semantics.\r\n \"\"\"\r\n if isinstance(item, int):\r\n return Boxes(self.tensor[item].view(1, -1))\r\n b = self.tensor[item]\r\n assert b.dim() == 2, \"Indexing on Boxes with {} failed to return a matrix!\".format(item)\r\n return Boxes(b)\r\n\r\n def __len__(self) -> int:\r\n return self.tensor.shape[0]\r\n\r\n def __repr__(self) -> str:\r\n return \"Boxes(\" + str(self.tensor) + \")\"\r\n\r\n def inside_box(self, box_size: Tuple[int, int], boundary_threshold: int = 0) -> torch.Tensor:\r\n \"\"\"\r\n Args:\r\n box_size (height, width): Size of the reference box.\r\n boundary_threshold (int): Boxes that extend beyond the reference box\r\n boundary by more than boundary_threshold are considered \"outside\".\r\n\r\n Returns:\r\n a binary vector, indicating whether each box is inside the reference box.\r\n \"\"\"\r\n height, width = box_size\r\n inds_inside = (\r\n (self.tensor[..., 0] >= -boundary_threshold)\r\n & (self.tensor[..., 1] >= -boundary_threshold)\r\n & (self.tensor[..., 2] < width + boundary_threshold)\r\n & (self.tensor[..., 3] < height + boundary_threshold)\r\n )\r\n return inds_inside\r\n\r\n def get_centers(self) -> torch.Tensor:\r\n \"\"\"\r\n Returns:\r\n The box centers in a Nx2 array of (x, y).\r\n \"\"\"\r\n return (self.tensor[:, :2] + self.tensor[:, 2:]) / 2\r\n\r\n def scale(self, scale_x: float, scale_y: float) -> None:\r\n \"\"\"\r\n Scale the box with horizontal and vertical scaling factors\r\n \"\"\"\r\n self.tensor[:, 0::2] *= scale_x\r\n self.tensor[:, 1::2] *= scale_y\r\n\r\n @classmethod\r\n def cat(cls, boxes_list: List[\"Boxes\"]) -> \"Boxes\":\r\n \"\"\"\r\n Concatenates a list of Boxes into a single Boxes\r\n\r\n Arguments:\r\n boxes_list (list[Boxes])\r\n\r\n Returns:\r\n Boxes: the concatenated Boxes\r\n \"\"\"\r\n assert isinstance(boxes_list, (list, tuple))\r\n if len(boxes_list) == 0:\r\n return cls(torch.empty(0))\r\n assert all([isinstance(box, Boxes) for box in boxes_list])\r\n\r\n # use torch.cat (v.s. layers.cat) so the returned boxes never share storage with input\r\n cat_boxes = cls(torch.cat([b.tensor for b in boxes_list], dim=0))\r\n return cat_boxes\r\n\r\n @property\r\n def device(self) -> device:\r\n return self.tensor.device\r\n\r\n # type \"Iterator[torch.Tensor]\", yield, and iter() not supported by torchscript\r\n # https://github.com/pytorch/pytorch/issues/18627\r\n @torch.jit.unused\r\n def __iter__(self):\r\n \"\"\"\r\n Yield a box as a Tensor of shape (4,) at a time.\r\n \"\"\"\r\n yield from self.tensor\r"},{"identifier":"pairwise_iou","path":"annotator/oneformer/detectron2/structures/boxes.py","snippet":"def pairwise_iou(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:\r\n \"\"\"\r\n Given two lists of boxes of size N and M, compute the IoU\r\n (intersection over union) between **all** N x M pairs of boxes.\r\n The box order must be (xmin, ymin, xmax, ymax).\r\n\r\n Args:\r\n boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.\r\n\r\n Returns:\r\n Tensor: IoU, sized [N,M].\r\n \"\"\"\r\n area1 = boxes1.area() # [N]\r\n area2 = boxes2.area() # [M]\r\n inter = pairwise_intersection(boxes1, boxes2)\r\n\r\n # handle empty boxes\r\n iou = torch.where(\r\n inter > 0,\r\n inter / (area1[:, None] + area2 - inter),\r\n torch.zeros(1, dtype=inter.dtype, device=inter.device),\r\n )\r\n return iou\r"},{"identifier":"ImageList","path":"annotator/oneformer/detectron2/structures/image_list.py","snippet":"class ImageList(object):\r\n \"\"\"\r\n Structure that holds a list of images (of possibly\r\n varying sizes) as a single tensor.\r\n This works by padding the images to the same size.\r\n The original sizes of each image is stored in `image_sizes`.\r\n\r\n Attributes:\r\n image_sizes (list[tuple[int, int]]): each tuple is (h, w).\r\n During tracing, it becomes list[Tensor] instead.\r\n \"\"\"\r\n\r\n def __init__(self, tensor: torch.Tensor, image_sizes: List[Tuple[int, int]]):\r\n \"\"\"\r\n Arguments:\r\n tensor (Tensor): of shape (N, H, W) or (N, C_1, ..., C_K, H, W) where K >= 1\r\n image_sizes (list[tuple[int, int]]): Each tuple is (h, w). It can\r\n be smaller than (H, W) due to padding.\r\n \"\"\"\r\n self.tensor = tensor\r\n self.image_sizes = image_sizes\r\n\r\n def __len__(self) -> int:\r\n return len(self.image_sizes)\r\n\r\n def __getitem__(self, idx) -> torch.Tensor:\r\n \"\"\"\r\n Access the individual image in its original size.\r\n\r\n Args:\r\n idx: int or slice\r\n\r\n Returns:\r\n Tensor: an image of shape (H, W) or (C_1, ..., C_K, H, W) where K >= 1\r\n \"\"\"\r\n size = self.image_sizes[idx]\r\n return self.tensor[idx, ..., : size[0], : size[1]]\r\n\r\n @torch.jit.unused\r\n def to(self, *args: Any, **kwargs: Any) -> \"ImageList\":\r\n cast_tensor = self.tensor.to(*args, **kwargs)\r\n return ImageList(cast_tensor, self.image_sizes)\r\n\r\n @property\r\n def device(self) -> device:\r\n return self.tensor.device\r\n\r\n @staticmethod\r\n def from_tensors(\r\n tensors: List[torch.Tensor],\r\n size_divisibility: int = 0,\r\n pad_value: float = 0.0,\r\n padding_constraints: Optional[Dict[str, int]] = None,\r\n ) -> \"ImageList\":\r\n \"\"\"\r\n Args:\r\n tensors: a tuple or list of `torch.Tensor`, each of shape (Hi, Wi) or\r\n (C_1, ..., C_K, Hi, Wi) where K >= 1. The Tensors will be padded\r\n to the same shape with `pad_value`.\r\n size_divisibility (int): If `size_divisibility > 0`, add padding to ensure\r\n the common height and width is divisible by `size_divisibility`.\r\n This depends on the model and many models need a divisibility of 32.\r\n pad_value (float): value to pad.\r\n padding_constraints (optional[Dict]): If given, it would follow the format as\r\n {\"size_divisibility\": int, \"square_size\": int}, where `size_divisibility` will\r\n overwrite the above one if presented and `square_size` indicates the\r\n square padding size if `square_size` > 0.\r\n Returns:\r\n an `ImageList`.\r\n \"\"\"\r\n assert len(tensors) > 0\r\n assert isinstance(tensors, (tuple, list))\r\n for t in tensors:\r\n assert isinstance(t, torch.Tensor), type(t)\r\n assert t.shape[:-2] == tensors[0].shape[:-2], t.shape\r\n\r\n image_sizes = [(im.shape[-2], im.shape[-1]) for im in tensors]\r\n image_sizes_tensor = [shapes_to_tensor(x) for x in image_sizes]\r\n max_size = torch.stack(image_sizes_tensor).max(0).values\r\n\r\n if padding_constraints is not None:\r\n square_size = padding_constraints.get(\"square_size\", 0)\r\n if square_size > 0:\r\n # pad to square.\r\n max_size[0] = max_size[1] = square_size\r\n if \"size_divisibility\" in padding_constraints:\r\n size_divisibility = padding_constraints[\"size_divisibility\"]\r\n if size_divisibility > 1:\r\n stride = size_divisibility\r\n # the last two dims are H,W, both subject to divisibility requirement\r\n max_size = (max_size + (stride - 1)).div(stride, rounding_mode=\"floor\") * stride\r\n\r\n # handle weirdness of scripting and tracing ...\r\n if torch.jit.is_scripting():\r\n max_size: List[int] = max_size.to(dtype=torch.long).tolist()\r\n else:\r\n if torch.jit.is_tracing():\r\n image_sizes = image_sizes_tensor\r\n\r\n if len(tensors) == 1:\r\n # This seems slightly (2%) faster.\r\n # TODO: check whether it's faster for multiple images as well\r\n image_size = image_sizes[0]\r\n padding_size = [0, max_size[-1] - image_size[1], 0, max_size[-2] - image_size[0]]\r\n batched_imgs = F.pad(tensors[0], padding_size, value=pad_value).unsqueeze_(0)\r\n else:\r\n # max_size can be a tensor in tracing mode, therefore convert to list\r\n batch_shape = [len(tensors)] + list(tensors[0].shape[:-2]) + list(max_size)\r\n device = (\r\n None if torch.jit.is_scripting() else (\"cpu\" if torch.jit.is_tracing() else None)\r\n )\r\n batched_imgs = tensors[0].new_full(batch_shape, pad_value, device=device)\r\n batched_imgs = move_device_like(batched_imgs, tensors[0])\r\n for i, img in enumerate(tensors):\r\n # Use `batched_imgs` directly instead of `img, pad_img = zip(tensors, batched_imgs)`\r\n # Tracing mode cannot capture `copy_()` of temporary locals\r\n batched_imgs[i, ..., : img.shape[-2], : img.shape[-1]].copy_(img)\r\n\r\n return ImageList(batched_imgs.contiguous(), image_sizes)\r"},{"identifier":"Instances","path":"annotator/oneformer/detectron2/structures/instances.py","snippet":"class Instances:\r\n \"\"\"\r\n This class represents a list of instances in an image.\r\n It stores the attributes of instances (e.g., boxes, masks, labels, scores) as \"fields\".\r\n All fields must have the same ``__len__`` which is the number of instances.\r\n\r\n All other (non-field) attributes of this class are considered private:\r\n they must start with '_' and are not modifiable by a user.\r\n\r\n Some basic usage:\r\n\r\n 1. Set/get/check a field:\r\n\r\n .. code-block:: python\r\n\r\n instances.gt_boxes = Boxes(...)\r\n print(instances.pred_masks) # a tensor of shape (N, H, W)\r\n print('gt_masks' in instances)\r\n\r\n 2. ``len(instances)`` returns the number of instances\r\n 3. Indexing: ``instances[indices]`` will apply the indexing on all the fields\r\n and returns a new :class:`Instances`.\r\n Typically, ``indices`` is a integer vector of indices,\r\n or a binary mask of length ``num_instances``\r\n\r\n .. code-block:: python\r\n\r\n category_3_detections = instances[instances.pred_classes == 3]\r\n confident_detections = instances[instances.scores > 0.9]\r\n \"\"\"\r\n\r\n def __init__(self, image_size: Tuple[int, int], **kwargs: Any):\r\n \"\"\"\r\n Args:\r\n image_size (height, width): the spatial size of the image.\r\n kwargs: fields to add to this `Instances`.\r\n \"\"\"\r\n self._image_size = image_size\r\n self._fields: Dict[str, Any] = {}\r\n for k, v in kwargs.items():\r\n self.set(k, v)\r\n\r\n @property\r\n def image_size(self) -> Tuple[int, int]:\r\n \"\"\"\r\n Returns:\r\n tuple: height, width\r\n \"\"\"\r\n return self._image_size\r\n\r\n def __setattr__(self, name: str, val: Any) -> None:\r\n if name.startswith(\"_\"):\r\n super().__setattr__(name, val)\r\n else:\r\n self.set(name, val)\r\n\r\n def __getattr__(self, name: str) -> Any:\r\n if name == \"_fields\" or name not in self._fields:\r\n raise AttributeError(\"Cannot find field '{}' in the given Instances!\".format(name))\r\n return self._fields[name]\r\n\r\n def set(self, name: str, value: Any) -> None:\r\n \"\"\"\r\n Set the field named `name` to `value`.\r\n The length of `value` must be the number of instances,\r\n and must agree with other existing fields in this object.\r\n \"\"\"\r\n with warnings.catch_warnings(record=True):\r\n data_len = len(value)\r\n if len(self._fields):\r\n assert (\r\n len(self) == data_len\r\n ), \"Adding a field of length {} to a Instances of length {}\".format(data_len, len(self))\r\n self._fields[name] = value\r\n\r\n def has(self, name: str) -> bool:\r\n \"\"\"\r\n Returns:\r\n bool: whether the field called `name` exists.\r\n \"\"\"\r\n return name in self._fields\r\n\r\n def remove(self, name: str) -> None:\r\n \"\"\"\r\n Remove the field called `name`.\r\n \"\"\"\r\n del self._fields[name]\r\n\r\n def get(self, name: str) -> Any:\r\n \"\"\"\r\n Returns the field called `name`.\r\n \"\"\"\r\n return self._fields[name]\r\n\r\n def get_fields(self) -> Dict[str, Any]:\r\n \"\"\"\r\n Returns:\r\n dict: a dict which maps names (str) to data of the fields\r\n\r\n Modifying the returned dict will modify this instance.\r\n \"\"\"\r\n return self._fields\r\n\r\n # Tensor-like methods\r\n def to(self, *args: Any, **kwargs: Any) -> \"Instances\":\r\n \"\"\"\r\n Returns:\r\n Instances: all fields are called with a `to(device)`, if the field has this method.\r\n \"\"\"\r\n ret = Instances(self._image_size)\r\n for k, v in self._fields.items():\r\n if hasattr(v, \"to\"):\r\n v = v.to(*args, **kwargs)\r\n ret.set(k, v)\r\n return ret\r\n\r\n def __getitem__(self, item: Union[int, slice, torch.BoolTensor]) -> \"Instances\":\r\n \"\"\"\r\n Args:\r\n item: an index-like object and will be used to index all the fields.\r\n\r\n Returns:\r\n If `item` is a string, return the data in the corresponding field.\r\n Otherwise, returns an `Instances` where all fields are indexed by `item`.\r\n \"\"\"\r\n if type(item) == int:\r\n if item >= len(self) or item < -len(self):\r\n raise IndexError(\"Instances index out of range!\")\r\n else:\r\n item = slice(item, None, len(self))\r\n\r\n ret = Instances(self._image_size)\r\n for k, v in self._fields.items():\r\n ret.set(k, v[item])\r\n return ret\r\n\r\n def __len__(self) -> int:\r\n for v in self._fields.values():\r\n # use __len__ because len() has to be int and is not friendly to tracing\r\n return v.__len__()\r\n raise NotImplementedError(\"Empty Instances does not support __len__!\")\r\n\r\n def __iter__(self):\r\n raise NotImplementedError(\"`Instances` object is not iterable!\")\r\n\r\n @staticmethod\r\n def cat(instance_lists: List[\"Instances\"]) -> \"Instances\":\r\n \"\"\"\r\n Args:\r\n instance_lists (list[Instances])\r\n\r\n Returns:\r\n Instances\r\n \"\"\"\r\n assert all(isinstance(i, Instances) for i in instance_lists)\r\n assert len(instance_lists) > 0\r\n if len(instance_lists) == 1:\r\n return instance_lists[0]\r\n\r\n image_size = instance_lists[0].image_size\r\n if not isinstance(image_size, torch.Tensor): # could be a tensor in tracing\r\n for i in instance_lists[1:]:\r\n assert i.image_size == image_size\r\n ret = Instances(image_size)\r\n for k in instance_lists[0]._fields.keys():\r\n values = [i.get(k) for i in instance_lists]\r\n v0 = values[0]\r\n if isinstance(v0, torch.Tensor):\r\n values = torch.cat(values, dim=0)\r\n elif isinstance(v0, list):\r\n values = list(itertools.chain(*values))\r\n elif hasattr(type(v0), \"cat\"):\r\n values = type(v0).cat(values)\r\n else:\r\n raise ValueError(\"Unsupported type {} for concatenation\".format(type(v0)))\r\n ret.set(k, values)\r\n return ret\r\n\r\n def __str__(self) -> str:\r\n s = self.__class__.__name__ + \"(\"\r\n s += \"num_instances={}, \".format(len(self))\r\n s += \"image_height={}, \".format(self._image_size[0])\r\n s += \"image_width={}, \".format(self._image_size[1])\r\n s += \"fields=[{}])\".format(\", \".join((f\"{k}: {v}\" for k, v in self._fields.items())))\r\n return s\r\n\r\n __repr__ = __str__\r"},{"identifier":"get_event_storage","path":"annotator/oneformer/detectron2/utils/events.py","snippet":"def get_event_storage():\r\n \"\"\"\r\n Returns:\r\n The :class:`EventStorage` object that's currently being used.\r\n Throws an error if no :class:`EventStorage` is currently enabled.\r\n \"\"\"\r\n assert len(\r\n _CURRENT_STORAGE_STACK\r\n ), \"get_event_storage() has to be called inside a 'with EventStorage(...)' context!\"\r\n return _CURRENT_STORAGE_STACK[-1]\r"},{"identifier":"build_anchor_generator","path":"annotator/oneformer/detectron2/modeling/anchor_generator.py","snippet":"def build_anchor_generator(cfg, input_shape):\r\n \"\"\"\r\n Built an anchor generator from `cfg.MODEL.ANCHOR_GENERATOR.NAME`.\r\n \"\"\"\r\n anchor_generator = cfg.MODEL.ANCHOR_GENERATOR.NAME\r\n return ANCHOR_GENERATOR_REGISTRY.get(anchor_generator)(cfg, input_shape)\r"},{"identifier":"build_backbone","path":"annotator/oneformer/detectron2/modeling/backbone/build.py","snippet":"def build_backbone(cfg, input_shape=None):\r\n \"\"\"\r\n Build a backbone from `cfg.MODEL.BACKBONE.NAME`.\r\n\r\n Returns:\r\n an instance of :class:`Backbone`\r\n \"\"\"\r\n if input_shape is None:\r\n input_shape = ShapeSpec(channels=len(cfg.MODEL.PIXEL_MEAN))\r\n\r\n backbone_name = cfg.MODEL.BACKBONE.NAME\r\n backbone = BACKBONE_REGISTRY.get(backbone_name)(cfg, input_shape)\r\n assert isinstance(backbone, Backbone)\r\n return backbone\r"},{"identifier":"Backbone","path":"annotator/oneformer/detectron2/modeling/backbone/backbone.py","snippet":"class Backbone(nn.Module, metaclass=ABCMeta):\r\n \"\"\"\r\n Abstract base class for network backbones.\r\n \"\"\"\r\n\r\n def __init__(self):\r\n \"\"\"\r\n The `__init__` method of any subclass can specify its own set of arguments.\r\n \"\"\"\r\n super().__init__()\r\n\r\n @abstractmethod\r\n def forward(self):\r\n \"\"\"\r\n Subclasses must override this method, but adhere to the same return type.\r\n\r\n Returns:\r\n dict[str->Tensor]: mapping from feature name (e.g., \"res2\") to tensor\r\n \"\"\"\r\n pass\r\n\r\n @property\r\n def size_divisibility(self) -> int:\r\n \"\"\"\r\n Some backbones require the input height and width to be divisible by a\r\n specific integer. This is typically true for encoder / decoder type networks\r\n with lateral connection (e.g., FPN) for which feature maps need to match\r\n dimension in the \"bottom up\" and \"top down\" paths. Set to 0 if no specific\r\n input size divisibility is required.\r\n \"\"\"\r\n return 0\r\n\r\n @property\r\n def padding_constraints(self) -> Dict[str, int]:\r\n \"\"\"\r\n This property is a generalization of size_divisibility. Some backbones and training\r\n recipes require specific padding constraints, such as enforcing divisibility by a specific\r\n integer (e.g., FPN) or padding to a square (e.g., ViTDet with large-scale jitter\r\n in :paper:vitdet). `padding_constraints` contains these optional items like:\r\n {\r\n \"size_divisibility\": int,\r\n \"square_size\": int,\r\n # Future options are possible\r\n }\r\n `size_divisibility` will read from here if presented and `square_size` indicates the\r\n square padding size if `square_size` > 0.\r\n\r\n TODO: use type of Dict[str, int] to avoid torchscipt issues. The type of padding_constraints\r\n could be generalized as TypedDict (Python 3.8+) to support more types in the future.\r\n \"\"\"\r\n return {}\r\n\r\n def output_shape(self):\r\n \"\"\"\r\n Returns:\r\n dict[str->ShapeSpec]\r\n \"\"\"\r\n # this is a backward-compatible default\r\n return {\r\n name: ShapeSpec(\r\n channels=self._out_feature_channels[name], stride=self._out_feature_strides[name]\r\n )\r\n for name in self._out_features\r\n }\r"},{"identifier":"Box2BoxTransform","path":"annotator/oneformer/detectron2/modeling/box_regression.py","snippet":"class Box2BoxTransform(object):\r\n \"\"\"\r\n The box-to-box transform defined in R-CNN. The transformation is parameterized\r\n by 4 deltas: (dx, dy, dw, dh). The transformation scales the box's width and height\r\n by exp(dw), exp(dh) and shifts a box's center by the offset (dx * width, dy * height).\r\n \"\"\"\r\n\r\n def __init__(\r\n self, weights: Tuple[float, float, float, float], scale_clamp: float = _DEFAULT_SCALE_CLAMP\r\n ):\r\n \"\"\"\r\n Args:\r\n weights (4-element tuple): Scaling factors that are applied to the\r\n (dx, dy, dw, dh) deltas. In Fast R-CNN, these were originally set\r\n such that the deltas have unit variance; now they are treated as\r\n hyperparameters of the system.\r\n scale_clamp (float): When predicting deltas, the predicted box scaling\r\n factors (dw and dh) are clamped such that they are <= scale_clamp.\r\n \"\"\"\r\n self.weights = weights\r\n self.scale_clamp = scale_clamp\r\n\r\n def get_deltas(self, src_boxes, target_boxes):\r\n \"\"\"\r\n Get box regression transformation deltas (dx, dy, dw, dh) that can be used\r\n to transform the `src_boxes` into the `target_boxes`. That is, the relation\r\n ``target_boxes == self.apply_deltas(deltas, src_boxes)`` is true (unless\r\n any delta is too large and is clamped).\r\n\r\n Args:\r\n src_boxes (Tensor): source boxes, e.g., object proposals\r\n target_boxes (Tensor): target of the transformation, e.g., ground-truth\r\n boxes.\r\n \"\"\"\r\n assert isinstance(src_boxes, torch.Tensor), type(src_boxes)\r\n assert isinstance(target_boxes, torch.Tensor), type(target_boxes)\r\n\r\n src_widths = src_boxes[:, 2] - src_boxes[:, 0]\r\n src_heights = src_boxes[:, 3] - src_boxes[:, 1]\r\n src_ctr_x = src_boxes[:, 0] + 0.5 * src_widths\r\n src_ctr_y = src_boxes[:, 1] + 0.5 * src_heights\r\n\r\n target_widths = target_boxes[:, 2] - target_boxes[:, 0]\r\n target_heights = target_boxes[:, 3] - target_boxes[:, 1]\r\n target_ctr_x = target_boxes[:, 0] + 0.5 * target_widths\r\n target_ctr_y = target_boxes[:, 1] + 0.5 * target_heights\r\n\r\n wx, wy, ww, wh = self.weights\r\n dx = wx * (target_ctr_x - src_ctr_x) / src_widths\r\n dy = wy * (target_ctr_y - src_ctr_y) / src_heights\r\n dw = ww * torch.log(target_widths / src_widths)\r\n dh = wh * torch.log(target_heights / src_heights)\r\n\r\n deltas = torch.stack((dx, dy, dw, dh), dim=1)\r\n assert (src_widths > 0).all().item(), \"Input boxes to Box2BoxTransform are not valid!\"\r\n return deltas\r\n\r\n def apply_deltas(self, deltas, boxes):\r\n \"\"\"\r\n Apply transformation `deltas` (dx, dy, dw, dh) to `boxes`.\r\n\r\n Args:\r\n deltas (Tensor): transformation deltas of shape (N, k*4), where k >= 1.\r\n deltas[i] represents k potentially different class-specific\r\n box transformations for the single box boxes[i].\r\n boxes (Tensor): boxes to transform, of shape (N, 4)\r\n \"\"\"\r\n deltas = deltas.float() # ensure fp32 for decoding precision\r\n boxes = boxes.to(deltas.dtype)\r\n\r\n widths = boxes[:, 2] - boxes[:, 0]\r\n heights = boxes[:, 3] - boxes[:, 1]\r\n ctr_x = boxes[:, 0] + 0.5 * widths\r\n ctr_y = boxes[:, 1] + 0.5 * heights\r\n\r\n wx, wy, ww, wh = self.weights\r\n dx = deltas[:, 0::4] / wx\r\n dy = deltas[:, 1::4] / wy\r\n dw = deltas[:, 2::4] / ww\r\n dh = deltas[:, 3::4] / wh\r\n\r\n # Prevent sending too large values into torch.exp()\r\n dw = torch.clamp(dw, max=self.scale_clamp)\r\n dh = torch.clamp(dh, max=self.scale_clamp)\r\n\r\n pred_ctr_x = dx * widths[:, None] + ctr_x[:, None]\r\n pred_ctr_y = dy * heights[:, None] + ctr_y[:, None]\r\n pred_w = torch.exp(dw) * widths[:, None]\r\n pred_h = torch.exp(dh) * heights[:, None]\r\n\r\n x1 = pred_ctr_x - 0.5 * pred_w\r\n y1 = pred_ctr_y - 0.5 * pred_h\r\n x2 = pred_ctr_x + 0.5 * pred_w\r\n y2 = pred_ctr_y + 0.5 * pred_h\r\n pred_boxes = torch.stack((x1, y1, x2, y2), dim=-1)\r\n return pred_boxes.reshape(deltas.shape)\r"},{"identifier":"_dense_box_regression_loss","path":"annotator/oneformer/detectron2/modeling/box_regression.py","snippet":"def _dense_box_regression_loss(\r\n anchors: List[Union[Boxes, torch.Tensor]],\r\n box2box_transform: Box2BoxTransform,\r\n pred_anchor_deltas: List[torch.Tensor],\r\n gt_boxes: List[torch.Tensor],\r\n fg_mask: torch.Tensor,\r\n box_reg_loss_type=\"smooth_l1\",\r\n smooth_l1_beta=0.0,\r\n):\r\n \"\"\"\r\n Compute loss for dense multi-level box regression.\r\n Loss is accumulated over ``fg_mask``.\r\n\r\n Args:\r\n anchors: #lvl anchor boxes, each is (HixWixA, 4)\r\n pred_anchor_deltas: #lvl predictions, each is (N, HixWixA, 4)\r\n gt_boxes: N ground truth boxes, each has shape (R, 4) (R = sum(Hi * Wi * A))\r\n fg_mask: the foreground boolean mask of shape (N, R) to compute loss on\r\n box_reg_loss_type (str): Loss type to use. Supported losses: \"smooth_l1\", \"giou\",\r\n \"diou\", \"ciou\".\r\n smooth_l1_beta (float): beta parameter for the smooth L1 regression loss. Default to\r\n use L1 loss. Only used when `box_reg_loss_type` is \"smooth_l1\"\r\n \"\"\"\r\n if isinstance(anchors[0], Boxes):\r\n anchors = type(anchors[0]).cat(anchors).tensor # (R, 4)\r\n else:\r\n anchors = cat(anchors)\r\n if box_reg_loss_type == \"smooth_l1\":\r\n gt_anchor_deltas = [box2box_transform.get_deltas(anchors, k) for k in gt_boxes]\r\n gt_anchor_deltas = torch.stack(gt_anchor_deltas) # (N, R, 4)\r\n loss_box_reg = smooth_l1_loss(\r\n cat(pred_anchor_deltas, dim=1)[fg_mask],\r\n gt_anchor_deltas[fg_mask],\r\n beta=smooth_l1_beta,\r\n reduction=\"sum\",\r\n )\r\n elif box_reg_loss_type == \"giou\":\r\n pred_boxes = [\r\n box2box_transform.apply_deltas(k, anchors) for k in cat(pred_anchor_deltas, dim=1)\r\n ]\r\n loss_box_reg = giou_loss(\r\n torch.stack(pred_boxes)[fg_mask], torch.stack(gt_boxes)[fg_mask], reduction=\"sum\"\r\n )\r\n elif box_reg_loss_type == \"diou\":\r\n pred_boxes = [\r\n box2box_transform.apply_deltas(k, anchors) for k in cat(pred_anchor_deltas, dim=1)\r\n ]\r\n loss_box_reg = diou_loss(\r\n torch.stack(pred_boxes)[fg_mask], torch.stack(gt_boxes)[fg_mask], reduction=\"sum\"\r\n )\r\n elif box_reg_loss_type == \"ciou\":\r\n pred_boxes = [\r\n box2box_transform.apply_deltas(k, anchors) for k in cat(pred_anchor_deltas, dim=1)\r\n ]\r\n loss_box_reg = ciou_loss(\r\n torch.stack(pred_boxes)[fg_mask], torch.stack(gt_boxes)[fg_mask], reduction=\"sum\"\r\n )\r\n else:\r\n raise ValueError(f\"Invalid dense box regression loss type '{box_reg_loss_type}'\")\r\n return loss_box_reg\r"},{"identifier":"Matcher","path":"annotator/oneformer/detectron2/modeling/matcher.py","snippet":"class Matcher(object):\r\n \"\"\"\r\n This class assigns to each predicted \"element\" (e.g., a box) a ground-truth\r\n element. Each predicted element will have exactly zero or one matches; each\r\n ground-truth element may be matched to zero or more predicted elements.\r\n\r\n The matching is determined by the MxN match_quality_matrix, that characterizes\r\n how well each (ground-truth, prediction)-pair match each other. For example,\r\n if the elements are boxes, this matrix may contain box intersection-over-union\r\n overlap values.\r\n\r\n The matcher returns (a) a vector of length N containing the index of the\r\n ground-truth element m in [0, M) that matches to prediction n in [0, N).\r\n (b) a vector of length N containing the labels for each prediction.\r\n \"\"\"\r\n\r\n def __init__(\r\n self, thresholds: List[float], labels: List[int], allow_low_quality_matches: bool = False\r\n ):\r\n \"\"\"\r\n Args:\r\n thresholds (list): a list of thresholds used to stratify predictions\r\n into levels.\r\n labels (list): a list of values to label predictions belonging at\r\n each level. A label can be one of {-1, 0, 1} signifying\r\n {ignore, negative class, positive class}, respectively.\r\n allow_low_quality_matches (bool): if True, produce additional matches\r\n for predictions with maximum match quality lower than high_threshold.\r\n See set_low_quality_matches_ for more details.\r\n\r\n For example,\r\n thresholds = [0.3, 0.5]\r\n labels = [0, -1, 1]\r\n All predictions with iou < 0.3 will be marked with 0 and\r\n thus will be considered as false positives while training.\r\n All predictions with 0.3 <= iou < 0.5 will be marked with -1 and\r\n thus will be ignored.\r\n All predictions with 0.5 <= iou will be marked with 1 and\r\n thus will be considered as true positives.\r\n \"\"\"\r\n # Add -inf and +inf to first and last position in thresholds\r\n thresholds = thresholds[:]\r\n assert thresholds[0] > 0\r\n thresholds.insert(0, -float(\"inf\"))\r\n thresholds.append(float(\"inf\"))\r\n # Currently torchscript does not support all + generator\r\n assert all([low <= high for (low, high) in zip(thresholds[:-1], thresholds[1:])])\r\n assert all([l in [-1, 0, 1] for l in labels])\r\n assert len(labels) == len(thresholds) - 1\r\n self.thresholds = thresholds\r\n self.labels = labels\r\n self.allow_low_quality_matches = allow_low_quality_matches\r\n\r\n def __call__(self, match_quality_matrix):\r\n \"\"\"\r\n Args:\r\n match_quality_matrix (Tensor[float]): an MxN tensor, containing the\r\n pairwise quality between M ground-truth elements and N predicted\r\n elements. All elements must be >= 0 (due to the us of `torch.nonzero`\r\n for selecting indices in :meth:`set_low_quality_matches_`).\r\n\r\n Returns:\r\n matches (Tensor[int64]): a vector of length N, where matches[i] is a matched\r\n ground-truth index in [0, M)\r\n match_labels (Tensor[int8]): a vector of length N, where pred_labels[i] indicates\r\n whether a prediction is a true or false positive or ignored\r\n \"\"\"\r\n assert match_quality_matrix.dim() == 2\r\n if match_quality_matrix.numel() == 0:\r\n default_matches = match_quality_matrix.new_full(\r\n (match_quality_matrix.size(1),), 0, dtype=torch.int64\r\n )\r\n # When no gt boxes exist, we define IOU = 0 and therefore set labels\r\n # to `self.labels[0]`, which usually defaults to background class 0\r\n # To choose to ignore instead, can make labels=[-1,0,-1,1] + set appropriate thresholds\r\n default_match_labels = match_quality_matrix.new_full(\r\n (match_quality_matrix.size(1),), self.labels[0], dtype=torch.int8\r\n )\r\n return default_matches, default_match_labels\r\n\r\n assert torch.all(match_quality_matrix >= 0)\r\n\r\n # match_quality_matrix is M (gt) x N (predicted)\r\n # Max over gt elements (dim 0) to find best gt candidate for each prediction\r\n matched_vals, matches = match_quality_matrix.max(dim=0)\r\n\r\n match_labels = matches.new_full(matches.size(), 1, dtype=torch.int8)\r\n\r\n for (l, low, high) in zip(self.labels, self.thresholds[:-1], self.thresholds[1:]):\r\n low_high = (matched_vals >= low) & (matched_vals < high)\r\n match_labels[low_high] = l\r\n\r\n if self.allow_low_quality_matches:\r\n self.set_low_quality_matches_(match_labels, match_quality_matrix)\r\n\r\n return matches, match_labels\r\n\r\n def set_low_quality_matches_(self, match_labels, match_quality_matrix):\r\n \"\"\"\r\n Produce additional matches for predictions that have only low-quality matches.\r\n Specifically, for each ground-truth G find the set of predictions that have\r\n maximum overlap with it (including ties); for each prediction in that set, if\r\n it is unmatched, then match it to the ground-truth G.\r\n\r\n This function implements the RPN assignment case (i) in Sec. 3.1.2 of\r\n :paper:`Faster R-CNN`.\r\n \"\"\"\r\n # For each gt, find the prediction with which it has highest quality\r\n highest_quality_foreach_gt, _ = match_quality_matrix.max(dim=1)\r\n # Find the highest quality match available, even if it is low, including ties.\r\n # Note that the matches qualities must be positive due to the use of\r\n # `torch.nonzero`.\r\n _, pred_inds_with_highest_quality = nonzero_tuple(\r\n match_quality_matrix == highest_quality_foreach_gt[:, None]\r\n )\r\n # If an anchor was labeled positive only due to a low-quality match\r\n # with gt_A, but it has larger overlap with gt_B, it's matched index will still be gt_B.\r\n # This follows the implementation in Detectron, and is found to have no significant impact.\r\n match_labels[pred_inds_with_highest_quality] = 1\r"},{"identifier":"META_ARCH_REGISTRY","path":"annotator/oneformer/detectron2/modeling/meta_arch/build.py","snippet":"META_ARCH_REGISTRY = Registry(\"META_ARCH\") # noqa F401 isort:skip\r"},{"identifier":"DenseDetector","path":"annotator/oneformer/detectron2/modeling/meta_arch/dense_detector.py","snippet":"class DenseDetector(nn.Module):\r\n \"\"\"\r\n Base class for dense detector. We define a dense detector as a fully-convolutional model that\r\n makes per-pixel (i.e. dense) predictions.\r\n \"\"\"\r\n\r\n def __init__(\r\n self,\r\n backbone: Backbone,\r\n head: nn.Module,\r\n head_in_features: Optional[List[str]] = None,\r\n *,\r\n pixel_mean,\r\n pixel_std,\r\n ):\r\n \"\"\"\r\n Args:\r\n backbone: backbone module\r\n head: head module\r\n head_in_features: backbone features to use in head. Default to all backbone features.\r\n pixel_mean (Tuple[float]):\r\n Values to be used for image normalization (BGR order).\r\n To train on images of different number of channels, set different mean & std.\r\n Default values are the mean pixel value from ImageNet: [103.53, 116.28, 123.675]\r\n pixel_std (Tuple[float]):\r\n When using pre-trained models in Detectron1 or any MSRA models,\r\n std has been absorbed into its conv1 weights, so the std needs to be set 1.\r\n Otherwise, you can use [57.375, 57.120, 58.395] (ImageNet std)\r\n \"\"\"\r\n super().__init__()\r\n\r\n self.backbone = backbone\r\n self.head = head\r\n if head_in_features is None:\r\n shapes = self.backbone.output_shape()\r\n self.head_in_features = sorted(shapes.keys(), key=lambda x: shapes[x].stride)\r\n else:\r\n self.head_in_features = head_in_features\r\n self.register_buffer(\"pixel_mean\", torch.tensor(pixel_mean).view(-1, 1, 1), False)\r\n self.register_buffer(\"pixel_std\", torch.tensor(pixel_std).view(-1, 1, 1), False)\r\n\r\n @property\r\n def device(self):\r\n return self.pixel_mean.device\r\n\r\n def _move_to_current_device(self, x):\r\n return move_device_like(x, self.pixel_mean)\r\n\r\n def forward(self, batched_inputs: List[Dict[str, Tensor]]):\r\n \"\"\"\r\n Args:\r\n batched_inputs: a list, batched outputs of :class:`DatasetMapper` .\r\n Each item in the list contains the inputs for one image.\r\n For now, each item in the list is a dict that contains:\r\n\r\n * image: Tensor, image in (C, H, W) format.\r\n * instances: Instances\r\n\r\n Other information that's included in the original dicts, such as:\r\n\r\n * \"height\", \"width\" (int): the output resolution of the model, used in inference.\r\n See :meth:`postprocess` for details.\r\n\r\n Returns:\r\n In training, dict[str, Tensor]: mapping from a named loss to a tensor storing the\r\n loss. Used during training only. In inference, the standard output format, described\r\n in :doc:`/tutorials/models`.\r\n \"\"\"\r\n images = self.preprocess_image(batched_inputs)\r\n features = self.backbone(images.tensor)\r\n features = [features[f] for f in self.head_in_features]\r\n predictions = self.head(features)\r\n\r\n if self.training:\r\n assert not torch.jit.is_scripting(), \"Not supported\"\r\n assert \"instances\" in batched_inputs[0], \"Instance annotations are missing in training!\"\r\n gt_instances = [x[\"instances\"].to(self.device) for x in batched_inputs]\r\n return self.forward_training(images, features, predictions, gt_instances)\r\n else:\r\n results = self.forward_inference(images, features, predictions)\r\n if torch.jit.is_scripting():\r\n return results\r\n\r\n processed_results = []\r\n for results_per_image, input_per_image, image_size in zip(\r\n results, batched_inputs, images.image_sizes\r\n ):\r\n height = input_per_image.get(\"height\", image_size[0])\r\n width = input_per_image.get(\"width\", image_size[1])\r\n r = detector_postprocess(results_per_image, height, width)\r\n processed_results.append({\"instances\": r})\r\n return processed_results\r\n\r\n def forward_training(self, images, features, predictions, gt_instances):\r\n raise NotImplementedError()\r\n\r\n def preprocess_image(self, batched_inputs: List[Dict[str, Tensor]]):\r\n \"\"\"\r\n Normalize, pad and batch the input images.\r\n \"\"\"\r\n images = [self._move_to_current_device(x[\"image\"]) for x in batched_inputs]\r\n images = [(x - self.pixel_mean) / self.pixel_std for x in images]\r\n images = ImageList.from_tensors(\r\n images,\r\n self.backbone.size_divisibility,\r\n padding_constraints=self.backbone.padding_constraints,\r\n )\r\n return images\r\n\r\n def _transpose_dense_predictions(\r\n self, predictions: List[List[Tensor]], dims_per_anchor: List[int]\r\n ) -> List[List[Tensor]]:\r\n \"\"\"\r\n Transpose the dense per-level predictions.\r\n\r\n Args:\r\n predictions: a list of outputs, each is a list of per-level\r\n predictions with shape (N, Ai x K, Hi, Wi), where N is the\r\n number of images, Ai is the number of anchors per location on\r\n level i, K is the dimension of predictions per anchor.\r\n dims_per_anchor: the value of K for each predictions. e.g. 4 for\r\n box prediction, #classes for classification prediction.\r\n\r\n Returns:\r\n List[List[Tensor]]: each prediction is transposed to (N, Hi x Wi x Ai, K).\r\n \"\"\"\r\n assert len(predictions) == len(dims_per_anchor)\r\n res: List[List[Tensor]] = []\r\n for pred, dim_per_anchor in zip(predictions, dims_per_anchor):\r\n pred = [permute_to_N_HWA_K(x, dim_per_anchor) for x in pred]\r\n res.append(pred)\r\n return res\r\n\r\n def _ema_update(self, name: str, value: float, initial_value: float, momentum: float = 0.9):\r\n \"\"\"\r\n Apply EMA update to `self.name` using `value`.\r\n\r\n This is mainly used for loss normalizer. In Detectron1, loss is normalized by number\r\n of foreground samples in the batch. When batch size is 1 per GPU, #foreground has a\r\n large variance and using it lead to lower performance. Therefore we maintain an EMA of\r\n #foreground to stabilize the normalizer.\r\n\r\n Args:\r\n name: name of the normalizer\r\n value: the new value to update\r\n initial_value: the initial value to start with\r\n momentum: momentum of EMA\r\n\r\n Returns:\r\n float: the updated EMA value\r\n \"\"\"\r\n if hasattr(self, name):\r\n old = getattr(self, name)\r\n else:\r\n old = initial_value\r\n new = old * momentum + value * (1 - momentum)\r\n setattr(self, name, new)\r\n return new\r\n\r\n def _decode_per_level_predictions(\r\n self,\r\n anchors: Boxes,\r\n pred_scores: Tensor,\r\n pred_deltas: Tensor,\r\n score_thresh: float,\r\n topk_candidates: int,\r\n image_size: Tuple[int, int],\r\n ) -> Instances:\r\n \"\"\"\r\n Decode boxes and classification predictions of one featuer level, by\r\n the following steps:\r\n 1. filter the predictions based on score threshold and top K scores.\r\n 2. transform the box regression outputs\r\n 3. return the predicted scores, classes and boxes\r\n\r\n Args:\r\n anchors: Boxes, anchor for this feature level\r\n pred_scores: HxWxA,K\r\n pred_deltas: HxWxA,4\r\n\r\n Returns:\r\n Instances: with field \"scores\", \"pred_boxes\", \"pred_classes\".\r\n \"\"\"\r\n # Apply two filtering to make NMS faster.\r\n # 1. Keep boxes with confidence score higher than threshold\r\n keep_idxs = pred_scores > score_thresh\r\n pred_scores = pred_scores[keep_idxs]\r\n topk_idxs = torch.nonzero(keep_idxs) # Kx2\r\n\r\n # 2. Keep top k top scoring boxes only\r\n topk_idxs_size = topk_idxs.shape[0]\r\n if isinstance(topk_idxs_size, Tensor):\r\n # It's a tensor in tracing\r\n num_topk = torch.clamp(topk_idxs_size, max=topk_candidates)\r\n else:\r\n num_topk = min(topk_idxs_size, topk_candidates)\r\n pred_scores, idxs = pred_scores.topk(num_topk)\r\n topk_idxs = topk_idxs[idxs]\r\n\r\n anchor_idxs, classes_idxs = topk_idxs.unbind(dim=1)\r\n\r\n pred_boxes = self.box2box_transform.apply_deltas(\r\n pred_deltas[anchor_idxs], anchors.tensor[anchor_idxs]\r\n )\r\n return Instances(\r\n image_size, pred_boxes=Boxes(pred_boxes), scores=pred_scores, pred_classes=classes_idxs\r\n )\r\n\r\n def _decode_multi_level_predictions(\r\n self,\r\n anchors: List[Boxes],\r\n pred_scores: List[Tensor],\r\n pred_deltas: List[Tensor],\r\n score_thresh: float,\r\n topk_candidates: int,\r\n image_size: Tuple[int, int],\r\n ) -> Instances:\r\n \"\"\"\r\n Run `_decode_per_level_predictions` for all feature levels and concat the results.\r\n \"\"\"\r\n predictions = [\r\n self._decode_per_level_predictions(\r\n anchors_i,\r\n box_cls_i,\r\n box_reg_i,\r\n self.test_score_thresh,\r\n self.test_topk_candidates,\r\n image_size,\r\n )\r\n # Iterate over every feature level\r\n for box_cls_i, box_reg_i, anchors_i in zip(pred_scores, pred_deltas, anchors)\r\n ]\r\n return predictions[0].cat(predictions) # 'Instances.cat' is not scriptale but this is\r\n\r\n def visualize_training(self, batched_inputs, results):\r\n \"\"\"\r\n A function used to visualize ground truth images and final network predictions.\r\n It shows ground truth bounding boxes on the original image and up to 20\r\n predicted object bounding boxes on the original image.\r\n\r\n Args:\r\n batched_inputs (list): a list that contains input to the model.\r\n results (List[Instances]): a list of #images elements returned by forward_inference().\r\n \"\"\"\r\n from annotator.oneformer.detectron2.utils.visualizer import Visualizer\r\n\r\n assert len(batched_inputs) == len(\r\n results\r\n ), \"Cannot visualize inputs and results of different sizes\"\r\n storage = get_event_storage()\r\n max_boxes = 20\r\n\r\n image_index = 0 # only visualize a single image\r\n img = batched_inputs[image_index][\"image\"]\r\n img = convert_image_to_rgb(img.permute(1, 2, 0), self.input_format)\r\n v_gt = Visualizer(img, None)\r\n v_gt = v_gt.overlay_instances(boxes=batched_inputs[image_index][\"instances\"].gt_boxes)\r\n anno_img = v_gt.get_image()\r\n processed_results = detector_postprocess(results[image_index], img.shape[0], img.shape[1])\r\n predicted_boxes = processed_results.pred_boxes.tensor.detach().cpu().numpy()\r\n\r\n v_pred = Visualizer(img, None)\r\n v_pred = v_pred.overlay_instances(boxes=predicted_boxes[0:max_boxes])\r\n prop_img = v_pred.get_image()\r\n vis_img = np.vstack((anno_img, prop_img))\r\n vis_img = vis_img.transpose(2, 0, 1)\r\n vis_name = f\"Top: GT bounding boxes; Bottom: {max_boxes} Highest Scoring Results\"\r\n storage.put_image(vis_name, vis_img)\r"},{"identifier":"permute_to_N_HWA_K","path":"annotator/oneformer/detectron2/modeling/meta_arch/dense_detector.py","snippet":"def permute_to_N_HWA_K(tensor, K: int):\r\n \"\"\"\r\n Transpose/reshape a tensor from (N, (Ai x K), H, W) to (N, (HxWxAi), K)\r\n \"\"\"\r\n assert tensor.dim() == 4, tensor.shape\r\n N, _, H, W = tensor.shape\r\n tensor = tensor.view(N, -1, K, H, W)\r\n tensor = tensor.permute(0, 3, 4, 1, 2)\r\n tensor = tensor.reshape(N, -1, K) # Size=(N,HWA,K)\r\n return tensor\r"}],"string":"[\n {\n \"identifier\": \"configurable\",\n \"path\": \"annotator/oneformer/detectron2/config/config.py\",\n \"snippet\": \"def configurable(init_func=None, *, from_config=None):\\r\\n \\\"\\\"\\\"\\r\\n Decorate a function or a class's __init__ method so that it can be called\\r\\n with a :class:`CfgNode` object using a :func:`from_config` function that translates\\r\\n :class:`CfgNode` to arguments.\\r\\n\\r\\n Examples:\\r\\n ::\\r\\n # Usage 1: Decorator on __init__:\\r\\n class A:\\r\\n @configurable\\r\\n def __init__(self, a, b=2, c=3):\\r\\n pass\\r\\n\\r\\n @classmethod\\r\\n def from_config(cls, cfg): # 'cfg' must be the first argument\\r\\n # Returns kwargs to be passed to __init__\\r\\n return {\\\"a\\\": cfg.A, \\\"b\\\": cfg.B}\\r\\n\\r\\n a1 = A(a=1, b=2) # regular construction\\r\\n a2 = A(cfg) # construct with a cfg\\r\\n a3 = A(cfg, b=3, c=4) # construct with extra overwrite\\r\\n\\r\\n # Usage 2: Decorator on any function. Needs an extra from_config argument:\\r\\n @configurable(from_config=lambda cfg: {\\\"a: cfg.A, \\\"b\\\": cfg.B})\\r\\n def a_func(a, b=2, c=3):\\r\\n pass\\r\\n\\r\\n a1 = a_func(a=1, b=2) # regular call\\r\\n a2 = a_func(cfg) # call with a cfg\\r\\n a3 = a_func(cfg, b=3, c=4) # call with extra overwrite\\r\\n\\r\\n Args:\\r\\n init_func (callable): a class's ``__init__`` method in usage 1. The\\r\\n class must have a ``from_config`` classmethod which takes `cfg` as\\r\\n the first argument.\\r\\n from_config (callable): the from_config function in usage 2. It must take `cfg`\\r\\n as its first argument.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n if init_func is not None:\\r\\n assert (\\r\\n inspect.isfunction(init_func)\\r\\n and from_config is None\\r\\n and init_func.__name__ == \\\"__init__\\\"\\r\\n ), \\\"Incorrect use of @configurable. Check API documentation for examples.\\\"\\r\\n\\r\\n @functools.wraps(init_func)\\r\\n def wrapped(self, *args, **kwargs):\\r\\n try:\\r\\n from_config_func = type(self).from_config\\r\\n except AttributeError as e:\\r\\n raise AttributeError(\\r\\n \\\"Class with @configurable must have a 'from_config' classmethod.\\\"\\r\\n ) from e\\r\\n if not inspect.ismethod(from_config_func):\\r\\n raise TypeError(\\\"Class with @configurable must have a 'from_config' classmethod.\\\")\\r\\n\\r\\n if _called_with_cfg(*args, **kwargs):\\r\\n explicit_args = _get_args_from_config(from_config_func, *args, **kwargs)\\r\\n init_func(self, **explicit_args)\\r\\n else:\\r\\n init_func(self, *args, **kwargs)\\r\\n\\r\\n return wrapped\\r\\n\\r\\n else:\\r\\n if from_config is None:\\r\\n return configurable # @configurable() is made equivalent to @configurable\\r\\n assert inspect.isfunction(\\r\\n from_config\\r\\n ), \\\"from_config argument of configurable must be a function!\\\"\\r\\n\\r\\n def wrapper(orig_func):\\r\\n @functools.wraps(orig_func)\\r\\n def wrapped(*args, **kwargs):\\r\\n if _called_with_cfg(*args, **kwargs):\\r\\n explicit_args = _get_args_from_config(from_config, *args, **kwargs)\\r\\n return orig_func(**explicit_args)\\r\\n else:\\r\\n return orig_func(*args, **kwargs)\\r\\n\\r\\n wrapped.from_config = from_config\\r\\n return wrapped\\r\\n\\r\\n return wrapper\\r\"\n },\n {\n \"identifier\": \"get_norm\",\n \"path\": \"annotator/oneformer/detectron2/layers/batch_norm.py\",\n \"snippet\": \"def get_norm(norm, out_channels):\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n norm (str or callable): either one of BN, SyncBN, FrozenBN, GN;\\r\\n or a callable that takes a channel number and returns\\r\\n the normalization layer as a nn.Module.\\r\\n\\r\\n Returns:\\r\\n nn.Module or None: the normalization layer\\r\\n \\\"\\\"\\\"\\r\\n if norm is None:\\r\\n return None\\r\\n if isinstance(norm, str):\\r\\n if len(norm) == 0:\\r\\n return None\\r\\n norm = {\\r\\n \\\"BN\\\": BatchNorm2d,\\r\\n # Fixed in https://github.com/pytorch/pytorch/pull/36382\\r\\n \\\"SyncBN\\\": NaiveSyncBatchNorm if env.TORCH_VERSION <= (1, 5) else nn.SyncBatchNorm,\\r\\n \\\"FrozenBN\\\": FrozenBatchNorm2d,\\r\\n \\\"GN\\\": lambda channels: nn.GroupNorm(32, channels),\\r\\n # for debugging:\\r\\n \\\"nnSyncBN\\\": nn.SyncBatchNorm,\\r\\n \\\"naiveSyncBN\\\": NaiveSyncBatchNorm,\\r\\n # expose stats_mode N as an option to caller, required for zero-len inputs\\r\\n \\\"naiveSyncBN_N\\\": lambda channels: NaiveSyncBatchNorm(channels, stats_mode=\\\"N\\\"),\\r\\n \\\"LN\\\": lambda channels: LayerNorm(channels),\\r\\n }[norm]\\r\\n return norm(out_channels)\\r\"\n },\n {\n \"identifier\": \"CycleBatchNormList\",\n \"path\": \"annotator/oneformer/detectron2/layers/batch_norm.py\",\n \"snippet\": \"class CycleBatchNormList(nn.ModuleList):\\r\\n \\\"\\\"\\\"\\r\\n Implement domain-specific BatchNorm by cycling.\\r\\n\\r\\n When a BatchNorm layer is used for multiple input domains or input\\r\\n features, it might need to maintain a separate test-time statistics\\r\\n for each domain. See Sec 5.2 in :paper:`rethinking-batchnorm`.\\r\\n\\r\\n This module implements it by using N separate BN layers\\r\\n and it cycles through them every time a forward() is called.\\r\\n\\r\\n NOTE: The caller of this module MUST guarantee to always call\\r\\n this module by multiple of N times. Otherwise its test-time statistics\\r\\n will be incorrect.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(self, length: int, bn_class=nn.BatchNorm2d, **kwargs):\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n length: number of BatchNorm layers to cycle.\\r\\n bn_class: the BatchNorm class to use\\r\\n kwargs: arguments of the BatchNorm class, such as num_features.\\r\\n \\\"\\\"\\\"\\r\\n self._affine = kwargs.pop(\\\"affine\\\", True)\\r\\n super().__init__([bn_class(**kwargs, affine=False) for k in range(length)])\\r\\n if self._affine:\\r\\n # shared affine, domain-specific BN\\r\\n channels = self[0].num_features\\r\\n self.weight = nn.Parameter(torch.ones(channels))\\r\\n self.bias = nn.Parameter(torch.zeros(channels))\\r\\n self._pos = 0\\r\\n\\r\\n def forward(self, x):\\r\\n ret = self[self._pos](x)\\r\\n self._pos = (self._pos + 1) % len(self)\\r\\n\\r\\n if self._affine:\\r\\n w = self.weight.reshape(1, -1, 1, 1)\\r\\n b = self.bias.reshape(1, -1, 1, 1)\\r\\n return ret * w + b\\r\\n else:\\r\\n return ret\\r\\n\\r\\n def extra_repr(self):\\r\\n return f\\\"affine={self._affine}\\\"\\r\"\n },\n {\n \"identifier\": \"batched_nms\",\n \"path\": \"annotator/oneformer/detectron2/layers/nms.py\",\n \"snippet\": \"def batched_nms(\\r\\n boxes: torch.Tensor, scores: torch.Tensor, idxs: torch.Tensor, iou_threshold: float\\r\\n):\\r\\n \\\"\\\"\\\"\\r\\n Same as torchvision.ops.boxes.batched_nms, but with float().\\r\\n \\\"\\\"\\\"\\r\\n assert boxes.shape[-1] == 4\\r\\n # Note: Torchvision already has a strategy (https://github.com/pytorch/vision/issues/1311)\\r\\n # to decide whether to use coordinate trick or for loop to implement batched_nms. So we\\r\\n # just call it directly.\\r\\n # Fp16 does not have enough range for batched NMS, so adding float().\\r\\n return box_ops.batched_nms(boxes.float(), scores, idxs, iou_threshold)\\r\"\n },\n {\n \"identifier\": \"ShapeSpec\",\n \"path\": \"annotator/oneformer/detectron2/layers/shape_spec.py\",\n \"snippet\": \"class ShapeSpec:\\r\\n \\\"\\\"\\\"\\r\\n A simple structure that contains basic shape specification about a tensor.\\r\\n It is often used as the auxiliary inputs/outputs of models,\\r\\n to complement the lack of shape inference ability among pytorch modules.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n channels: Optional[int] = None\\r\\n height: Optional[int] = None\\r\\n width: Optional[int] = None\\r\\n stride: Optional[int] = None\\r\"\n },\n {\n \"identifier\": \"cat\",\n \"path\": \"annotator/oneformer/detectron2/layers/wrappers.py\",\n \"snippet\": \"def cat(tensors: List[torch.Tensor], dim: int = 0):\\r\\n \\\"\\\"\\\"\\r\\n Efficient version of torch.cat that avoids a copy if there is only a single element in a list\\r\\n \\\"\\\"\\\"\\r\\n assert isinstance(tensors, (list, tuple))\\r\\n if len(tensors) == 1:\\r\\n return tensors[0]\\r\\n return torch.cat(tensors, dim)\\r\"\n },\n {\n \"identifier\": \"Boxes\",\n \"path\": \"annotator/oneformer/detectron2/structures/boxes.py\",\n \"snippet\": \"class Boxes:\\r\\n \\\"\\\"\\\"\\r\\n This structure stores a list of boxes as a Nx4 torch.Tensor.\\r\\n It supports some common methods about boxes\\r\\n (`area`, `clip`, `nonempty`, etc),\\r\\n and also behaves like a Tensor\\r\\n (support indexing, `to(device)`, `.device`, and iteration over all boxes)\\r\\n\\r\\n Attributes:\\r\\n tensor (torch.Tensor): float matrix of Nx4. Each row is (x1, y1, x2, y2).\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(self, tensor: torch.Tensor):\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n tensor (Tensor[float]): a Nx4 matrix. Each row is (x1, y1, x2, y2).\\r\\n \\\"\\\"\\\"\\r\\n if not isinstance(tensor, torch.Tensor):\\r\\n tensor = torch.as_tensor(tensor, dtype=torch.float32, device=torch.device(\\\"cpu\\\"))\\r\\n else:\\r\\n tensor = tensor.to(torch.float32)\\r\\n if tensor.numel() == 0:\\r\\n # Use reshape, so we don't end up creating a new tensor that does not depend on\\r\\n # the inputs (and consequently confuses jit)\\r\\n tensor = tensor.reshape((-1, 4)).to(dtype=torch.float32)\\r\\n assert tensor.dim() == 2 and tensor.size(-1) == 4, tensor.size()\\r\\n\\r\\n self.tensor = tensor\\r\\n\\r\\n def clone(self) -> \\\"Boxes\\\":\\r\\n \\\"\\\"\\\"\\r\\n Clone the Boxes.\\r\\n\\r\\n Returns:\\r\\n Boxes\\r\\n \\\"\\\"\\\"\\r\\n return Boxes(self.tensor.clone())\\r\\n\\r\\n def to(self, device: torch.device):\\r\\n # Boxes are assumed float32 and does not support to(dtype)\\r\\n return Boxes(self.tensor.to(device=device))\\r\\n\\r\\n def area(self) -> torch.Tensor:\\r\\n \\\"\\\"\\\"\\r\\n Computes the area of all the boxes.\\r\\n\\r\\n Returns:\\r\\n torch.Tensor: a vector with areas of each box.\\r\\n \\\"\\\"\\\"\\r\\n box = self.tensor\\r\\n area = (box[:, 2] - box[:, 0]) * (box[:, 3] - box[:, 1])\\r\\n return area\\r\\n\\r\\n def clip(self, box_size: Tuple[int, int]) -> None:\\r\\n \\\"\\\"\\\"\\r\\n Clip (in place) the boxes by limiting x coordinates to the range [0, width]\\r\\n and y coordinates to the range [0, height].\\r\\n\\r\\n Args:\\r\\n box_size (height, width): The clipping box's size.\\r\\n \\\"\\\"\\\"\\r\\n assert torch.isfinite(self.tensor).all(), \\\"Box tensor contains infinite or NaN!\\\"\\r\\n h, w = box_size\\r\\n x1 = self.tensor[:, 0].clamp(min=0, max=w)\\r\\n y1 = self.tensor[:, 1].clamp(min=0, max=h)\\r\\n x2 = self.tensor[:, 2].clamp(min=0, max=w)\\r\\n y2 = self.tensor[:, 3].clamp(min=0, max=h)\\r\\n self.tensor = torch.stack((x1, y1, x2, y2), dim=-1)\\r\\n\\r\\n def nonempty(self, threshold: float = 0.0) -> torch.Tensor:\\r\\n \\\"\\\"\\\"\\r\\n Find boxes that are non-empty.\\r\\n A box is considered empty, if either of its side is no larger than threshold.\\r\\n\\r\\n Returns:\\r\\n Tensor:\\r\\n a binary vector which represents whether each box is empty\\r\\n (False) or non-empty (True).\\r\\n \\\"\\\"\\\"\\r\\n box = self.tensor\\r\\n widths = box[:, 2] - box[:, 0]\\r\\n heights = box[:, 3] - box[:, 1]\\r\\n keep = (widths > threshold) & (heights > threshold)\\r\\n return keep\\r\\n\\r\\n def __getitem__(self, item) -> \\\"Boxes\\\":\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n item: int, slice, or a BoolTensor\\r\\n\\r\\n Returns:\\r\\n Boxes: Create a new :class:`Boxes` by indexing.\\r\\n\\r\\n The following usage are allowed:\\r\\n\\r\\n 1. `new_boxes = boxes[3]`: return a `Boxes` which contains only one box.\\r\\n 2. `new_boxes = boxes[2:10]`: return a slice of boxes.\\r\\n 3. `new_boxes = boxes[vector]`, where vector is a torch.BoolTensor\\r\\n with `length = len(boxes)`. Nonzero elements in the vector will be selected.\\r\\n\\r\\n Note that the returned Boxes might share storage with this Boxes,\\r\\n subject to Pytorch's indexing semantics.\\r\\n \\\"\\\"\\\"\\r\\n if isinstance(item, int):\\r\\n return Boxes(self.tensor[item].view(1, -1))\\r\\n b = self.tensor[item]\\r\\n assert b.dim() == 2, \\\"Indexing on Boxes with {} failed to return a matrix!\\\".format(item)\\r\\n return Boxes(b)\\r\\n\\r\\n def __len__(self) -> int:\\r\\n return self.tensor.shape[0]\\r\\n\\r\\n def __repr__(self) -> str:\\r\\n return \\\"Boxes(\\\" + str(self.tensor) + \\\")\\\"\\r\\n\\r\\n def inside_box(self, box_size: Tuple[int, int], boundary_threshold: int = 0) -> torch.Tensor:\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n box_size (height, width): Size of the reference box.\\r\\n boundary_threshold (int): Boxes that extend beyond the reference box\\r\\n boundary by more than boundary_threshold are considered \\\"outside\\\".\\r\\n\\r\\n Returns:\\r\\n a binary vector, indicating whether each box is inside the reference box.\\r\\n \\\"\\\"\\\"\\r\\n height, width = box_size\\r\\n inds_inside = (\\r\\n (self.tensor[..., 0] >= -boundary_threshold)\\r\\n & (self.tensor[..., 1] >= -boundary_threshold)\\r\\n & (self.tensor[..., 2] < width + boundary_threshold)\\r\\n & (self.tensor[..., 3] < height + boundary_threshold)\\r\\n )\\r\\n return inds_inside\\r\\n\\r\\n def get_centers(self) -> torch.Tensor:\\r\\n \\\"\\\"\\\"\\r\\n Returns:\\r\\n The box centers in a Nx2 array of (x, y).\\r\\n \\\"\\\"\\\"\\r\\n return (self.tensor[:, :2] + self.tensor[:, 2:]) / 2\\r\\n\\r\\n def scale(self, scale_x: float, scale_y: float) -> None:\\r\\n \\\"\\\"\\\"\\r\\n Scale the box with horizontal and vertical scaling factors\\r\\n \\\"\\\"\\\"\\r\\n self.tensor[:, 0::2] *= scale_x\\r\\n self.tensor[:, 1::2] *= scale_y\\r\\n\\r\\n @classmethod\\r\\n def cat(cls, boxes_list: List[\\\"Boxes\\\"]) -> \\\"Boxes\\\":\\r\\n \\\"\\\"\\\"\\r\\n Concatenates a list of Boxes into a single Boxes\\r\\n\\r\\n Arguments:\\r\\n boxes_list (list[Boxes])\\r\\n\\r\\n Returns:\\r\\n Boxes: the concatenated Boxes\\r\\n \\\"\\\"\\\"\\r\\n assert isinstance(boxes_list, (list, tuple))\\r\\n if len(boxes_list) == 0:\\r\\n return cls(torch.empty(0))\\r\\n assert all([isinstance(box, Boxes) for box in boxes_list])\\r\\n\\r\\n # use torch.cat (v.s. layers.cat) so the returned boxes never share storage with input\\r\\n cat_boxes = cls(torch.cat([b.tensor for b in boxes_list], dim=0))\\r\\n return cat_boxes\\r\\n\\r\\n @property\\r\\n def device(self) -> device:\\r\\n return self.tensor.device\\r\\n\\r\\n # type \\\"Iterator[torch.Tensor]\\\", yield, and iter() not supported by torchscript\\r\\n # https://github.com/pytorch/pytorch/issues/18627\\r\\n @torch.jit.unused\\r\\n def __iter__(self):\\r\\n \\\"\\\"\\\"\\r\\n Yield a box as a Tensor of shape (4,) at a time.\\r\\n \\\"\\\"\\\"\\r\\n yield from self.tensor\\r\"\n },\n {\n \"identifier\": \"pairwise_iou\",\n \"path\": \"annotator/oneformer/detectron2/structures/boxes.py\",\n \"snippet\": \"def pairwise_iou(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:\\r\\n \\\"\\\"\\\"\\r\\n Given two lists of boxes of size N and M, compute the IoU\\r\\n (intersection over union) between **all** N x M pairs of boxes.\\r\\n The box order must be (xmin, ymin, xmax, ymax).\\r\\n\\r\\n Args:\\r\\n boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.\\r\\n\\r\\n Returns:\\r\\n Tensor: IoU, sized [N,M].\\r\\n \\\"\\\"\\\"\\r\\n area1 = boxes1.area() # [N]\\r\\n area2 = boxes2.area() # [M]\\r\\n inter = pairwise_intersection(boxes1, boxes2)\\r\\n\\r\\n # handle empty boxes\\r\\n iou = torch.where(\\r\\n inter > 0,\\r\\n inter / (area1[:, None] + area2 - inter),\\r\\n torch.zeros(1, dtype=inter.dtype, device=inter.device),\\r\\n )\\r\\n return iou\\r\"\n },\n {\n \"identifier\": \"ImageList\",\n \"path\": \"annotator/oneformer/detectron2/structures/image_list.py\",\n \"snippet\": \"class ImageList(object):\\r\\n \\\"\\\"\\\"\\r\\n Structure that holds a list of images (of possibly\\r\\n varying sizes) as a single tensor.\\r\\n This works by padding the images to the same size.\\r\\n The original sizes of each image is stored in `image_sizes`.\\r\\n\\r\\n Attributes:\\r\\n image_sizes (list[tuple[int, int]]): each tuple is (h, w).\\r\\n During tracing, it becomes list[Tensor] instead.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(self, tensor: torch.Tensor, image_sizes: List[Tuple[int, int]]):\\r\\n \\\"\\\"\\\"\\r\\n Arguments:\\r\\n tensor (Tensor): of shape (N, H, W) or (N, C_1, ..., C_K, H, W) where K >= 1\\r\\n image_sizes (list[tuple[int, int]]): Each tuple is (h, w). It can\\r\\n be smaller than (H, W) due to padding.\\r\\n \\\"\\\"\\\"\\r\\n self.tensor = tensor\\r\\n self.image_sizes = image_sizes\\r\\n\\r\\n def __len__(self) -> int:\\r\\n return len(self.image_sizes)\\r\\n\\r\\n def __getitem__(self, idx) -> torch.Tensor:\\r\\n \\\"\\\"\\\"\\r\\n Access the individual image in its original size.\\r\\n\\r\\n Args:\\r\\n idx: int or slice\\r\\n\\r\\n Returns:\\r\\n Tensor: an image of shape (H, W) or (C_1, ..., C_K, H, W) where K >= 1\\r\\n \\\"\\\"\\\"\\r\\n size = self.image_sizes[idx]\\r\\n return self.tensor[idx, ..., : size[0], : size[1]]\\r\\n\\r\\n @torch.jit.unused\\r\\n def to(self, *args: Any, **kwargs: Any) -> \\\"ImageList\\\":\\r\\n cast_tensor = self.tensor.to(*args, **kwargs)\\r\\n return ImageList(cast_tensor, self.image_sizes)\\r\\n\\r\\n @property\\r\\n def device(self) -> device:\\r\\n return self.tensor.device\\r\\n\\r\\n @staticmethod\\r\\n def from_tensors(\\r\\n tensors: List[torch.Tensor],\\r\\n size_divisibility: int = 0,\\r\\n pad_value: float = 0.0,\\r\\n padding_constraints: Optional[Dict[str, int]] = None,\\r\\n ) -> \\\"ImageList\\\":\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n tensors: a tuple or list of `torch.Tensor`, each of shape (Hi, Wi) or\\r\\n (C_1, ..., C_K, Hi, Wi) where K >= 1. The Tensors will be padded\\r\\n to the same shape with `pad_value`.\\r\\n size_divisibility (int): If `size_divisibility > 0`, add padding to ensure\\r\\n the common height and width is divisible by `size_divisibility`.\\r\\n This depends on the model and many models need a divisibility of 32.\\r\\n pad_value (float): value to pad.\\r\\n padding_constraints (optional[Dict]): If given, it would follow the format as\\r\\n {\\\"size_divisibility\\\": int, \\\"square_size\\\": int}, where `size_divisibility` will\\r\\n overwrite the above one if presented and `square_size` indicates the\\r\\n square padding size if `square_size` > 0.\\r\\n Returns:\\r\\n an `ImageList`.\\r\\n \\\"\\\"\\\"\\r\\n assert len(tensors) > 0\\r\\n assert isinstance(tensors, (tuple, list))\\r\\n for t in tensors:\\r\\n assert isinstance(t, torch.Tensor), type(t)\\r\\n assert t.shape[:-2] == tensors[0].shape[:-2], t.shape\\r\\n\\r\\n image_sizes = [(im.shape[-2], im.shape[-1]) for im in tensors]\\r\\n image_sizes_tensor = [shapes_to_tensor(x) for x in image_sizes]\\r\\n max_size = torch.stack(image_sizes_tensor).max(0).values\\r\\n\\r\\n if padding_constraints is not None:\\r\\n square_size = padding_constraints.get(\\\"square_size\\\", 0)\\r\\n if square_size > 0:\\r\\n # pad to square.\\r\\n max_size[0] = max_size[1] = square_size\\r\\n if \\\"size_divisibility\\\" in padding_constraints:\\r\\n size_divisibility = padding_constraints[\\\"size_divisibility\\\"]\\r\\n if size_divisibility > 1:\\r\\n stride = size_divisibility\\r\\n # the last two dims are H,W, both subject to divisibility requirement\\r\\n max_size = (max_size + (stride - 1)).div(stride, rounding_mode=\\\"floor\\\") * stride\\r\\n\\r\\n # handle weirdness of scripting and tracing ...\\r\\n if torch.jit.is_scripting():\\r\\n max_size: List[int] = max_size.to(dtype=torch.long).tolist()\\r\\n else:\\r\\n if torch.jit.is_tracing():\\r\\n image_sizes = image_sizes_tensor\\r\\n\\r\\n if len(tensors) == 1:\\r\\n # This seems slightly (2%) faster.\\r\\n # TODO: check whether it's faster for multiple images as well\\r\\n image_size = image_sizes[0]\\r\\n padding_size = [0, max_size[-1] - image_size[1], 0, max_size[-2] - image_size[0]]\\r\\n batched_imgs = F.pad(tensors[0], padding_size, value=pad_value).unsqueeze_(0)\\r\\n else:\\r\\n # max_size can be a tensor in tracing mode, therefore convert to list\\r\\n batch_shape = [len(tensors)] + list(tensors[0].shape[:-2]) + list(max_size)\\r\\n device = (\\r\\n None if torch.jit.is_scripting() else (\\\"cpu\\\" if torch.jit.is_tracing() else None)\\r\\n )\\r\\n batched_imgs = tensors[0].new_full(batch_shape, pad_value, device=device)\\r\\n batched_imgs = move_device_like(batched_imgs, tensors[0])\\r\\n for i, img in enumerate(tensors):\\r\\n # Use `batched_imgs` directly instead of `img, pad_img = zip(tensors, batched_imgs)`\\r\\n # Tracing mode cannot capture `copy_()` of temporary locals\\r\\n batched_imgs[i, ..., : img.shape[-2], : img.shape[-1]].copy_(img)\\r\\n\\r\\n return ImageList(batched_imgs.contiguous(), image_sizes)\\r\"\n },\n {\n \"identifier\": \"Instances\",\n \"path\": \"annotator/oneformer/detectron2/structures/instances.py\",\n \"snippet\": \"class Instances:\\r\\n \\\"\\\"\\\"\\r\\n This class represents a list of instances in an image.\\r\\n It stores the attributes of instances (e.g., boxes, masks, labels, scores) as \\\"fields\\\".\\r\\n All fields must have the same ``__len__`` which is the number of instances.\\r\\n\\r\\n All other (non-field) attributes of this class are considered private:\\r\\n they must start with '_' and are not modifiable by a user.\\r\\n\\r\\n Some basic usage:\\r\\n\\r\\n 1. Set/get/check a field:\\r\\n\\r\\n .. code-block:: python\\r\\n\\r\\n instances.gt_boxes = Boxes(...)\\r\\n print(instances.pred_masks) # a tensor of shape (N, H, W)\\r\\n print('gt_masks' in instances)\\r\\n\\r\\n 2. ``len(instances)`` returns the number of instances\\r\\n 3. Indexing: ``instances[indices]`` will apply the indexing on all the fields\\r\\n and returns a new :class:`Instances`.\\r\\n Typically, ``indices`` is a integer vector of indices,\\r\\n or a binary mask of length ``num_instances``\\r\\n\\r\\n .. code-block:: python\\r\\n\\r\\n category_3_detections = instances[instances.pred_classes == 3]\\r\\n confident_detections = instances[instances.scores > 0.9]\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(self, image_size: Tuple[int, int], **kwargs: Any):\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n image_size (height, width): the spatial size of the image.\\r\\n kwargs: fields to add to this `Instances`.\\r\\n \\\"\\\"\\\"\\r\\n self._image_size = image_size\\r\\n self._fields: Dict[str, Any] = {}\\r\\n for k, v in kwargs.items():\\r\\n self.set(k, v)\\r\\n\\r\\n @property\\r\\n def image_size(self) -> Tuple[int, int]:\\r\\n \\\"\\\"\\\"\\r\\n Returns:\\r\\n tuple: height, width\\r\\n \\\"\\\"\\\"\\r\\n return self._image_size\\r\\n\\r\\n def __setattr__(self, name: str, val: Any) -> None:\\r\\n if name.startswith(\\\"_\\\"):\\r\\n super().__setattr__(name, val)\\r\\n else:\\r\\n self.set(name, val)\\r\\n\\r\\n def __getattr__(self, name: str) -> Any:\\r\\n if name == \\\"_fields\\\" or name not in self._fields:\\r\\n raise AttributeError(\\\"Cannot find field '{}' in the given Instances!\\\".format(name))\\r\\n return self._fields[name]\\r\\n\\r\\n def set(self, name: str, value: Any) -> None:\\r\\n \\\"\\\"\\\"\\r\\n Set the field named `name` to `value`.\\r\\n The length of `value` must be the number of instances,\\r\\n and must agree with other existing fields in this object.\\r\\n \\\"\\\"\\\"\\r\\n with warnings.catch_warnings(record=True):\\r\\n data_len = len(value)\\r\\n if len(self._fields):\\r\\n assert (\\r\\n len(self) == data_len\\r\\n ), \\\"Adding a field of length {} to a Instances of length {}\\\".format(data_len, len(self))\\r\\n self._fields[name] = value\\r\\n\\r\\n def has(self, name: str) -> bool:\\r\\n \\\"\\\"\\\"\\r\\n Returns:\\r\\n bool: whether the field called `name` exists.\\r\\n \\\"\\\"\\\"\\r\\n return name in self._fields\\r\\n\\r\\n def remove(self, name: str) -> None:\\r\\n \\\"\\\"\\\"\\r\\n Remove the field called `name`.\\r\\n \\\"\\\"\\\"\\r\\n del self._fields[name]\\r\\n\\r\\n def get(self, name: str) -> Any:\\r\\n \\\"\\\"\\\"\\r\\n Returns the field called `name`.\\r\\n \\\"\\\"\\\"\\r\\n return self._fields[name]\\r\\n\\r\\n def get_fields(self) -> Dict[str, Any]:\\r\\n \\\"\\\"\\\"\\r\\n Returns:\\r\\n dict: a dict which maps names (str) to data of the fields\\r\\n\\r\\n Modifying the returned dict will modify this instance.\\r\\n \\\"\\\"\\\"\\r\\n return self._fields\\r\\n\\r\\n # Tensor-like methods\\r\\n def to(self, *args: Any, **kwargs: Any) -> \\\"Instances\\\":\\r\\n \\\"\\\"\\\"\\r\\n Returns:\\r\\n Instances: all fields are called with a `to(device)`, if the field has this method.\\r\\n \\\"\\\"\\\"\\r\\n ret = Instances(self._image_size)\\r\\n for k, v in self._fields.items():\\r\\n if hasattr(v, \\\"to\\\"):\\r\\n v = v.to(*args, **kwargs)\\r\\n ret.set(k, v)\\r\\n return ret\\r\\n\\r\\n def __getitem__(self, item: Union[int, slice, torch.BoolTensor]) -> \\\"Instances\\\":\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n item: an index-like object and will be used to index all the fields.\\r\\n\\r\\n Returns:\\r\\n If `item` is a string, return the data in the corresponding field.\\r\\n Otherwise, returns an `Instances` where all fields are indexed by `item`.\\r\\n \\\"\\\"\\\"\\r\\n if type(item) == int:\\r\\n if item >= len(self) or item < -len(self):\\r\\n raise IndexError(\\\"Instances index out of range!\\\")\\r\\n else:\\r\\n item = slice(item, None, len(self))\\r\\n\\r\\n ret = Instances(self._image_size)\\r\\n for k, v in self._fields.items():\\r\\n ret.set(k, v[item])\\r\\n return ret\\r\\n\\r\\n def __len__(self) -> int:\\r\\n for v in self._fields.values():\\r\\n # use __len__ because len() has to be int and is not friendly to tracing\\r\\n return v.__len__()\\r\\n raise NotImplementedError(\\\"Empty Instances does not support __len__!\\\")\\r\\n\\r\\n def __iter__(self):\\r\\n raise NotImplementedError(\\\"`Instances` object is not iterable!\\\")\\r\\n\\r\\n @staticmethod\\r\\n def cat(instance_lists: List[\\\"Instances\\\"]) -> \\\"Instances\\\":\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n instance_lists (list[Instances])\\r\\n\\r\\n Returns:\\r\\n Instances\\r\\n \\\"\\\"\\\"\\r\\n assert all(isinstance(i, Instances) for i in instance_lists)\\r\\n assert len(instance_lists) > 0\\r\\n if len(instance_lists) == 1:\\r\\n return instance_lists[0]\\r\\n\\r\\n image_size = instance_lists[0].image_size\\r\\n if not isinstance(image_size, torch.Tensor): # could be a tensor in tracing\\r\\n for i in instance_lists[1:]:\\r\\n assert i.image_size == image_size\\r\\n ret = Instances(image_size)\\r\\n for k in instance_lists[0]._fields.keys():\\r\\n values = [i.get(k) for i in instance_lists]\\r\\n v0 = values[0]\\r\\n if isinstance(v0, torch.Tensor):\\r\\n values = torch.cat(values, dim=0)\\r\\n elif isinstance(v0, list):\\r\\n values = list(itertools.chain(*values))\\r\\n elif hasattr(type(v0), \\\"cat\\\"):\\r\\n values = type(v0).cat(values)\\r\\n else:\\r\\n raise ValueError(\\\"Unsupported type {} for concatenation\\\".format(type(v0)))\\r\\n ret.set(k, values)\\r\\n return ret\\r\\n\\r\\n def __str__(self) -> str:\\r\\n s = self.__class__.__name__ + \\\"(\\\"\\r\\n s += \\\"num_instances={}, \\\".format(len(self))\\r\\n s += \\\"image_height={}, \\\".format(self._image_size[0])\\r\\n s += \\\"image_width={}, \\\".format(self._image_size[1])\\r\\n s += \\\"fields=[{}])\\\".format(\\\", \\\".join((f\\\"{k}: {v}\\\" for k, v in self._fields.items())))\\r\\n return s\\r\\n\\r\\n __repr__ = __str__\\r\"\n },\n {\n \"identifier\": \"get_event_storage\",\n \"path\": \"annotator/oneformer/detectron2/utils/events.py\",\n \"snippet\": \"def get_event_storage():\\r\\n \\\"\\\"\\\"\\r\\n Returns:\\r\\n The :class:`EventStorage` object that's currently being used.\\r\\n Throws an error if no :class:`EventStorage` is currently enabled.\\r\\n \\\"\\\"\\\"\\r\\n assert len(\\r\\n _CURRENT_STORAGE_STACK\\r\\n ), \\\"get_event_storage() has to be called inside a 'with EventStorage(...)' context!\\\"\\r\\n return _CURRENT_STORAGE_STACK[-1]\\r\"\n },\n {\n \"identifier\": \"build_anchor_generator\",\n \"path\": \"annotator/oneformer/detectron2/modeling/anchor_generator.py\",\n \"snippet\": \"def build_anchor_generator(cfg, input_shape):\\r\\n \\\"\\\"\\\"\\r\\n Built an anchor generator from `cfg.MODEL.ANCHOR_GENERATOR.NAME`.\\r\\n \\\"\\\"\\\"\\r\\n anchor_generator = cfg.MODEL.ANCHOR_GENERATOR.NAME\\r\\n return ANCHOR_GENERATOR_REGISTRY.get(anchor_generator)(cfg, input_shape)\\r\"\n },\n {\n \"identifier\": \"build_backbone\",\n \"path\": \"annotator/oneformer/detectron2/modeling/backbone/build.py\",\n \"snippet\": \"def build_backbone(cfg, input_shape=None):\\r\\n \\\"\\\"\\\"\\r\\n Build a backbone from `cfg.MODEL.BACKBONE.NAME`.\\r\\n\\r\\n Returns:\\r\\n an instance of :class:`Backbone`\\r\\n \\\"\\\"\\\"\\r\\n if input_shape is None:\\r\\n input_shape = ShapeSpec(channels=len(cfg.MODEL.PIXEL_MEAN))\\r\\n\\r\\n backbone_name = cfg.MODEL.BACKBONE.NAME\\r\\n backbone = BACKBONE_REGISTRY.get(backbone_name)(cfg, input_shape)\\r\\n assert isinstance(backbone, Backbone)\\r\\n return backbone\\r\"\n },\n {\n \"identifier\": \"Backbone\",\n \"path\": \"annotator/oneformer/detectron2/modeling/backbone/backbone.py\",\n \"snippet\": \"class Backbone(nn.Module, metaclass=ABCMeta):\\r\\n \\\"\\\"\\\"\\r\\n Abstract base class for network backbones.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(self):\\r\\n \\\"\\\"\\\"\\r\\n The `__init__` method of any subclass can specify its own set of arguments.\\r\\n \\\"\\\"\\\"\\r\\n super().__init__()\\r\\n\\r\\n @abstractmethod\\r\\n def forward(self):\\r\\n \\\"\\\"\\\"\\r\\n Subclasses must override this method, but adhere to the same return type.\\r\\n\\r\\n Returns:\\r\\n dict[str->Tensor]: mapping from feature name (e.g., \\\"res2\\\") to tensor\\r\\n \\\"\\\"\\\"\\r\\n pass\\r\\n\\r\\n @property\\r\\n def size_divisibility(self) -> int:\\r\\n \\\"\\\"\\\"\\r\\n Some backbones require the input height and width to be divisible by a\\r\\n specific integer. This is typically true for encoder / decoder type networks\\r\\n with lateral connection (e.g., FPN) for which feature maps need to match\\r\\n dimension in the \\\"bottom up\\\" and \\\"top down\\\" paths. Set to 0 if no specific\\r\\n input size divisibility is required.\\r\\n \\\"\\\"\\\"\\r\\n return 0\\r\\n\\r\\n @property\\r\\n def padding_constraints(self) -> Dict[str, int]:\\r\\n \\\"\\\"\\\"\\r\\n This property is a generalization of size_divisibility. Some backbones and training\\r\\n recipes require specific padding constraints, such as enforcing divisibility by a specific\\r\\n integer (e.g., FPN) or padding to a square (e.g., ViTDet with large-scale jitter\\r\\n in :paper:vitdet). `padding_constraints` contains these optional items like:\\r\\n {\\r\\n \\\"size_divisibility\\\": int,\\r\\n \\\"square_size\\\": int,\\r\\n # Future options are possible\\r\\n }\\r\\n `size_divisibility` will read from here if presented and `square_size` indicates the\\r\\n square padding size if `square_size` > 0.\\r\\n\\r\\n TODO: use type of Dict[str, int] to avoid torchscipt issues. The type of padding_constraints\\r\\n could be generalized as TypedDict (Python 3.8+) to support more types in the future.\\r\\n \\\"\\\"\\\"\\r\\n return {}\\r\\n\\r\\n def output_shape(self):\\r\\n \\\"\\\"\\\"\\r\\n Returns:\\r\\n dict[str->ShapeSpec]\\r\\n \\\"\\\"\\\"\\r\\n # this is a backward-compatible default\\r\\n return {\\r\\n name: ShapeSpec(\\r\\n channels=self._out_feature_channels[name], stride=self._out_feature_strides[name]\\r\\n )\\r\\n for name in self._out_features\\r\\n }\\r\"\n },\n {\n \"identifier\": \"Box2BoxTransform\",\n \"path\": \"annotator/oneformer/detectron2/modeling/box_regression.py\",\n \"snippet\": \"class Box2BoxTransform(object):\\r\\n \\\"\\\"\\\"\\r\\n The box-to-box transform defined in R-CNN. The transformation is parameterized\\r\\n by 4 deltas: (dx, dy, dw, dh). The transformation scales the box's width and height\\r\\n by exp(dw), exp(dh) and shifts a box's center by the offset (dx * width, dy * height).\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(\\r\\n self, weights: Tuple[float, float, float, float], scale_clamp: float = _DEFAULT_SCALE_CLAMP\\r\\n ):\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n weights (4-element tuple): Scaling factors that are applied to the\\r\\n (dx, dy, dw, dh) deltas. In Fast R-CNN, these were originally set\\r\\n such that the deltas have unit variance; now they are treated as\\r\\n hyperparameters of the system.\\r\\n scale_clamp (float): When predicting deltas, the predicted box scaling\\r\\n factors (dw and dh) are clamped such that they are <= scale_clamp.\\r\\n \\\"\\\"\\\"\\r\\n self.weights = weights\\r\\n self.scale_clamp = scale_clamp\\r\\n\\r\\n def get_deltas(self, src_boxes, target_boxes):\\r\\n \\\"\\\"\\\"\\r\\n Get box regression transformation deltas (dx, dy, dw, dh) that can be used\\r\\n to transform the `src_boxes` into the `target_boxes`. That is, the relation\\r\\n ``target_boxes == self.apply_deltas(deltas, src_boxes)`` is true (unless\\r\\n any delta is too large and is clamped).\\r\\n\\r\\n Args:\\r\\n src_boxes (Tensor): source boxes, e.g., object proposals\\r\\n target_boxes (Tensor): target of the transformation, e.g., ground-truth\\r\\n boxes.\\r\\n \\\"\\\"\\\"\\r\\n assert isinstance(src_boxes, torch.Tensor), type(src_boxes)\\r\\n assert isinstance(target_boxes, torch.Tensor), type(target_boxes)\\r\\n\\r\\n src_widths = src_boxes[:, 2] - src_boxes[:, 0]\\r\\n src_heights = src_boxes[:, 3] - src_boxes[:, 1]\\r\\n src_ctr_x = src_boxes[:, 0] + 0.5 * src_widths\\r\\n src_ctr_y = src_boxes[:, 1] + 0.5 * src_heights\\r\\n\\r\\n target_widths = target_boxes[:, 2] - target_boxes[:, 0]\\r\\n target_heights = target_boxes[:, 3] - target_boxes[:, 1]\\r\\n target_ctr_x = target_boxes[:, 0] + 0.5 * target_widths\\r\\n target_ctr_y = target_boxes[:, 1] + 0.5 * target_heights\\r\\n\\r\\n wx, wy, ww, wh = self.weights\\r\\n dx = wx * (target_ctr_x - src_ctr_x) / src_widths\\r\\n dy = wy * (target_ctr_y - src_ctr_y) / src_heights\\r\\n dw = ww * torch.log(target_widths / src_widths)\\r\\n dh = wh * torch.log(target_heights / src_heights)\\r\\n\\r\\n deltas = torch.stack((dx, dy, dw, dh), dim=1)\\r\\n assert (src_widths > 0).all().item(), \\\"Input boxes to Box2BoxTransform are not valid!\\\"\\r\\n return deltas\\r\\n\\r\\n def apply_deltas(self, deltas, boxes):\\r\\n \\\"\\\"\\\"\\r\\n Apply transformation `deltas` (dx, dy, dw, dh) to `boxes`.\\r\\n\\r\\n Args:\\r\\n deltas (Tensor): transformation deltas of shape (N, k*4), where k >= 1.\\r\\n deltas[i] represents k potentially different class-specific\\r\\n box transformations for the single box boxes[i].\\r\\n boxes (Tensor): boxes to transform, of shape (N, 4)\\r\\n \\\"\\\"\\\"\\r\\n deltas = deltas.float() # ensure fp32 for decoding precision\\r\\n boxes = boxes.to(deltas.dtype)\\r\\n\\r\\n widths = boxes[:, 2] - boxes[:, 0]\\r\\n heights = boxes[:, 3] - boxes[:, 1]\\r\\n ctr_x = boxes[:, 0] + 0.5 * widths\\r\\n ctr_y = boxes[:, 1] + 0.5 * heights\\r\\n\\r\\n wx, wy, ww, wh = self.weights\\r\\n dx = deltas[:, 0::4] / wx\\r\\n dy = deltas[:, 1::4] / wy\\r\\n dw = deltas[:, 2::4] / ww\\r\\n dh = deltas[:, 3::4] / wh\\r\\n\\r\\n # Prevent sending too large values into torch.exp()\\r\\n dw = torch.clamp(dw, max=self.scale_clamp)\\r\\n dh = torch.clamp(dh, max=self.scale_clamp)\\r\\n\\r\\n pred_ctr_x = dx * widths[:, None] + ctr_x[:, None]\\r\\n pred_ctr_y = dy * heights[:, None] + ctr_y[:, None]\\r\\n pred_w = torch.exp(dw) * widths[:, None]\\r\\n pred_h = torch.exp(dh) * heights[:, None]\\r\\n\\r\\n x1 = pred_ctr_x - 0.5 * pred_w\\r\\n y1 = pred_ctr_y - 0.5 * pred_h\\r\\n x2 = pred_ctr_x + 0.5 * pred_w\\r\\n y2 = pred_ctr_y + 0.5 * pred_h\\r\\n pred_boxes = torch.stack((x1, y1, x2, y2), dim=-1)\\r\\n return pred_boxes.reshape(deltas.shape)\\r\"\n },\n {\n \"identifier\": \"_dense_box_regression_loss\",\n \"path\": \"annotator/oneformer/detectron2/modeling/box_regression.py\",\n \"snippet\": \"def _dense_box_regression_loss(\\r\\n anchors: List[Union[Boxes, torch.Tensor]],\\r\\n box2box_transform: Box2BoxTransform,\\r\\n pred_anchor_deltas: List[torch.Tensor],\\r\\n gt_boxes: List[torch.Tensor],\\r\\n fg_mask: torch.Tensor,\\r\\n box_reg_loss_type=\\\"smooth_l1\\\",\\r\\n smooth_l1_beta=0.0,\\r\\n):\\r\\n \\\"\\\"\\\"\\r\\n Compute loss for dense multi-level box regression.\\r\\n Loss is accumulated over ``fg_mask``.\\r\\n\\r\\n Args:\\r\\n anchors: #lvl anchor boxes, each is (HixWixA, 4)\\r\\n pred_anchor_deltas: #lvl predictions, each is (N, HixWixA, 4)\\r\\n gt_boxes: N ground truth boxes, each has shape (R, 4) (R = sum(Hi * Wi * A))\\r\\n fg_mask: the foreground boolean mask of shape (N, R) to compute loss on\\r\\n box_reg_loss_type (str): Loss type to use. Supported losses: \\\"smooth_l1\\\", \\\"giou\\\",\\r\\n \\\"diou\\\", \\\"ciou\\\".\\r\\n smooth_l1_beta (float): beta parameter for the smooth L1 regression loss. Default to\\r\\n use L1 loss. Only used when `box_reg_loss_type` is \\\"smooth_l1\\\"\\r\\n \\\"\\\"\\\"\\r\\n if isinstance(anchors[0], Boxes):\\r\\n anchors = type(anchors[0]).cat(anchors).tensor # (R, 4)\\r\\n else:\\r\\n anchors = cat(anchors)\\r\\n if box_reg_loss_type == \\\"smooth_l1\\\":\\r\\n gt_anchor_deltas = [box2box_transform.get_deltas(anchors, k) for k in gt_boxes]\\r\\n gt_anchor_deltas = torch.stack(gt_anchor_deltas) # (N, R, 4)\\r\\n loss_box_reg = smooth_l1_loss(\\r\\n cat(pred_anchor_deltas, dim=1)[fg_mask],\\r\\n gt_anchor_deltas[fg_mask],\\r\\n beta=smooth_l1_beta,\\r\\n reduction=\\\"sum\\\",\\r\\n )\\r\\n elif box_reg_loss_type == \\\"giou\\\":\\r\\n pred_boxes = [\\r\\n box2box_transform.apply_deltas(k, anchors) for k in cat(pred_anchor_deltas, dim=1)\\r\\n ]\\r\\n loss_box_reg = giou_loss(\\r\\n torch.stack(pred_boxes)[fg_mask], torch.stack(gt_boxes)[fg_mask], reduction=\\\"sum\\\"\\r\\n )\\r\\n elif box_reg_loss_type == \\\"diou\\\":\\r\\n pred_boxes = [\\r\\n box2box_transform.apply_deltas(k, anchors) for k in cat(pred_anchor_deltas, dim=1)\\r\\n ]\\r\\n loss_box_reg = diou_loss(\\r\\n torch.stack(pred_boxes)[fg_mask], torch.stack(gt_boxes)[fg_mask], reduction=\\\"sum\\\"\\r\\n )\\r\\n elif box_reg_loss_type == \\\"ciou\\\":\\r\\n pred_boxes = [\\r\\n box2box_transform.apply_deltas(k, anchors) for k in cat(pred_anchor_deltas, dim=1)\\r\\n ]\\r\\n loss_box_reg = ciou_loss(\\r\\n torch.stack(pred_boxes)[fg_mask], torch.stack(gt_boxes)[fg_mask], reduction=\\\"sum\\\"\\r\\n )\\r\\n else:\\r\\n raise ValueError(f\\\"Invalid dense box regression loss type '{box_reg_loss_type}'\\\")\\r\\n return loss_box_reg\\r\"\n },\n {\n \"identifier\": \"Matcher\",\n \"path\": \"annotator/oneformer/detectron2/modeling/matcher.py\",\n \"snippet\": \"class Matcher(object):\\r\\n \\\"\\\"\\\"\\r\\n This class assigns to each predicted \\\"element\\\" (e.g., a box) a ground-truth\\r\\n element. Each predicted element will have exactly zero or one matches; each\\r\\n ground-truth element may be matched to zero or more predicted elements.\\r\\n\\r\\n The matching is determined by the MxN match_quality_matrix, that characterizes\\r\\n how well each (ground-truth, prediction)-pair match each other. For example,\\r\\n if the elements are boxes, this matrix may contain box intersection-over-union\\r\\n overlap values.\\r\\n\\r\\n The matcher returns (a) a vector of length N containing the index of the\\r\\n ground-truth element m in [0, M) that matches to prediction n in [0, N).\\r\\n (b) a vector of length N containing the labels for each prediction.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(\\r\\n self, thresholds: List[float], labels: List[int], allow_low_quality_matches: bool = False\\r\\n ):\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n thresholds (list): a list of thresholds used to stratify predictions\\r\\n into levels.\\r\\n labels (list): a list of values to label predictions belonging at\\r\\n each level. A label can be one of {-1, 0, 1} signifying\\r\\n {ignore, negative class, positive class}, respectively.\\r\\n allow_low_quality_matches (bool): if True, produce additional matches\\r\\n for predictions with maximum match quality lower than high_threshold.\\r\\n See set_low_quality_matches_ for more details.\\r\\n\\r\\n For example,\\r\\n thresholds = [0.3, 0.5]\\r\\n labels = [0, -1, 1]\\r\\n All predictions with iou < 0.3 will be marked with 0 and\\r\\n thus will be considered as false positives while training.\\r\\n All predictions with 0.3 <= iou < 0.5 will be marked with -1 and\\r\\n thus will be ignored.\\r\\n All predictions with 0.5 <= iou will be marked with 1 and\\r\\n thus will be considered as true positives.\\r\\n \\\"\\\"\\\"\\r\\n # Add -inf and +inf to first and last position in thresholds\\r\\n thresholds = thresholds[:]\\r\\n assert thresholds[0] > 0\\r\\n thresholds.insert(0, -float(\\\"inf\\\"))\\r\\n thresholds.append(float(\\\"inf\\\"))\\r\\n # Currently torchscript does not support all + generator\\r\\n assert all([low <= high for (low, high) in zip(thresholds[:-1], thresholds[1:])])\\r\\n assert all([l in [-1, 0, 1] for l in labels])\\r\\n assert len(labels) == len(thresholds) - 1\\r\\n self.thresholds = thresholds\\r\\n self.labels = labels\\r\\n self.allow_low_quality_matches = allow_low_quality_matches\\r\\n\\r\\n def __call__(self, match_quality_matrix):\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n match_quality_matrix (Tensor[float]): an MxN tensor, containing the\\r\\n pairwise quality between M ground-truth elements and N predicted\\r\\n elements. All elements must be >= 0 (due to the us of `torch.nonzero`\\r\\n for selecting indices in :meth:`set_low_quality_matches_`).\\r\\n\\r\\n Returns:\\r\\n matches (Tensor[int64]): a vector of length N, where matches[i] is a matched\\r\\n ground-truth index in [0, M)\\r\\n match_labels (Tensor[int8]): a vector of length N, where pred_labels[i] indicates\\r\\n whether a prediction is a true or false positive or ignored\\r\\n \\\"\\\"\\\"\\r\\n assert match_quality_matrix.dim() == 2\\r\\n if match_quality_matrix.numel() == 0:\\r\\n default_matches = match_quality_matrix.new_full(\\r\\n (match_quality_matrix.size(1),), 0, dtype=torch.int64\\r\\n )\\r\\n # When no gt boxes exist, we define IOU = 0 and therefore set labels\\r\\n # to `self.labels[0]`, which usually defaults to background class 0\\r\\n # To choose to ignore instead, can make labels=[-1,0,-1,1] + set appropriate thresholds\\r\\n default_match_labels = match_quality_matrix.new_full(\\r\\n (match_quality_matrix.size(1),), self.labels[0], dtype=torch.int8\\r\\n )\\r\\n return default_matches, default_match_labels\\r\\n\\r\\n assert torch.all(match_quality_matrix >= 0)\\r\\n\\r\\n # match_quality_matrix is M (gt) x N (predicted)\\r\\n # Max over gt elements (dim 0) to find best gt candidate for each prediction\\r\\n matched_vals, matches = match_quality_matrix.max(dim=0)\\r\\n\\r\\n match_labels = matches.new_full(matches.size(), 1, dtype=torch.int8)\\r\\n\\r\\n for (l, low, high) in zip(self.labels, self.thresholds[:-1], self.thresholds[1:]):\\r\\n low_high = (matched_vals >= low) & (matched_vals < high)\\r\\n match_labels[low_high] = l\\r\\n\\r\\n if self.allow_low_quality_matches:\\r\\n self.set_low_quality_matches_(match_labels, match_quality_matrix)\\r\\n\\r\\n return matches, match_labels\\r\\n\\r\\n def set_low_quality_matches_(self, match_labels, match_quality_matrix):\\r\\n \\\"\\\"\\\"\\r\\n Produce additional matches for predictions that have only low-quality matches.\\r\\n Specifically, for each ground-truth G find the set of predictions that have\\r\\n maximum overlap with it (including ties); for each prediction in that set, if\\r\\n it is unmatched, then match it to the ground-truth G.\\r\\n\\r\\n This function implements the RPN assignment case (i) in Sec. 3.1.2 of\\r\\n :paper:`Faster R-CNN`.\\r\\n \\\"\\\"\\\"\\r\\n # For each gt, find the prediction with which it has highest quality\\r\\n highest_quality_foreach_gt, _ = match_quality_matrix.max(dim=1)\\r\\n # Find the highest quality match available, even if it is low, including ties.\\r\\n # Note that the matches qualities must be positive due to the use of\\r\\n # `torch.nonzero`.\\r\\n _, pred_inds_with_highest_quality = nonzero_tuple(\\r\\n match_quality_matrix == highest_quality_foreach_gt[:, None]\\r\\n )\\r\\n # If an anchor was labeled positive only due to a low-quality match\\r\\n # with gt_A, but it has larger overlap with gt_B, it's matched index will still be gt_B.\\r\\n # This follows the implementation in Detectron, and is found to have no significant impact.\\r\\n match_labels[pred_inds_with_highest_quality] = 1\\r\"\n },\n {\n \"identifier\": \"META_ARCH_REGISTRY\",\n \"path\": \"annotator/oneformer/detectron2/modeling/meta_arch/build.py\",\n \"snippet\": \"META_ARCH_REGISTRY = Registry(\\\"META_ARCH\\\") # noqa F401 isort:skip\\r\"\n },\n {\n \"identifier\": \"DenseDetector\",\n \"path\": \"annotator/oneformer/detectron2/modeling/meta_arch/dense_detector.py\",\n \"snippet\": \"class DenseDetector(nn.Module):\\r\\n \\\"\\\"\\\"\\r\\n Base class for dense detector. We define a dense detector as a fully-convolutional model that\\r\\n makes per-pixel (i.e. dense) predictions.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(\\r\\n self,\\r\\n backbone: Backbone,\\r\\n head: nn.Module,\\r\\n head_in_features: Optional[List[str]] = None,\\r\\n *,\\r\\n pixel_mean,\\r\\n pixel_std,\\r\\n ):\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n backbone: backbone module\\r\\n head: head module\\r\\n head_in_features: backbone features to use in head. Default to all backbone features.\\r\\n pixel_mean (Tuple[float]):\\r\\n Values to be used for image normalization (BGR order).\\r\\n To train on images of different number of channels, set different mean & std.\\r\\n Default values are the mean pixel value from ImageNet: [103.53, 116.28, 123.675]\\r\\n pixel_std (Tuple[float]):\\r\\n When using pre-trained models in Detectron1 or any MSRA models,\\r\\n std has been absorbed into its conv1 weights, so the std needs to be set 1.\\r\\n Otherwise, you can use [57.375, 57.120, 58.395] (ImageNet std)\\r\\n \\\"\\\"\\\"\\r\\n super().__init__()\\r\\n\\r\\n self.backbone = backbone\\r\\n self.head = head\\r\\n if head_in_features is None:\\r\\n shapes = self.backbone.output_shape()\\r\\n self.head_in_features = sorted(shapes.keys(), key=lambda x: shapes[x].stride)\\r\\n else:\\r\\n self.head_in_features = head_in_features\\r\\n self.register_buffer(\\\"pixel_mean\\\", torch.tensor(pixel_mean).view(-1, 1, 1), False)\\r\\n self.register_buffer(\\\"pixel_std\\\", torch.tensor(pixel_std).view(-1, 1, 1), False)\\r\\n\\r\\n @property\\r\\n def device(self):\\r\\n return self.pixel_mean.device\\r\\n\\r\\n def _move_to_current_device(self, x):\\r\\n return move_device_like(x, self.pixel_mean)\\r\\n\\r\\n def forward(self, batched_inputs: List[Dict[str, Tensor]]):\\r\\n \\\"\\\"\\\"\\r\\n Args:\\r\\n batched_inputs: a list, batched outputs of :class:`DatasetMapper` .\\r\\n Each item in the list contains the inputs for one image.\\r\\n For now, each item in the list is a dict that contains:\\r\\n\\r\\n * image: Tensor, image in (C, H, W) format.\\r\\n * instances: Instances\\r\\n\\r\\n Other information that's included in the original dicts, such as:\\r\\n\\r\\n * \\\"height\\\", \\\"width\\\" (int): the output resolution of the model, used in inference.\\r\\n See :meth:`postprocess` for details.\\r\\n\\r\\n Returns:\\r\\n In training, dict[str, Tensor]: mapping from a named loss to a tensor storing the\\r\\n loss. Used during training only. In inference, the standard output format, described\\r\\n in :doc:`/tutorials/models`.\\r\\n \\\"\\\"\\\"\\r\\n images = self.preprocess_image(batched_inputs)\\r\\n features = self.backbone(images.tensor)\\r\\n features = [features[f] for f in self.head_in_features]\\r\\n predictions = self.head(features)\\r\\n\\r\\n if self.training:\\r\\n assert not torch.jit.is_scripting(), \\\"Not supported\\\"\\r\\n assert \\\"instances\\\" in batched_inputs[0], \\\"Instance annotations are missing in training!\\\"\\r\\n gt_instances = [x[\\\"instances\\\"].to(self.device) for x in batched_inputs]\\r\\n return self.forward_training(images, features, predictions, gt_instances)\\r\\n else:\\r\\n results = self.forward_inference(images, features, predictions)\\r\\n if torch.jit.is_scripting():\\r\\n return results\\r\\n\\r\\n processed_results = []\\r\\n for results_per_image, input_per_image, image_size in zip(\\r\\n results, batched_inputs, images.image_sizes\\r\\n ):\\r\\n height = input_per_image.get(\\\"height\\\", image_size[0])\\r\\n width = input_per_image.get(\\\"width\\\", image_size[1])\\r\\n r = detector_postprocess(results_per_image, height, width)\\r\\n processed_results.append({\\\"instances\\\": r})\\r\\n return processed_results\\r\\n\\r\\n def forward_training(self, images, features, predictions, gt_instances):\\r\\n raise NotImplementedError()\\r\\n\\r\\n def preprocess_image(self, batched_inputs: List[Dict[str, Tensor]]):\\r\\n \\\"\\\"\\\"\\r\\n Normalize, pad and batch the input images.\\r\\n \\\"\\\"\\\"\\r\\n images = [self._move_to_current_device(x[\\\"image\\\"]) for x in batched_inputs]\\r\\n images = [(x - self.pixel_mean) / self.pixel_std for x in images]\\r\\n images = ImageList.from_tensors(\\r\\n images,\\r\\n self.backbone.size_divisibility,\\r\\n padding_constraints=self.backbone.padding_constraints,\\r\\n )\\r\\n return images\\r\\n\\r\\n def _transpose_dense_predictions(\\r\\n self, predictions: List[List[Tensor]], dims_per_anchor: List[int]\\r\\n ) -> List[List[Tensor]]:\\r\\n \\\"\\\"\\\"\\r\\n Transpose the dense per-level predictions.\\r\\n\\r\\n Args:\\r\\n predictions: a list of outputs, each is a list of per-level\\r\\n predictions with shape (N, Ai x K, Hi, Wi), where N is the\\r\\n number of images, Ai is the number of anchors per location on\\r\\n level i, K is the dimension of predictions per anchor.\\r\\n dims_per_anchor: the value of K for each predictions. e.g. 4 for\\r\\n box prediction, #classes for classification prediction.\\r\\n\\r\\n Returns:\\r\\n List[List[Tensor]]: each prediction is transposed to (N, Hi x Wi x Ai, K).\\r\\n \\\"\\\"\\\"\\r\\n assert len(predictions) == len(dims_per_anchor)\\r\\n res: List[List[Tensor]] = []\\r\\n for pred, dim_per_anchor in zip(predictions, dims_per_anchor):\\r\\n pred = [permute_to_N_HWA_K(x, dim_per_anchor) for x in pred]\\r\\n res.append(pred)\\r\\n return res\\r\\n\\r\\n def _ema_update(self, name: str, value: float, initial_value: float, momentum: float = 0.9):\\r\\n \\\"\\\"\\\"\\r\\n Apply EMA update to `self.name` using `value`.\\r\\n\\r\\n This is mainly used for loss normalizer. In Detectron1, loss is normalized by number\\r\\n of foreground samples in the batch. When batch size is 1 per GPU, #foreground has a\\r\\n large variance and using it lead to lower performance. Therefore we maintain an EMA of\\r\\n #foreground to stabilize the normalizer.\\r\\n\\r\\n Args:\\r\\n name: name of the normalizer\\r\\n value: the new value to update\\r\\n initial_value: the initial value to start with\\r\\n momentum: momentum of EMA\\r\\n\\r\\n Returns:\\r\\n float: the updated EMA value\\r\\n \\\"\\\"\\\"\\r\\n if hasattr(self, name):\\r\\n old = getattr(self, name)\\r\\n else:\\r\\n old = initial_value\\r\\n new = old * momentum + value * (1 - momentum)\\r\\n setattr(self, name, new)\\r\\n return new\\r\\n\\r\\n def _decode_per_level_predictions(\\r\\n self,\\r\\n anchors: Boxes,\\r\\n pred_scores: Tensor,\\r\\n pred_deltas: Tensor,\\r\\n score_thresh: float,\\r\\n topk_candidates: int,\\r\\n image_size: Tuple[int, int],\\r\\n ) -> Instances:\\r\\n \\\"\\\"\\\"\\r\\n Decode boxes and classification predictions of one featuer level, by\\r\\n the following steps:\\r\\n 1. filter the predictions based on score threshold and top K scores.\\r\\n 2. transform the box regression outputs\\r\\n 3. return the predicted scores, classes and boxes\\r\\n\\r\\n Args:\\r\\n anchors: Boxes, anchor for this feature level\\r\\n pred_scores: HxWxA,K\\r\\n pred_deltas: HxWxA,4\\r\\n\\r\\n Returns:\\r\\n Instances: with field \\\"scores\\\", \\\"pred_boxes\\\", \\\"pred_classes\\\".\\r\\n \\\"\\\"\\\"\\r\\n # Apply two filtering to make NMS faster.\\r\\n # 1. Keep boxes with confidence score higher than threshold\\r\\n keep_idxs = pred_scores > score_thresh\\r\\n pred_scores = pred_scores[keep_idxs]\\r\\n topk_idxs = torch.nonzero(keep_idxs) # Kx2\\r\\n\\r\\n # 2. Keep top k top scoring boxes only\\r\\n topk_idxs_size = topk_idxs.shape[0]\\r\\n if isinstance(topk_idxs_size, Tensor):\\r\\n # It's a tensor in tracing\\r\\n num_topk = torch.clamp(topk_idxs_size, max=topk_candidates)\\r\\n else:\\r\\n num_topk = min(topk_idxs_size, topk_candidates)\\r\\n pred_scores, idxs = pred_scores.topk(num_topk)\\r\\n topk_idxs = topk_idxs[idxs]\\r\\n\\r\\n anchor_idxs, classes_idxs = topk_idxs.unbind(dim=1)\\r\\n\\r\\n pred_boxes = self.box2box_transform.apply_deltas(\\r\\n pred_deltas[anchor_idxs], anchors.tensor[anchor_idxs]\\r\\n )\\r\\n return Instances(\\r\\n image_size, pred_boxes=Boxes(pred_boxes), scores=pred_scores, pred_classes=classes_idxs\\r\\n )\\r\\n\\r\\n def _decode_multi_level_predictions(\\r\\n self,\\r\\n anchors: List[Boxes],\\r\\n pred_scores: List[Tensor],\\r\\n pred_deltas: List[Tensor],\\r\\n score_thresh: float,\\r\\n topk_candidates: int,\\r\\n image_size: Tuple[int, int],\\r\\n ) -> Instances:\\r\\n \\\"\\\"\\\"\\r\\n Run `_decode_per_level_predictions` for all feature levels and concat the results.\\r\\n \\\"\\\"\\\"\\r\\n predictions = [\\r\\n self._decode_per_level_predictions(\\r\\n anchors_i,\\r\\n box_cls_i,\\r\\n box_reg_i,\\r\\n self.test_score_thresh,\\r\\n self.test_topk_candidates,\\r\\n image_size,\\r\\n )\\r\\n # Iterate over every feature level\\r\\n for box_cls_i, box_reg_i, anchors_i in zip(pred_scores, pred_deltas, anchors)\\r\\n ]\\r\\n return predictions[0].cat(predictions) # 'Instances.cat' is not scriptale but this is\\r\\n\\r\\n def visualize_training(self, batched_inputs, results):\\r\\n \\\"\\\"\\\"\\r\\n A function used to visualize ground truth images and final network predictions.\\r\\n It shows ground truth bounding boxes on the original image and up to 20\\r\\n predicted object bounding boxes on the original image.\\r\\n\\r\\n Args:\\r\\n batched_inputs (list): a list that contains input to the model.\\r\\n results (List[Instances]): a list of #images elements returned by forward_inference().\\r\\n \\\"\\\"\\\"\\r\\n from annotator.oneformer.detectron2.utils.visualizer import Visualizer\\r\\n\\r\\n assert len(batched_inputs) == len(\\r\\n results\\r\\n ), \\\"Cannot visualize inputs and results of different sizes\\\"\\r\\n storage = get_event_storage()\\r\\n max_boxes = 20\\r\\n\\r\\n image_index = 0 # only visualize a single image\\r\\n img = batched_inputs[image_index][\\\"image\\\"]\\r\\n img = convert_image_to_rgb(img.permute(1, 2, 0), self.input_format)\\r\\n v_gt = Visualizer(img, None)\\r\\n v_gt = v_gt.overlay_instances(boxes=batched_inputs[image_index][\\\"instances\\\"].gt_boxes)\\r\\n anno_img = v_gt.get_image()\\r\\n processed_results = detector_postprocess(results[image_index], img.shape[0], img.shape[1])\\r\\n predicted_boxes = processed_results.pred_boxes.tensor.detach().cpu().numpy()\\r\\n\\r\\n v_pred = Visualizer(img, None)\\r\\n v_pred = v_pred.overlay_instances(boxes=predicted_boxes[0:max_boxes])\\r\\n prop_img = v_pred.get_image()\\r\\n vis_img = np.vstack((anno_img, prop_img))\\r\\n vis_img = vis_img.transpose(2, 0, 1)\\r\\n vis_name = f\\\"Top: GT bounding boxes; Bottom: {max_boxes} Highest Scoring Results\\\"\\r\\n storage.put_image(vis_name, vis_img)\\r\"\n },\n {\n \"identifier\": \"permute_to_N_HWA_K\",\n \"path\": \"annotator/oneformer/detectron2/modeling/meta_arch/dense_detector.py\",\n \"snippet\": \"def permute_to_N_HWA_K(tensor, K: int):\\r\\n \\\"\\\"\\\"\\r\\n Transpose/reshape a tensor from (N, (Ai x K), H, W) to (N, (HxWxAi), K)\\r\\n \\\"\\\"\\\"\\r\\n assert tensor.dim() == 4, tensor.shape\\r\\n N, _, H, W = tensor.shape\\r\\n tensor = tensor.view(N, -1, K, H, W)\\r\\n tensor = tensor.permute(0, 3, 4, 1, 2)\\r\\n tensor = tensor.reshape(N, -1, K) # Size=(N,HWA,K)\\r\\n return tensor\\r\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import logging\r\nimport math\r\nimport torch\r\nfrom typing import List, Tuple\r\nfrom fvcore.nn import sigmoid_focal_loss_jit\r\nfrom torch import Tensor, nn\r\nfrom torch.nn import functional as F\r\nfrom annotator.oneformer.detectron2.config import configurable\r\nfrom annotator.oneformer.detectron2.layers import CycleBatchNormList, ShapeSpec, batched_nms, cat, get_norm\r\nfrom annotator.oneformer.detectron2.structures import Boxes, ImageList, Instances, pairwise_iou\r\nfrom annotator.oneformer.detectron2.utils.events import get_event_storage\r\nfrom ..anchor_generator import build_anchor_generator\r\nfrom ..backbone import Backbone, build_backbone\r\nfrom ..box_regression import Box2BoxTransform, _dense_box_regression_loss\r\nfrom ..matcher import Matcher\r\nfrom .build import META_ARCH_REGISTRY\r\nfrom .dense_detector import DenseDetector, permute_to_N_HWA_K # noqa\r"},"token_num":{"kind":"number","value":17658,"string":"17,658"},"cropped_code":{"kind":"string","value":" match_quality_matrix = pairwise_iou(gt_per_image.gt_boxes, anchors)\r\n matched_idxs, anchor_labels = self.anchor_matcher(match_quality_matrix)\r\n del match_quality_matrix\r\n\r\n if len(gt_per_image) > 0:\r\n matched_gt_boxes_i = gt_per_image.gt_boxes.tensor[matched_idxs]\r\n\r\n gt_labels_i = gt_per_image.gt_classes[matched_idxs]\r\n # Anchors with label 0 are treated as background.\r\n gt_labels_i[anchor_labels == 0] = self.num_classes\r\n # Anchors with label -1 are ignored.\r\n gt_labels_i[anchor_labels == -1] = -1\r\n else:\r\n matched_gt_boxes_i = torch.zeros_like(anchors.tensor)\r\n gt_labels_i = torch.zeros_like(matched_idxs) + self.num_classes\r\n\r\n gt_labels.append(gt_labels_i)\r\n matched_gt_boxes.append(matched_gt_boxes_i)\r\n\r\n return gt_labels, matched_gt_boxes\r\n\r\n def forward_inference(\r\n self, images: ImageList, features: List[Tensor], predictions: List[List[Tensor]]\r\n ):\r\n pred_logits, pred_anchor_deltas = self._transpose_dense_predictions(\r\n predictions, [self.num_classes, 4]\r\n )\r\n anchors = self.anchor_generator(features)\r\n\r\n results: List[Instances] = []\r\n for img_idx, image_size in enumerate(images.image_sizes):\r\n scores_per_image = [x[img_idx].sigmoid_() for x in pred_logits]\r\n deltas_per_image = [x[img_idx] for x in pred_anchor_deltas]\r\n results_per_image = self.inference_single_image(\r\n anchors, scores_per_image, deltas_per_image, image_size\r\n )\r\n results.append(results_per_image)\r\n return results\r\n\r\n def inference_single_image(\r\n self,\r\n anchors: List[Boxes],\r\n box_cls: List[Tensor],\r\n box_delta: List[Tensor],\r\n image_size: Tuple[int, int],\r\n ):\r\n \"\"\"\r\n Single-image inference. Return bounding-box detection results by thresholding\r\n on scores and applying non-maximum suppression (NMS).\r\n\r\n Arguments:\r\n anchors (list[Boxes]): list of #feature levels. Each entry contains\r\n a Boxes object, which contains all the anchors in that feature level.\r\n box_cls (list[Tensor]): list of #feature levels. Each entry contains\r\n tensor of size (H x W x A, K)\r\n box_delta (list[Tensor]): Same shape as 'box_cls' except that K becomes 4.\r\n image_size (tuple(H, W)): a tuple of the image height and width.\r\n\r\n Returns:\r\n Same as `inference`, but for only one image.\r\n \"\"\"\r\n pred = self._decode_multi_level_predictions(\r\n anchors,\r\n box_cls,\r\n box_delta,\r\n self.test_score_thresh,\r\n self.test_topk_candidates,\r\n image_size,\r\n )\r\n keep = batched_nms( # per-class NMS\r\n pred.pred_boxes.tensor, pred.scores, pred.pred_classes, self.test_nms_thresh\r\n )\r\n return pred[keep[: self.max_detections_per_image]]\r\n\r\n\r\nclass RetinaNetHead(nn.Module):\r\n \"\"\"\r\n The head used in RetinaNet for object classification and box regression.\r\n It has two subnets for the two tasks, with a common structure but separate parameters.\r\n \"\"\"\r\n\r\n @configurable\r\n def __init__(\r\n self,\r\n *,\r\n input_shape: List[ShapeSpec],\r\n num_classes,\r\n num_anchors,\r\n conv_dims: List[int],\r\n norm=\"\",\r\n prior_prob=0.01,\r\n ):\r\n \"\"\"\r\n NOTE: this interface is experimental.\r\n\r\n Args:\r\n input_shape (List[ShapeSpec]): input shape\r\n num_classes (int): number of classes. Used to label background proposals.\r\n num_anchors (int): number of generated anchors\r\n conv_dims (List[int]): dimensions for each convolution layer\r\n norm (str or callable):\r\n Normalization for conv layers except for the two output layers.\r\n See :func:`detectron2.layers.get_norm` for supported types.\r\n prior_prob (float): Prior weight for computing bias\r\n \"\"\"\r\n super().__init__()\r\n\r\n self._num_features = len(input_shape)\r\n if norm == \"BN\" or norm == \"SyncBN\":\r\n logger.info(\r\n f\"Using domain-specific {norm} in RetinaNetHead with len={self._num_features}.\"\r\n )\r\n bn_class = nn.BatchNorm2d if norm == \"BN\" else nn.SyncBatchNorm\r\n\r\n def norm(c):\r\n return CycleBatchNormList(\r\n length=self._num_features, bn_class=bn_class, num_features=c\r\n )\r\n\r\n else:\r\n"},"all_code":{"kind":"string","value":"# Copyright (c) Facebook, Inc. and its affiliates.\r\n\r\n\r\n\r\n__all__ = [\"RetinaNet\"]\r\n\r\n\r\nlogger = logging.getLogger(__name__)\r\n\r\n\r\n@META_ARCH_REGISTRY.register()\r\nclass RetinaNet(DenseDetector):\r\n \"\"\"\r\n Implement RetinaNet in :paper:`RetinaNet`.\r\n \"\"\"\r\n\r\n @configurable\r\n def __init__(\r\n self,\r\n *,\r\n backbone: Backbone,\r\n head: nn.Module,\r\n head_in_features,\r\n anchor_generator,\r\n box2box_transform,\r\n anchor_matcher,\r\n num_classes,\r\n focal_loss_alpha=0.25,\r\n focal_loss_gamma=2.0,\r\n smooth_l1_beta=0.0,\r\n box_reg_loss_type=\"smooth_l1\",\r\n test_score_thresh=0.05,\r\n test_topk_candidates=1000,\r\n test_nms_thresh=0.5,\r\n max_detections_per_image=100,\r\n pixel_mean,\r\n pixel_std,\r\n vis_period=0,\r\n input_format=\"BGR\",\r\n ):\r\n \"\"\"\r\n NOTE: this interface is experimental.\r\n\r\n Args:\r\n backbone: a backbone module, must follow detectron2's backbone interface\r\n head (nn.Module): a module that predicts logits and regression deltas\r\n for each level from a list of per-level features\r\n head_in_features (Tuple[str]): Names of the input feature maps to be used in head\r\n anchor_generator (nn.Module): a module that creates anchors from a\r\n list of features. Usually an instance of :class:`AnchorGenerator`\r\n box2box_transform (Box2BoxTransform): defines the transform from anchors boxes to\r\n instance boxes\r\n anchor_matcher (Matcher): label the anchors by matching them with ground truth.\r\n num_classes (int): number of classes. Used to label background proposals.\r\n\r\n # Loss parameters:\r\n focal_loss_alpha (float): focal_loss_alpha\r\n focal_loss_gamma (float): focal_loss_gamma\r\n smooth_l1_beta (float): smooth_l1_beta\r\n box_reg_loss_type (str): Options are \"smooth_l1\", \"giou\", \"diou\", \"ciou\"\r\n\r\n # Inference parameters:\r\n test_score_thresh (float): Inference cls score threshold, only anchors with\r\n score > INFERENCE_TH are considered for inference (to improve speed)\r\n test_topk_candidates (int): Select topk candidates before NMS\r\n test_nms_thresh (float): Overlap threshold used for non-maximum suppression\r\n (suppress boxes with IoU >= this threshold)\r\n max_detections_per_image (int):\r\n Maximum number of detections to return per image during inference\r\n (100 is based on the limit established for the COCO dataset).\r\n\r\n pixel_mean, pixel_std: see :class:`DenseDetector`.\r\n \"\"\"\r\n super().__init__(\r\n backbone, head, head_in_features, pixel_mean=pixel_mean, pixel_std=pixel_std\r\n )\r\n self.num_classes = num_classes\r\n\r\n # Anchors\r\n self.anchor_generator = anchor_generator\r\n self.box2box_transform = box2box_transform\r\n self.anchor_matcher = anchor_matcher\r\n\r\n # Loss parameters:\r\n self.focal_loss_alpha = focal_loss_alpha\r\n self.focal_loss_gamma = focal_loss_gamma\r\n self.smooth_l1_beta = smooth_l1_beta\r\n self.box_reg_loss_type = box_reg_loss_type\r\n # Inference parameters:\r\n self.test_score_thresh = test_score_thresh\r\n self.test_topk_candidates = test_topk_candidates\r\n self.test_nms_thresh = test_nms_thresh\r\n self.max_detections_per_image = max_detections_per_image\r\n # Vis parameters\r\n self.vis_period = vis_period\r\n self.input_format = input_format\r\n\r\n @classmethod\r\n def from_config(cls, cfg):\r\n backbone = build_backbone(cfg)\r\n backbone_shape = backbone.output_shape()\r\n feature_shapes = [backbone_shape[f] for f in cfg.MODEL.RETINANET.IN_FEATURES]\r\n head = RetinaNetHead(cfg, feature_shapes)\r\n anchor_generator = build_anchor_generator(cfg, feature_shapes)\r\n return {\r\n \"backbone\": backbone,\r\n \"head\": head,\r\n \"anchor_generator\": anchor_generator,\r\n \"box2box_transform\": Box2BoxTransform(weights=cfg.MODEL.RETINANET.BBOX_REG_WEIGHTS),\r\n \"anchor_matcher\": Matcher(\r\n cfg.MODEL.RETINANET.IOU_THRESHOLDS,\r\n cfg.MODEL.RETINANET.IOU_LABELS,\r\n allow_low_quality_matches=True,\r\n ),\r\n \"pixel_mean\": cfg.MODEL.PIXEL_MEAN,\r\n \"pixel_std\": cfg.MODEL.PIXEL_STD,\r\n \"num_classes\": cfg.MODEL.RETINANET.NUM_CLASSES,\r\n \"head_in_features\": cfg.MODEL.RETINANET.IN_FEATURES,\r\n # Loss parameters:\r\n \"focal_loss_alpha\": cfg.MODEL.RETINANET.FOCAL_LOSS_ALPHA,\r\n \"focal_loss_gamma\": cfg.MODEL.RETINANET.FOCAL_LOSS_GAMMA,\r\n \"smooth_l1_beta\": cfg.MODEL.RETINANET.SMOOTH_L1_LOSS_BETA,\r\n \"box_reg_loss_type\": cfg.MODEL.RETINANET.BBOX_REG_LOSS_TYPE,\r\n # Inference parameters:\r\n \"test_score_thresh\": cfg.MODEL.RETINANET.SCORE_THRESH_TEST,\r\n \"test_topk_candidates\": cfg.MODEL.RETINANET.TOPK_CANDIDATES_TEST,\r\n \"test_nms_thresh\": cfg.MODEL.RETINANET.NMS_THRESH_TEST,\r\n \"max_detections_per_image\": cfg.TEST.DETECTIONS_PER_IMAGE,\r\n # Vis parameters\r\n \"vis_period\": cfg.VIS_PERIOD,\r\n \"input_format\": cfg.INPUT.FORMAT,\r\n }\r\n\r\n def forward_training(self, images, features, predictions, gt_instances):\r\n # Transpose the Hi*Wi*A dimension to the middle:\r\n pred_logits, pred_anchor_deltas = self._transpose_dense_predictions(\r\n predictions, [self.num_classes, 4]\r\n )\r\n anchors = self.anchor_generator(features)\r\n gt_labels, gt_boxes = self.label_anchors(anchors, gt_instances)\r\n return self.losses(anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes)\r\n\r\n def losses(self, anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes):\r\n \"\"\"\r\n Args:\r\n anchors (list[Boxes]): a list of #feature level Boxes\r\n gt_labels, gt_boxes: see output of :meth:`RetinaNet.label_anchors`.\r\n Their shapes are (N, R) and (N, R, 4), respectively, where R is\r\n the total number of anchors across levels, i.e. sum(Hi x Wi x Ai)\r\n pred_logits, pred_anchor_deltas: both are list[Tensor]. Each element in the\r\n list corresponds to one level and has shape (N, Hi * Wi * Ai, K or 4).\r\n Where K is the number of classes used in `pred_logits`.\r\n\r\n Returns:\r\n dict[str, Tensor]:\r\n mapping from a named loss to a scalar tensor storing the loss.\r\n Used during training only. The dict keys are: \"loss_cls\" and \"loss_box_reg\"\r\n \"\"\"\r\n num_images = len(gt_labels)\r\n gt_labels = torch.stack(gt_labels) # (N, R)\r\n\r\n valid_mask = gt_labels >= 0\r\n pos_mask = (gt_labels >= 0) & (gt_labels != self.num_classes)\r\n num_pos_anchors = pos_mask.sum().item()\r\n get_event_storage().put_scalar(\"num_pos_anchors\", num_pos_anchors / num_images)\r\n normalizer = self._ema_update(\"loss_normalizer\", max(num_pos_anchors, 1), 100)\r\n\r\n # classification and regression loss\r\n gt_labels_target = F.one_hot(gt_labels[valid_mask], num_classes=self.num_classes + 1)[\r\n :, :-1\r\n ] # no loss for the last (background) class\r\n loss_cls = sigmoid_focal_loss_jit(\r\n cat(pred_logits, dim=1)[valid_mask],\r\n gt_labels_target.to(pred_logits[0].dtype),\r\n alpha=self.focal_loss_alpha,\r\n gamma=self.focal_loss_gamma,\r\n reduction=\"sum\",\r\n )\r\n\r\n loss_box_reg = _dense_box_regression_loss(\r\n anchors,\r\n self.box2box_transform,\r\n pred_anchor_deltas,\r\n gt_boxes,\r\n pos_mask,\r\n box_reg_loss_type=self.box_reg_loss_type,\r\n smooth_l1_beta=self.smooth_l1_beta,\r\n )\r\n\r\n return {\r\n \"loss_cls\": loss_cls / normalizer,\r\n \"loss_box_reg\": loss_box_reg / normalizer,\r\n }\r\n\r\n @torch.no_grad()\r\n def label_anchors(self, anchors, gt_instances):\r\n \"\"\"\r\n Args:\r\n anchors (list[Boxes]): A list of #feature level Boxes.\r\n The Boxes contains anchors of this image on the specific feature level.\r\n gt_instances (list[Instances]): a list of N `Instances`s. The i-th\r\n `Instances` contains the ground-truth per-instance annotations\r\n for the i-th input image.\r\n\r\n Returns:\r\n list[Tensor]: List of #img tensors. i-th element is a vector of labels whose length is\r\n the total number of anchors across all feature maps (sum(Hi * Wi * A)).\r\n Label values are in {-1, 0, ..., K}, with -1 means ignore, and K means background.\r\n\r\n list[Tensor]: i-th element is a Rx4 tensor, where R is the total number of anchors\r\n across feature maps. The values are the matched gt boxes for each anchor.\r\n Values are undefined for those anchors not labeled as foreground.\r\n \"\"\"\r\n anchors = Boxes.cat(anchors) # Rx4\r\n\r\n gt_labels = []\r\n matched_gt_boxes = []\r\n for gt_per_image in gt_instances:\r\n match_quality_matrix = pairwise_iou(gt_per_image.gt_boxes, anchors)\r\n matched_idxs, anchor_labels = self.anchor_matcher(match_quality_matrix)\r\n del match_quality_matrix\r\n\r\n if len(gt_per_image) > 0:\r\n matched_gt_boxes_i = gt_per_image.gt_boxes.tensor[matched_idxs]\r\n\r\n gt_labels_i = gt_per_image.gt_classes[matched_idxs]\r\n # Anchors with label 0 are treated as background.\r\n gt_labels_i[anchor_labels == 0] = self.num_classes\r\n # Anchors with label -1 are ignored.\r\n gt_labels_i[anchor_labels == -1] = -1\r\n else:\r\n matched_gt_boxes_i = torch.zeros_like(anchors.tensor)\r\n gt_labels_i = torch.zeros_like(matched_idxs) + self.num_classes\r\n\r\n gt_labels.append(gt_labels_i)\r\n matched_gt_boxes.append(matched_gt_boxes_i)\r\n\r\n return gt_labels, matched_gt_boxes\r\n\r\n def forward_inference(\r\n self, images: ImageList, features: List[Tensor], predictions: List[List[Tensor]]\r\n ):\r\n pred_logits, pred_anchor_deltas = self._transpose_dense_predictions(\r\n predictions, [self.num_classes, 4]\r\n )\r\n anchors = self.anchor_generator(features)\r\n\r\n results: List[Instances] = []\r\n for img_idx, image_size in enumerate(images.image_sizes):\r\n scores_per_image = [x[img_idx].sigmoid_() for x in pred_logits]\r\n deltas_per_image = [x[img_idx] for x in pred_anchor_deltas]\r\n results_per_image = self.inference_single_image(\r\n anchors, scores_per_image, deltas_per_image, image_size\r\n )\r\n results.append(results_per_image)\r\n return results\r\n\r\n def inference_single_image(\r\n self,\r\n anchors: List[Boxes],\r\n box_cls: List[Tensor],\r\n box_delta: List[Tensor],\r\n image_size: Tuple[int, int],\r\n ):\r\n \"\"\"\r\n Single-image inference. Return bounding-box detection results by thresholding\r\n on scores and applying non-maximum suppression (NMS).\r\n\r\n Arguments:\r\n anchors (list[Boxes]): list of #feature levels. Each entry contains\r\n a Boxes object, which contains all the anchors in that feature level.\r\n box_cls (list[Tensor]): list of #feature levels. Each entry contains\r\n tensor of size (H x W x A, K)\r\n box_delta (list[Tensor]): Same shape as 'box_cls' except that K becomes 4.\r\n image_size (tuple(H, W)): a tuple of the image height and width.\r\n\r\n Returns:\r\n Same as `inference`, but for only one image.\r\n \"\"\"\r\n pred = self._decode_multi_level_predictions(\r\n anchors,\r\n box_cls,\r\n box_delta,\r\n self.test_score_thresh,\r\n self.test_topk_candidates,\r\n image_size,\r\n )\r\n keep = batched_nms( # per-class NMS\r\n pred.pred_boxes.tensor, pred.scores, pred.pred_classes, self.test_nms_thresh\r\n )\r\n return pred[keep[: self.max_detections_per_image]]\r\n\r\n\r\nclass RetinaNetHead(nn.Module):\r\n \"\"\"\r\n The head used in RetinaNet for object classification and box regression.\r\n It has two subnets for the two tasks, with a common structure but separate parameters.\r\n \"\"\"\r\n\r\n @configurable\r\n def __init__(\r\n self,\r\n *,\r\n input_shape: List[ShapeSpec],\r\n num_classes,\r\n num_anchors,\r\n conv_dims: List[int],\r\n norm=\"\",\r\n prior_prob=0.01,\r\n ):\r\n \"\"\"\r\n NOTE: this interface is experimental.\r\n\r\n Args:\r\n input_shape (List[ShapeSpec]): input shape\r\n num_classes (int): number of classes. Used to label background proposals.\r\n num_anchors (int): number of generated anchors\r\n conv_dims (List[int]): dimensions for each convolution layer\r\n norm (str or callable):\r\n Normalization for conv layers except for the two output layers.\r\n See :func:`detectron2.layers.get_norm` for supported types.\r\n prior_prob (float): Prior weight for computing bias\r\n \"\"\"\r\n super().__init__()\r\n\r\n self._num_features = len(input_shape)\r\n if norm == \"BN\" or norm == \"SyncBN\":\r\n logger.info(\r\n f\"Using domain-specific {norm} in RetinaNetHead with len={self._num_features}.\"\r\n )\r\n bn_class = nn.BatchNorm2d if norm == \"BN\" else nn.SyncBatchNorm\r\n\r\n def norm(c):\r\n return CycleBatchNormList(\r\n length=self._num_features, bn_class=bn_class, num_features=c\r\n )\r\n\r\n else:\r"},"next_line":{"kind":"string","value":" norm_name = str(type(get_norm(norm, 32)))\r"},"gold_snippet_index":{"kind":"number","value":1,"string":"1"},"created_at":{"kind":"string","value":"2023-12-05 02:51:53+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5968,"cells":{"repo_name":{"kind":"string","value":"DiffusionLight/DiffusionLight"},"file_path":{"kind":"string","value":"relighting/inpainter.py"},"context":{"kind":"list like","value":[{"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]] = None,\n image: PipelineImageInput = None,\n mask_image: PipelineImageInput = None,\n control_image: PipelineImageInput = None,\n height: Optional[int] = None,\n width: Optional[int] = None,\n strength: float = 1.0,\n num_inference_steps: int = 50,\n guidance_scale: float = 7.5,\n negative_prompt: Optional[Union[str, List[str]]] = None,\n num_images_per_prompt: Optional[int] = 1,\n eta: float = 0.0,\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\n latents: Optional[torch.FloatTensor] = None,\n prompt_embeds: Optional[torch.FloatTensor] = None,\n negative_prompt_embeds: Optional[torch.FloatTensor] = None,\n output_type: Optional[str] = \"pil\",\n return_dict: bool = True,\n callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,\n callback_steps: int = 1,\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\n controlnet_conditioning_scale: Union[float, List[float]] = 0.5,\n guess_mode: bool = False,\n control_guidance_start: Union[float, List[float]] = 0.0,\n control_guidance_end: Union[float, List[float]] = 1.0,\n newx: int = 0,\n newy: int = 0,\n newr: int = 256,\n current_seed=0,\n use_noise_moving=True,\n ):\n # OVERWRITE METHODS\n self.prepare_mask_latents = custom_prepare_mask_latents.__get__(self, CustomStableDiffusionControlNetInpaintPipeline)\n self.prepare_latents = custom_prepare_latents.__get__(self, CustomStableDiffusionControlNetInpaintPipeline)\n\n controlnet = self.controlnet._orig_mod if is_compiled_module(self.controlnet) else self.controlnet\n\n # align format for control guidance\n if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list):\n control_guidance_start = len(control_guidance_end) * [control_guidance_start]\n elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list):\n control_guidance_end = len(control_guidance_start) * [control_guidance_end]\n elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list):\n mult = len(controlnet.nets) if isinstance(controlnet, MultiControlNetModel) else 1\n control_guidance_start, control_guidance_end = mult * [control_guidance_start], mult * [\n control_guidance_end\n ]\n\n # 1. Check inputs. Raise error if not correct\n self.check_inputs(\n prompt,\n control_image,\n height,\n width,\n callback_steps,\n negative_prompt,\n prompt_embeds,\n negative_prompt_embeds,\n controlnet_conditioning_scale,\n control_guidance_start,\n control_guidance_end,\n )\n\n # 2. Define call parameters\n if prompt is not None and isinstance(prompt, str):\n batch_size = 1\n elif prompt is not None and isinstance(prompt, list):\n batch_size = len(prompt)\n else:\n batch_size = prompt_embeds.shape[0]\n\n device = self._execution_device\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\n # corresponds to doing no classifier free guidance.\n do_classifier_free_guidance = guidance_scale > 1.0\n\n if isinstance(controlnet, MultiControlNetModel) and isinstance(controlnet_conditioning_scale, float):\n controlnet_conditioning_scale = [controlnet_conditioning_scale] * len(controlnet.nets)\n\n global_pool_conditions = (\n controlnet.config.global_pool_conditions\n if isinstance(controlnet, ControlNetModel)\n else controlnet.nets[0].config.global_pool_conditions\n )\n guess_mode = guess_mode or global_pool_conditions\n\n # 3. Encode input prompt\n text_encoder_lora_scale = (\n cross_attention_kwargs.get(\"scale\", None) if cross_attention_kwargs is not None else None\n )\n prompt_embeds, negative_prompt_embeds = self.encode_prompt(\n prompt,\n device,\n num_images_per_prompt,\n do_classifier_free_guidance,\n negative_prompt,\n prompt_embeds=prompt_embeds,\n negative_prompt_embeds=negative_prompt_embeds,\n lora_scale=text_encoder_lora_scale,\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 if do_classifier_free_guidance:\n prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])\n\n # 4. Prepare image\n if isinstance(controlnet, ControlNetModel):\n control_image = self.prepare_control_image(\n image=control_image,\n width=width,\n height=height,\n batch_size=batch_size * num_images_per_prompt,\n num_images_per_prompt=num_images_per_prompt,\n device=device,\n dtype=controlnet.dtype,\n do_classifier_free_guidance=do_classifier_free_guidance,\n guess_mode=guess_mode,\n )\n elif isinstance(controlnet, MultiControlNetModel):\n control_images = []\n\n for control_image_ in control_image:\n control_image_ = self.prepare_control_image(\n image=control_image_,\n width=width,\n height=height,\n batch_size=batch_size * num_images_per_prompt,\n num_images_per_prompt=num_images_per_prompt,\n device=device,\n dtype=controlnet.dtype,\n do_classifier_free_guidance=do_classifier_free_guidance,\n guess_mode=guess_mode,\n )\n\n control_images.append(control_image_)\n\n control_image = control_images\n else:\n assert False\n\n # 4. Preprocess mask and image - resizes image and mask w.r.t height and width\n init_image = self.image_processor.preprocess(image, height=height, width=width)\n init_image = init_image.to(dtype=torch.float32)\n\n mask = self.mask_processor.preprocess(mask_image, height=height, width=width)\n\n masked_image = init_image * (mask < 0.5)\n _, _, height, width = init_image.shape\n\n # 5. Prepare timesteps\n self.scheduler.set_timesteps(num_inference_steps, device=device)\n timesteps, num_inference_steps = self.get_timesteps(\n num_inference_steps=num_inference_steps, strength=strength, device=device\n )\n # at which timestep to set the initial noise (n.b. 50% if strength is 0.5)\n latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)\n # create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise\n is_strength_max = strength == 1.0\n\n # 6. Prepare latent variables\n num_channels_latents = self.vae.config.latent_channels\n num_channels_unet = self.unet.config.in_channels\n return_image_latents = num_channels_unet == 4\n\n # EDITED HERE\n latents_outputs = self.prepare_latents(\n batch_size * num_images_per_prompt,\n num_channels_latents,\n height,\n width,\n prompt_embeds.dtype,\n device,\n generator,\n latents,\n image=init_image,\n timestep=latent_timestep,\n is_strength_max=is_strength_max,\n return_noise=True,\n return_image_latents=return_image_latents,\n newx=newx,\n newy=newy,\n newr=newr,\n current_seed=current_seed,\n use_noise_moving=use_noise_moving,\n )\n\n if return_image_latents:\n latents, noise, image_latents = latents_outputs\n else:\n latents, noise = latents_outputs\n\n # 7. Prepare mask latent variables\n mask, masked_image_latents = self.prepare_mask_latents(\n mask,\n masked_image,\n batch_size * num_images_per_prompt,\n height,\n width,\n prompt_embeds.dtype,\n device,\n generator,\n do_classifier_free_guidance,\n )\n\n # 7. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline\n extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)\n\n # 7.1 Create tensor stating which controlnets to keep\n controlnet_keep = []\n for i in range(len(timesteps)):\n keeps = [\n 1.0 - float(i / len(timesteps) < s or (i + 1) / len(timesteps) > e)\n for s, e in zip(control_guidance_start, control_guidance_end)\n ]\n controlnet_keep.append(keeps[0] if isinstance(controlnet, ControlNetModel) else keeps)\n\n # 8. Denoising loop\n num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order\n with self.progress_bar(total=num_inference_steps) as progress_bar:\n for i, t in enumerate(timesteps):\n # expand the latents if we are doing classifier free guidance\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\n\n # controlnet(s) inference\n if guess_mode and do_classifier_free_guidance:\n # Infer ControlNet only for the conditional batch.\n control_model_input = latents\n control_model_input = self.scheduler.scale_model_input(control_model_input, t)\n controlnet_prompt_embeds = prompt_embeds.chunk(2)[1]\n else:\n control_model_input = latent_model_input\n controlnet_prompt_embeds = prompt_embeds\n\n if isinstance(controlnet_keep[i], list):\n cond_scale = [c * s for c, s in zip(controlnet_conditioning_scale, controlnet_keep[i])]\n else:\n controlnet_cond_scale = controlnet_conditioning_scale\n if isinstance(controlnet_cond_scale, list):\n controlnet_cond_scale = controlnet_cond_scale[0]\n cond_scale = controlnet_cond_scale * controlnet_keep[i]\n\n down_block_res_samples, mid_block_res_sample = self.controlnet(\n control_model_input,\n t,\n encoder_hidden_states=controlnet_prompt_embeds,\n controlnet_cond=control_image,\n conditioning_scale=cond_scale,\n guess_mode=guess_mode,\n return_dict=False,\n )\n\n if guess_mode and do_classifier_free_guidance:\n # Infered ControlNet only for the conditional batch.\n # To apply the output of ControlNet to both the unconditional and conditional batches,\n # add 0 to the unconditional batch to keep it unchanged.\n down_block_res_samples = [torch.cat([torch.zeros_like(d), d]) for d in down_block_res_samples]\n mid_block_res_sample = torch.cat([torch.zeros_like(mid_block_res_sample), mid_block_res_sample])\n\n # predict the noise residual\n if num_channels_unet == 9:\n latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)\n\n noise_pred = self.unet(\n latent_model_input,\n t,\n encoder_hidden_states=prompt_embeds,\n cross_attention_kwargs=cross_attention_kwargs,\n down_block_additional_residuals=down_block_res_samples,\n mid_block_additional_residual=mid_block_res_sample,\n return_dict=False,\n )[0]\n\n # perform guidance\n if do_classifier_free_guidance:\n noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\n noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\n\n # compute the previous noisy sample x_t -> x_t-1\n latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]\n\n if num_channels_unet == 4:\n init_latents_proper = image_latents[:1]\n init_mask = mask[:1]\n\n if i < len(timesteps) - 1:\n noise_timestep = timesteps[i + 1]\n init_latents_proper = self.scheduler.add_noise(\n init_latents_proper, noise, torch.tensor([noise_timestep])\n )\n\n latents = (1 - init_mask) * init_latents_proper + init_mask * latents\n\n # call the callback, if provided\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\n progress_bar.update()\n if callback is not None and i % callback_steps == 0:\n callback(i, t, latents)\n\n # If we do sequential model offloading, let's offload unet and controlnet\n # manually for max memory savings\n if hasattr(self, \"final_offload_hook\") and self.final_offload_hook is not None:\n self.unet.to(\"cpu\")\n self.controlnet.to(\"cpu\")\n torch.cuda.empty_cache()\n\n if not output_type == \"latent\":\n image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]\n image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)\n else:\n image = latents\n has_nsfw_concept = None\n\n if has_nsfw_concept is None:\n do_denormalize = [True] * image.shape[0]\n else:\n do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]\n\n image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)\n\n # Offload all models\n self.maybe_free_model_hooks()\n\n if not return_dict:\n return (image, has_nsfw_concept)\n\n return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)"},{"identifier":"CustomStableDiffusionInpaintPipeline","path":"relighting/pipeline_inpaintonly.py","snippet":"class CustomStableDiffusionInpaintPipeline(StableDiffusionInpaintPipeline):\n @torch.no_grad()\n def __call__(\n self,\n prompt: Union[str, List[str]] = None,\n image: PipelineImageInput = None,\n mask_image: PipelineImageInput = None,\n masked_image_latents: torch.FloatTensor = None,\n height: Optional[int] = None,\n width: Optional[int] = None,\n strength: float = 1.0,\n num_inference_steps: int = 50,\n guidance_scale: float = 7.5,\n negative_prompt: Optional[Union[str, List[str]]] = None,\n num_images_per_prompt: Optional[int] = 1,\n eta: float = 0.0,\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\n latents: Optional[torch.FloatTensor] = None,\n prompt_embeds: Optional[torch.FloatTensor] = None,\n negative_prompt_embeds: Optional[torch.FloatTensor] = None,\n output_type: Optional[str] = \"pil\",\n return_dict: bool = True,\n callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,\n callback_steps: int = 1,\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\n newx: int = 0,\n newy: int = 0,\n newr: int = 256,\n current_seed=0,\n use_noise_moving=True,\n ):\n # OVERWRITE METHODS\n self.prepare_mask_latents = custom_prepare_mask_latents.__get__(self, CustomStableDiffusionInpaintPipeline)\n self.prepare_latents = custom_prepare_latents.__get__(self, CustomStableDiffusionInpaintPipeline)\n\n # 0. Default height and width to unet\n height = height or self.unet.config.sample_size * self.vae_scale_factor\n width = width or self.unet.config.sample_size * self.vae_scale_factor\n\n # 1. Check inputs\n self.check_inputs(\n prompt,\n height,\n width,\n strength,\n callback_steps,\n negative_prompt,\n prompt_embeds,\n negative_prompt_embeds,\n )\n\n # 2. Define call parameters\n if prompt is not None and isinstance(prompt, str):\n batch_size = 1\n elif prompt is not None and isinstance(prompt, list):\n batch_size = len(prompt)\n else:\n batch_size = prompt_embeds.shape[0]\n\n device = self._execution_device\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\n # corresponds to doing no classifier free guidance.\n do_classifier_free_guidance = guidance_scale > 1.0\n\n # 3. Encode input prompt\n text_encoder_lora_scale = (\n cross_attention_kwargs.get(\"scale\", None) if cross_attention_kwargs is not None else None\n )\n prompt_embeds, negative_prompt_embeds = self.encode_prompt(\n prompt,\n device,\n num_images_per_prompt,\n do_classifier_free_guidance,\n negative_prompt,\n prompt_embeds=prompt_embeds,\n negative_prompt_embeds=negative_prompt_embeds,\n lora_scale=text_encoder_lora_scale,\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 if do_classifier_free_guidance:\n prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])\n\n # 4. set timesteps\n self.scheduler.set_timesteps(num_inference_steps, device=device)\n timesteps, num_inference_steps = self.get_timesteps(\n num_inference_steps=num_inference_steps, strength=strength, device=device\n )\n # check that number of inference steps is not < 1 - as this doesn't make sense\n if num_inference_steps < 1:\n raise ValueError(\n f\"After adjusting the num_inference_steps by strength parameter: {strength}, the number of pipeline\"\n f\"steps is {num_inference_steps} which is < 1 and not appropriate for this pipeline.\"\n )\n # at which timestep to set the initial noise (n.b. 50% if strength is 0.5)\n latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)\n # create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise\n is_strength_max = strength == 1.0\n\n # 5. Preprocess mask and image\n\n init_image = self.image_processor.preprocess(image, height=height, width=width)\n init_image = init_image.to(dtype=torch.float32)\n\n # 6. Prepare latent variables\n num_channels_latents = self.vae.config.latent_channels\n num_channels_unet = self.unet.config.in_channels\n return_image_latents = num_channels_unet == 4\n\n latents_outputs = self.prepare_latents(\n batch_size * num_images_per_prompt,\n num_channels_latents,\n height,\n width,\n prompt_embeds.dtype,\n device,\n generator,\n latents,\n image=init_image,\n timestep=latent_timestep,\n is_strength_max=is_strength_max,\n return_noise=True,\n return_image_latents=return_image_latents,\n newx=newx,\n newy=newy,\n newr=newr,\n current_seed=current_seed,\n use_noise_moving=use_noise_moving,\n )\n\n if return_image_latents:\n latents, noise, image_latents = latents_outputs\n else:\n latents, noise = latents_outputs\n\n # 7. Prepare mask latent variables\n mask_condition = self.mask_processor.preprocess(mask_image, height=height, width=width)\n\n if masked_image_latents is None:\n masked_image = init_image * (mask_condition < 0.5)\n else:\n masked_image = masked_image_latents\n\n mask, masked_image_latents = self.prepare_mask_latents(\n mask_condition,\n masked_image,\n batch_size * num_images_per_prompt,\n height,\n width,\n prompt_embeds.dtype,\n device,\n generator,\n do_classifier_free_guidance,\n )\n\n # 8. Check that sizes of mask, masked image and latents match\n if num_channels_unet == 9:\n # default case for runwayml/stable-diffusion-inpainting\n num_channels_mask = mask.shape[1]\n num_channels_masked_image = masked_image_latents.shape[1]\n if num_channels_latents + num_channels_mask + num_channels_masked_image != self.unet.config.in_channels:\n raise ValueError(\n f\"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects\"\n f\" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +\"\n f\" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image}\"\n f\" = {num_channels_latents+num_channels_masked_image+num_channels_mask}. Please verify the config of\"\n \" `pipeline.unet` or your `mask_image` or `image` input.\"\n )\n elif num_channels_unet != 4:\n raise ValueError(\n f\"The unet {self.unet.__class__} should have either 4 or 9 input channels, not {self.unet.config.in_channels}.\"\n )\n\n # 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline\n extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)\n\n # 10. Denoising loop\n num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order\n with self.progress_bar(total=num_inference_steps) as progress_bar:\n for i, t in enumerate(timesteps):\n # expand the latents if we are doing classifier free guidance\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\n\n # concat latents, mask, masked_image_latents in the channel dimension\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\n\n if num_channels_unet == 9:\n latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)\n\n # predict the noise residual\n noise_pred = self.unet(\n latent_model_input,\n t,\n encoder_hidden_states=prompt_embeds,\n cross_attention_kwargs=cross_attention_kwargs,\n return_dict=False,\n )[0]\n\n # perform guidance\n if do_classifier_free_guidance:\n noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\n noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\n\n # compute the previous noisy sample x_t -> x_t-1\n latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]\n\n if num_channels_unet == 4:\n init_latents_proper = image_latents[:1]\n init_mask = mask[:1]\n\n if i < len(timesteps) - 1:\n noise_timestep = timesteps[i + 1]\n init_latents_proper = self.scheduler.add_noise(\n init_latents_proper, noise, torch.tensor([noise_timestep])\n )\n\n latents = (1 - init_mask) * init_latents_proper + init_mask * latents\n\n # call the callback, if provided\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\n progress_bar.update()\n if callback is not None and i % callback_steps == 0:\n callback(i, t, latents)\n\n if not output_type == \"latent\":\n condition_kwargs = {}\n if isinstance(self.vae, AsymmetricAutoencoderKL):\n init_image = init_image.to(device=device, dtype=masked_image_latents.dtype)\n init_image_condition = init_image.clone()\n init_image = self._encode_vae_image(init_image, generator=generator)\n mask_condition = mask_condition.to(device=device, dtype=masked_image_latents.dtype)\n condition_kwargs = {\"image\": init_image_condition, \"mask\": mask_condition}\n image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False, **condition_kwargs)[0]\n image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)\n else:\n image = latents\n has_nsfw_concept = None\n\n if has_nsfw_concept is None:\n do_denormalize = [True] * image.shape[0]\n else:\n do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]\n\n image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)\n\n # Offload all models\n self.maybe_free_model_hooks()\n\n if not return_dict:\n return (image, has_nsfw_concept)\n\n return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)"},{"identifier":"CustomStableDiffusionXLInpaintPipeline","path":"relighting/pipeline_inpaintonly.py","snippet":"class CustomStableDiffusionXLInpaintPipeline(StableDiffusionXLInpaintPipeline):\n @torch.no_grad()\n def __call__(\n self,\n prompt: Union[str, List[str]] = None,\n prompt_2: Optional[Union[str, List[str]]] = None,\n image: PipelineImageInput = None,\n mask_image: PipelineImageInput = None,\n masked_image_latents: torch.FloatTensor = None,\n height: Optional[int] = None,\n width: Optional[int] = None,\n strength: float = 0.9999,\n num_inference_steps: int = 50,\n denoising_start: Optional[float] = None,\n denoising_end: Optional[float] = None,\n guidance_scale: float = 7.5,\n negative_prompt: Optional[Union[str, List[str]]] = None,\n negative_prompt_2: Optional[Union[str, List[str]]] = None,\n num_images_per_prompt: Optional[int] = 1,\n eta: float = 0.0,\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\n latents: Optional[torch.FloatTensor] = None,\n prompt_embeds: Optional[torch.FloatTensor] = None,\n negative_prompt_embeds: Optional[torch.FloatTensor] = None,\n pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\n negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\n output_type: Optional[str] = \"pil\",\n return_dict: bool = True,\n callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,\n callback_steps: int = 1,\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\n guidance_rescale: float = 0.0,\n original_size: Tuple[int, int] = None,\n crops_coords_top_left: Tuple[int, int] = (0, 0),\n target_size: Tuple[int, int] = None,\n negative_original_size: Optional[Tuple[int, int]] = None,\n negative_crops_coords_top_left: Tuple[int, int] = (0, 0),\n negative_target_size: Optional[Tuple[int, int]] = None,\n aesthetic_score: float = 6.0,\n negative_aesthetic_score: float = 2.5,\n newx: int = 0,\n newy: int = 0,\n newr: int = 256,\n current_seed=0,\n use_noise_moving=True,\n ):\n # OVERWRITE METHODS\n self.prepare_mask_latents = custom_prepare_mask_latents.__get__(self, CustomStableDiffusionXLInpaintPipeline)\n self.prepare_latents = custom_prepare_latents.__get__(self, CustomStableDiffusionXLInpaintPipeline)\n\n # 0. Default height and width to unet\n height = height or self.unet.config.sample_size * self.vae_scale_factor\n width = width or self.unet.config.sample_size * self.vae_scale_factor\n\n # 1. Check inputs\n self.check_inputs(\n prompt,\n prompt_2,\n height,\n width,\n strength,\n callback_steps,\n negative_prompt,\n negative_prompt_2,\n prompt_embeds,\n negative_prompt_embeds,\n )\n\n # 2. Define call parameters\n if prompt is not None and isinstance(prompt, str):\n batch_size = 1\n elif prompt is not None and isinstance(prompt, list):\n batch_size = len(prompt)\n else:\n batch_size = prompt_embeds.shape[0]\n\n device = self._execution_device\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\n # corresponds to doing no classifier free guidance.\n do_classifier_free_guidance = guidance_scale > 1.0\n\n # 3. Encode input prompt\n text_encoder_lora_scale = (\n cross_attention_kwargs.get(\"scale\", None) if cross_attention_kwargs is not None else None\n )\n\n (\n prompt_embeds,\n negative_prompt_embeds,\n pooled_prompt_embeds,\n negative_pooled_prompt_embeds,\n ) = self.encode_prompt(\n prompt=prompt,\n prompt_2=prompt_2,\n device=device,\n num_images_per_prompt=num_images_per_prompt,\n do_classifier_free_guidance=do_classifier_free_guidance,\n negative_prompt=negative_prompt,\n negative_prompt_2=negative_prompt_2,\n prompt_embeds=prompt_embeds,\n negative_prompt_embeds=negative_prompt_embeds,\n pooled_prompt_embeds=pooled_prompt_embeds,\n negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,\n lora_scale=text_encoder_lora_scale,\n )\n\n # 4. set timesteps\n def denoising_value_valid(dnv):\n return isinstance(denoising_end, float) and 0 < dnv < 1\n\n self.scheduler.set_timesteps(num_inference_steps, device=device)\n timesteps, num_inference_steps = self.get_timesteps(\n num_inference_steps, strength, device, denoising_start=denoising_start if denoising_value_valid else None\n )\n # check that number of inference steps is not < 1 - as this doesn't make sense\n if num_inference_steps < 1:\n raise ValueError(\n f\"After adjusting the num_inference_steps by strength parameter: {strength}, the number of pipeline\"\n f\"steps is {num_inference_steps} which is < 1 and not appropriate for this pipeline.\"\n )\n # at which timestep to set the initial noise (n.b. 50% if strength is 0.5)\n latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)\n # create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise\n is_strength_max = strength == 1.0\n\n # 5. Preprocess mask and image\n init_image = self.image_processor.preprocess(image, height=height, width=width)\n init_image = init_image.to(dtype=torch.float32)\n\n mask = self.mask_processor.preprocess(mask_image, height=height, width=width)\n\n if masked_image_latents is not None:\n masked_image = masked_image_latents\n elif init_image.shape[1] == 4:\n # if images are in latent space, we can't mask it\n masked_image = None\n else:\n masked_image = init_image * (mask < 0.5)\n\n # 6. Prepare latent variables\n num_channels_latents = self.vae.config.latent_channels\n num_channels_unet = self.unet.config.in_channels\n return_image_latents = num_channels_unet == 4\n\n # add_noise = True if denoising_start is None else False\n latents_outputs = self.prepare_latents(\n batch_size * num_images_per_prompt,\n num_channels_latents,\n height,\n width,\n prompt_embeds.dtype,\n device,\n generator,\n latents,\n image=init_image,\n timestep=latent_timestep,\n is_strength_max=is_strength_max,\n return_noise=True,\n return_image_latents=return_image_latents,\n newx=newx,\n newy=newy,\n newr=newr,\n current_seed=current_seed,\n use_noise_moving=use_noise_moving,\n )\n\n if return_image_latents:\n latents, noise, image_latents = latents_outputs\n else:\n latents, noise = latents_outputs\n\n # 7. Prepare mask latent variables\n mask, masked_image_latents = self.prepare_mask_latents(\n mask,\n masked_image,\n batch_size * num_images_per_prompt,\n height,\n width,\n prompt_embeds.dtype,\n device,\n generator,\n do_classifier_free_guidance,\n )\n\n # 8. Check that sizes of mask, masked image and latents match\n if num_channels_unet == 9:\n # default case for runwayml/stable-diffusion-inpainting\n num_channels_mask = mask.shape[1]\n num_channels_masked_image = masked_image_latents.shape[1]\n if num_channels_latents + num_channels_mask + num_channels_masked_image != self.unet.config.in_channels:\n raise ValueError(\n f\"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects\"\n f\" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +\"\n f\" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image}\"\n f\" = {num_channels_latents+num_channels_masked_image+num_channels_mask}. Please verify the config of\"\n \" `pipeline.unet` or your `mask_image` or `image` input.\"\n )\n elif num_channels_unet != 4:\n raise ValueError(\n f\"The unet {self.unet.__class__} should have either 4 or 9 input channels, not {self.unet.config.in_channels}.\"\n )\n # 8.1 Prepare extra step kwargs.\n extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)\n\n # 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline\n height, width = latents.shape[-2:]\n height = height * self.vae_scale_factor\n width = width * self.vae_scale_factor\n\n original_size = original_size or (height, width)\n target_size = target_size or (height, width)\n\n # 10. Prepare added time ids & embeddings\n if negative_original_size is None:\n negative_original_size = original_size\n if negative_target_size is None:\n negative_target_size = target_size\n\n add_text_embeds = pooled_prompt_embeds\n add_time_ids, add_neg_time_ids = self._get_add_time_ids(\n original_size,\n crops_coords_top_left,\n target_size,\n aesthetic_score,\n negative_aesthetic_score,\n negative_original_size,\n negative_crops_coords_top_left,\n negative_target_size,\n dtype=prompt_embeds.dtype,\n )\n add_time_ids = add_time_ids.repeat(batch_size * num_images_per_prompt, 1)\n\n if do_classifier_free_guidance:\n prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)\n add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0)\n add_neg_time_ids = add_neg_time_ids.repeat(batch_size * num_images_per_prompt, 1)\n add_time_ids = torch.cat([add_neg_time_ids, add_time_ids], dim=0)\n\n prompt_embeds = prompt_embeds.to(device)\n add_text_embeds = add_text_embeds.to(device)\n add_time_ids = add_time_ids.to(device)\n\n # 11. Denoising loop\n num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0)\n\n if (\n denoising_end is not None\n and denoising_start is not None\n and denoising_value_valid(denoising_end)\n and denoising_value_valid(denoising_start)\n and denoising_start >= denoising_end\n ):\n raise ValueError(\n f\"`denoising_start`: {denoising_start} cannot be larger than or equal to `denoising_end`: \"\n + f\" {denoising_end} when using type float.\"\n )\n elif denoising_end is not None and denoising_value_valid(denoising_end):\n discrete_timestep_cutoff = int(\n round(\n self.scheduler.config.num_train_timesteps\n - (denoising_end * self.scheduler.config.num_train_timesteps)\n )\n )\n num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))\n timesteps = timesteps[:num_inference_steps]\n\n with self.progress_bar(total=num_inference_steps) as progress_bar:\n for i, t in enumerate(timesteps):\n # expand the latents if we are doing classifier free guidance\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\n\n # concat latents, mask, masked_image_latents in the channel dimension\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\n\n if num_channels_unet == 9:\n latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)\n\n # predict the noise residual\n added_cond_kwargs = {\"text_embeds\": add_text_embeds, \"time_ids\": add_time_ids}\n noise_pred = self.unet(\n latent_model_input,\n t,\n encoder_hidden_states=prompt_embeds,\n cross_attention_kwargs=cross_attention_kwargs,\n added_cond_kwargs=added_cond_kwargs,\n return_dict=False,\n )[0]\n\n # perform guidance\n if do_classifier_free_guidance:\n noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\n noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\n\n if do_classifier_free_guidance and guidance_rescale > 0.0:\n # Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf\n noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale)\n\n # compute the previous noisy sample x_t -> x_t-1\n latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]\n\n if num_channels_unet == 4:\n init_latents_proper = image_latents[:1]\n init_mask = mask[:1]\n\n if i < len(timesteps) - 1:\n noise_timestep = timesteps[i + 1]\n init_latents_proper = self.scheduler.add_noise(\n init_latents_proper, noise, torch.tensor([noise_timestep])\n )\n\n latents = (1 - init_mask) * init_latents_proper + init_mask * latents\n\n # call the callback, if provided\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\n progress_bar.update()\n if callback is not None and i % callback_steps == 0:\n callback(i, t, latents)\n\n if not output_type == \"latent\":\n # make sure the VAE is in float32 mode, as it overflows in float16\n needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast\n\n if needs_upcasting:\n self.upcast_vae()\n latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)\n\n image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]\n\n # cast back to fp16 if needed\n if needs_upcasting:\n self.vae.to(dtype=torch.float16)\n else:\n return StableDiffusionXLPipelineOutput(images=latents)\n\n # apply watermark if available\n if self.watermark is not None:\n image = self.watermark.apply_watermark(image)\n\n image = self.image_processor.postprocess(image, output_type=output_type)\n\n # Offload all models\n self.maybe_free_model_hooks()\n\n if not return_dict:\n return (image,)\n\n return StableDiffusionXLPipelineOutput(images=image)"},{"identifier":"SAMPLERS","path":"relighting/argument.py","snippet":"SAMPLERS = {\n \"ddim\": DDIMScheduler,\n \"ddpm\": DDPMScheduler,\n \"unipc\": UniPCMultistepScheduler,\n}"},{"identifier":"VAE_MODELS","path":"relighting/argument.py","snippet":"VAE_MODELS = {\n \"sdxl\": \"madebyollin/sdxl-vae-fp16-fix\",\n \"sdxl_fast\": \"madebyollin/sdxl-vae-fp16-fix\",\n}"},{"identifier":"DEPTH_ESTIMATOR","path":"relighting/argument.py","snippet":"DEPTH_ESTIMATOR = \"Intel/dpt-hybrid-midas\""},{"identifier":"get_control_signal_type","path":"relighting/argument.py","snippet":"def get_control_signal_type(controlnet):\n if \"normal\" in controlnet:\n return \"normal\"\n elif \"depth\" in controlnet:\n return \"depth\"\n else:\n raise NotImplementedError"},{"identifier":"estimate_scene_depth","path":"relighting/image_processor.py","snippet":"def estimate_scene_depth(image, depth_estimator):\n #image = feature_extractor(images=image, return_tensors=\"pt\").pixel_values.to(\"cuda\")\n #with torch.no_grad(), torch.autocast(\"cuda\"):\n # depth_map = depth_estimator(image).predicted_depth\n\n depth_map = depth_estimator(image)['predicted_depth']\n W, H = image.size\n depth_map = torch.nn.functional.interpolate(\n depth_map.unsqueeze(1),\n size=(H, W),\n mode=\"bicubic\",\n align_corners=False,\n )\n depth_min = torch.amin(depth_map, dim=[1, 2, 3], keepdim=True)\n depth_max = torch.amax(depth_map, dim=[1, 2, 3], keepdim=True)\n depth_map = (depth_map - depth_min) / (depth_max - depth_min)\n image = torch.cat([depth_map] * 3, dim=1)\n\n image = image.permute(0, 2, 3, 1).cpu().numpy()[0]\n image = Image.fromarray((image * 255.0).clip(0, 255).astype(np.uint8))\n return image"},{"identifier":"estimate_scene_normal","path":"relighting/image_processor.py","snippet":"def estimate_scene_normal(image, depth_estimator):\n # can be improve speed do not going back and float between numpy and torch\n normal_image = depth_estimator(image)['predicted_depth'][0]\n\n normal_image = normal_image.numpy()\n\n # upsizing image depth to match input\n hw = np.array(image).shape[:2]\n normal_image = skimage.transform.resize(normal_image, hw, preserve_range=True)\n\n image_depth = normal_image.copy()\n image_depth -= np.min(image_depth)\n image_depth /= np.max(image_depth)\n \n bg_threhold = 0.4\n\n x = cv2.Sobel(normal_image, cv2.CV_32F, 1, 0, ksize=3)\n x[image_depth < bg_threhold] = 0\n\n y = cv2.Sobel(normal_image, cv2.CV_32F, 0, 1, ksize=3)\n y[image_depth < bg_threhold] = 0\n\n z = np.ones_like(x) * np.pi * 2.0\n\n normal_image = np.stack([x, y, z], axis=2)\n normal_image /= np.sum(normal_image ** 2.0, axis=2, keepdims=True) ** 0.5\n\n # rescale back to image size\n return normal_image"},{"identifier":"merge_normal_map","path":"relighting/image_processor.py","snippet":"def merge_normal_map(normal_map, normal_ball, mask_ball, x, y):\n \"\"\"\n Merge a ball to normal map using mask\n @params\n normal_amp (np.array) - normal map of the scene [height, width, 3]\n normal_ball (np.array) - normal map of the ball [ball_height, ball_width, 3]\n mask_ball (np.array) - mask of the ball [ball_height, ball_width]\n x (int) - x position of the ball (top-left)\n y (int) - y position of the ball (top-left)\n @return\n normal_mapthe merge normal map [height, width, 3] \n \"\"\"\n result = normal_map.copy()\n\n mask_ball = mask_ball[..., None]\n ball = (normal_ball * mask_ball) # alpha blending the ball\n unball = (normal_map[y:y+normal_ball.shape[0], x:x+normal_ball.shape[1]] * (1 - mask_ball)) # alpha blending the normal map\n result[y:y+normal_ball.shape[0], x:x+normal_ball.shape[1]] = ball+unball # add them together\n return result"},{"identifier":"fill_depth_circular","path":"relighting/image_processor.py","snippet":"def fill_depth_circular(depth_image, x, y, r):\n depth_image = np.array(depth_image)\n\n for i in range(depth_image.shape[0]):\n for j in range(depth_image.shape[1]):\n xy = (i - x - r//2)**2 + (j - y - r//2)**2\n # if xy <= rr**2:\n # depth_image[j, i, :] = 255\n # depth_image[j, i, :] = int(minv + (maxv - minv) * z)\n if xy <= (r // 2)**2:\n depth_image[j, i, :] = 255\n \n depth_image = Image.fromarray(depth_image)\n return depth_image"},{"identifier":"get_ideal_normal_ball","path":"relighting/ball_processor.py","snippet":"def get_ideal_normal_ball(size, flip_x=True):\n \"\"\"\n Generate normal ball for specific size \n Normal map is x \"left\", y up, z into the screen \n (we flip X to match sobel operator)\n @params\n - size (int) - single value of height and width\n @return:\n - normal_map (np.array) - normal map [size, size, 3]\n - mask (np.array) - mask that make a valid normal map [size,size]\n \"\"\"\n # we flip x to match sobel operator\n x = torch.linspace(1, -1, size)\n y = torch.linspace(1, -1, size)\n x = x.flip(dims=(-1,)) if not flip_x else x\n\n y, x = torch.meshgrid(y, x)\n z = (1 - x**2 - y**2)\n mask = z >= 0\n\n # clean up invalid value outsize the mask\n x = x * mask\n y = y * mask\n z = z * mask\n \n # get real z value\n z = torch.sqrt(z)\n \n # clean up normal map value outside mask \n normal_map = torch.cat([x[..., None], y[..., None], z[..., None]], dim=-1)\n normal_map = normal_map.numpy()\n mask = mask.numpy()\n return normal_map, mask"},{"identifier":"crop_ball","path":"relighting/ball_processor.py","snippet":"def crop_ball(image, mask_ball, x, y, size, apply_mask=True, bg_color = (0, 0, 0)):\n if isinstance(image, Image.Image):\n result = np.array(image)\n else:\n result = image.copy()\n \n result = result[y:y+size, x:x+size]\n if apply_mask:\n result[~mask_ball] = bg_color\n return result"},{"identifier":"CustomStableDiffusionXLControlNetInpaintPipeline","path":"relighting/pipeline_xl.py","snippet":"class CustomStableDiffusionXLControlNetInpaintPipeline(StableDiffusionXLControlNetInpaintPipeline):\n @torch.no_grad()\n def __call__(\n self,\n prompt: Union[str, List[str]] = None,\n prompt_2: Optional[Union[str, List[str]]] = None,\n image: PipelineImageInput = None,\n mask_image: PipelineImageInput = None,\n control_image: Union[\n PipelineImageInput,\n List[PipelineImageInput],\n ] = None,\n height: Optional[int] = None,\n width: Optional[int] = None,\n strength: float = 0.9999,\n num_inference_steps: int = 50,\n denoising_start: Optional[float] = None,\n denoising_end: Optional[float] = None,\n guidance_scale: float = 5.0,\n negative_prompt: Optional[Union[str, List[str]]] = None,\n negative_prompt_2: Optional[Union[str, List[str]]] = None,\n num_images_per_prompt: Optional[int] = 1,\n eta: float = 0.0,\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\n latents: Optional[torch.FloatTensor] = None,\n prompt_embeds: Optional[torch.FloatTensor] = None,\n negative_prompt_embeds: Optional[torch.FloatTensor] = None,\n pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\n negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\n output_type: Optional[str] = \"pil\",\n return_dict: bool = True,\n callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,\n callback_steps: int = 1,\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\n controlnet_conditioning_scale: Union[float, List[float]] = 1.0,\n guess_mode: bool = False,\n control_guidance_start: Union[float, List[float]] = 0.0,\n control_guidance_end: Union[float, List[float]] = 1.0,\n guidance_rescale: float = 0.0,\n original_size: Tuple[int, int] = None,\n crops_coords_top_left: Tuple[int, int] = (0, 0),\n target_size: Tuple[int, int] = None,\n aesthetic_score: float = 6.0,\n negative_aesthetic_score: float = 2.5,\n newx: int = 0,\n newy: int = 0,\n newr: int = 256,\n current_seed=0,\n use_noise_moving=True,\n ):\n # OVERWRITE METHODS\n self.prepare_mask_latents = custom_prepare_mask_latents.__get__(self, CustomStableDiffusionXLControlNetInpaintPipeline)\n self.prepare_latents = custom_prepare_latents.__get__(self, CustomStableDiffusionXLControlNetInpaintPipeline)\n\n controlnet = self.controlnet._orig_mod if is_compiled_module(self.controlnet) else self.controlnet\n\n # align format for control guidance\n if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list):\n control_guidance_start = len(control_guidance_end) * [control_guidance_start]\n elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list):\n control_guidance_end = len(control_guidance_start) * [control_guidance_end]\n elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list):\n mult = len(controlnet.nets) if isinstance(controlnet, MultiControlNetModel) else 1\n control_guidance_start, control_guidance_end = mult * [control_guidance_start], mult * [\n control_guidance_end\n ]\n\n # # 0.0 Default height and width to unet\n # height = height or self.unet.config.sample_size * self.vae_scale_factor\n # width = width or self.unet.config.sample_size * self.vae_scale_factor\n\n # 0.1 align format for control guidance\n if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list):\n control_guidance_start = len(control_guidance_end) * [control_guidance_start]\n elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list):\n control_guidance_end = len(control_guidance_start) * [control_guidance_end]\n elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list):\n mult = len(controlnet.nets) if isinstance(controlnet, MultiControlNetModel) else 1\n control_guidance_start, control_guidance_end = mult * [control_guidance_start], mult * [\n control_guidance_end\n ]\n\n # 1. Check inputs\n self.check_inputs(\n prompt,\n prompt_2,\n control_image,\n strength,\n num_inference_steps,\n callback_steps,\n negative_prompt,\n negative_prompt_2,\n prompt_embeds,\n negative_prompt_embeds,\n pooled_prompt_embeds,\n negative_pooled_prompt_embeds,\n controlnet_conditioning_scale,\n control_guidance_start,\n control_guidance_end,\n )\n\n # 2. Define call parameters\n if prompt is not None and isinstance(prompt, str):\n batch_size = 1\n elif prompt is not None and isinstance(prompt, list):\n batch_size = len(prompt)\n else:\n batch_size = prompt_embeds.shape[0]\n\n device = self._execution_device\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\n # corresponds to doing no classifier free guidance.\n do_classifier_free_guidance = guidance_scale > 1.0\n\n if isinstance(controlnet, MultiControlNetModel) and isinstance(controlnet_conditioning_scale, float):\n controlnet_conditioning_scale = [controlnet_conditioning_scale] * len(controlnet.nets)\n\n # 3. Encode input prompt\n text_encoder_lora_scale = (\n cross_attention_kwargs.get(\"scale\", None) if cross_attention_kwargs is not None else None\n )\n\n (\n prompt_embeds,\n negative_prompt_embeds,\n pooled_prompt_embeds,\n negative_pooled_prompt_embeds,\n ) = self.encode_prompt(\n prompt=prompt,\n prompt_2=prompt_2,\n device=device,\n num_images_per_prompt=num_images_per_prompt,\n do_classifier_free_guidance=do_classifier_free_guidance,\n negative_prompt=negative_prompt,\n negative_prompt_2=negative_prompt_2,\n prompt_embeds=prompt_embeds,\n negative_prompt_embeds=negative_prompt_embeds,\n pooled_prompt_embeds=pooled_prompt_embeds,\n negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,\n lora_scale=text_encoder_lora_scale,\n )\n\n # 4. set timesteps\n def denoising_value_valid(dnv):\n return isinstance(denoising_end, float) and 0 < dnv < 1\n\n self.scheduler.set_timesteps(num_inference_steps, device=device)\n timesteps, num_inference_steps = self.get_timesteps(\n num_inference_steps, strength, device, denoising_start=denoising_start if denoising_value_valid else None\n )\n # check that number of inference steps is not < 1 - as this doesn't make sense\n if num_inference_steps < 1:\n raise ValueError(\n f\"After adjusting the num_inference_steps by strength parameter: {strength}, the number of pipeline\"\n f\"steps is {num_inference_steps} which is < 1 and not appropriate for this pipeline.\"\n )\n # at which timestep to set the initial noise (n.b. 50% if strength is 0.5)\n latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)\n # create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise\n is_strength_max = strength == 1.0\n\n # 5. Preprocess mask and image - resizes image and mask w.r.t height and width\n # 5.1 Prepare init image\n init_image = self.image_processor.preprocess(image, height=height, width=width)\n init_image = init_image.to(dtype=torch.float32)\n\n # 5.2 Prepare control images\n if isinstance(controlnet, ControlNetModel):\n control_image = self.prepare_control_image(\n image=control_image,\n width=width,\n height=height,\n batch_size=batch_size * num_images_per_prompt,\n num_images_per_prompt=num_images_per_prompt,\n device=device,\n dtype=controlnet.dtype,\n do_classifier_free_guidance=do_classifier_free_guidance,\n guess_mode=guess_mode,\n )\n elif isinstance(controlnet, MultiControlNetModel):\n control_images = []\n\n for control_image_ in control_image:\n control_image_ = self.prepare_control_image(\n image=control_image_,\n width=width,\n height=height,\n batch_size=batch_size * num_images_per_prompt,\n num_images_per_prompt=num_images_per_prompt,\n device=device,\n dtype=controlnet.dtype,\n do_classifier_free_guidance=do_classifier_free_guidance,\n guess_mode=guess_mode,\n )\n\n control_images.append(control_image_)\n\n control_image = control_images\n else:\n raise ValueError(f\"{controlnet.__class__} is not supported.\")\n\n # 5.3 Prepare mask\n mask = self.mask_processor.preprocess(mask_image, height=height, width=width)\n\n masked_image = init_image * (mask < 0.5)\n _, _, height, width = init_image.shape\n\n # 6. Prepare latent variables\n num_channels_latents = self.vae.config.latent_channels\n num_channels_unet = self.unet.config.in_channels\n return_image_latents = num_channels_unet == 4\n\n add_noise = True if denoising_start is None else False\n latents_outputs = self.prepare_latents(\n batch_size * num_images_per_prompt,\n num_channels_latents,\n height,\n width,\n prompt_embeds.dtype,\n device,\n generator,\n latents,\n image=init_image,\n timestep=latent_timestep,\n is_strength_max=is_strength_max,\n return_noise=True,\n return_image_latents=return_image_latents,\n newx=newx,\n newy=newy,\n newr=newr,\n current_seed=current_seed,\n use_noise_moving=use_noise_moving,\n )\n\n if return_image_latents:\n latents, noise, image_latents = latents_outputs\n else:\n latents, noise = latents_outputs\n\n # 7. Prepare mask latent variables\n mask, masked_image_latents = self.prepare_mask_latents(\n mask,\n masked_image,\n batch_size * num_images_per_prompt,\n height,\n width,\n prompt_embeds.dtype,\n device,\n generator,\n do_classifier_free_guidance,\n )\n\n # 8. Check that sizes of mask, masked image and latents match\n if num_channels_unet == 9:\n # default case for runwayml/stable-diffusion-inpainting\n num_channels_mask = mask.shape[1]\n num_channels_masked_image = masked_image_latents.shape[1]\n if num_channels_latents + num_channels_mask + num_channels_masked_image != self.unet.config.in_channels:\n raise ValueError(\n f\"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects\"\n f\" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +\"\n f\" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image}\"\n f\" = {num_channels_latents+num_channels_masked_image+num_channels_mask}. Please verify the config of\"\n \" `pipeline.unet` or your `mask_image` or `image` input.\"\n )\n elif num_channels_unet != 4:\n raise ValueError(\n f\"The unet {self.unet.__class__} should have either 4 or 9 input channels, not {self.unet.config.in_channels}.\"\n )\n # 8.1 Prepare extra step kwargs.\n extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)\n\n # 8.2 Create tensor stating which controlnets to keep\n controlnet_keep = []\n for i in range(len(timesteps)):\n keeps = [\n 1.0 - float(i / len(timesteps) < s or (i + 1) / len(timesteps) > e)\n for s, e in zip(control_guidance_start, control_guidance_end)\n ]\n if isinstance(self.controlnet, MultiControlNetModel):\n controlnet_keep.append(keeps)\n else:\n controlnet_keep.append(keeps[0])\n\n # 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline\n height, width = latents.shape[-2:]\n height = height * self.vae_scale_factor\n width = width * self.vae_scale_factor\n\n original_size = original_size or (height, width)\n target_size = target_size or (height, width)\n\n # 10. Prepare added time ids & embeddings\n add_text_embeds = pooled_prompt_embeds\n add_time_ids, add_neg_time_ids = self._get_add_time_ids(\n original_size,\n crops_coords_top_left,\n target_size,\n aesthetic_score,\n negative_aesthetic_score,\n dtype=prompt_embeds.dtype,\n )\n add_time_ids = add_time_ids.repeat(batch_size * num_images_per_prompt, 1)\n\n if do_classifier_free_guidance:\n prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)\n add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0)\n add_neg_time_ids = add_neg_time_ids.repeat(batch_size * num_images_per_prompt, 1)\n add_time_ids = torch.cat([add_neg_time_ids, add_time_ids], dim=0)\n\n prompt_embeds = prompt_embeds.to(device)\n add_text_embeds = add_text_embeds.to(device)\n add_time_ids = add_time_ids.to(device)\n\n # 11. Denoising loop\n num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0)\n\n if (\n denoising_end is not None\n and denoising_start is not None\n and denoising_value_valid(denoising_end)\n and denoising_value_valid(denoising_start)\n and denoising_start >= denoising_end\n ):\n raise ValueError(\n f\"`denoising_start`: {denoising_start} cannot be larger than or equal to `denoising_end`: \"\n + f\" {denoising_end} when using type float.\"\n )\n elif denoising_end is not None and denoising_value_valid(denoising_end):\n discrete_timestep_cutoff = int(\n round(\n self.scheduler.config.num_train_timesteps\n - (denoising_end * self.scheduler.config.num_train_timesteps)\n )\n )\n num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))\n timesteps = timesteps[:num_inference_steps]\n\n with self.progress_bar(total=num_inference_steps) as progress_bar:\n for i, t in enumerate(timesteps):\n # expand the latents if we are doing classifier free guidance\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\n\n # concat latents, mask, masked_image_latents in the channel dimension\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\n\n added_cond_kwargs = {\"text_embeds\": add_text_embeds, \"time_ids\": add_time_ids}\n\n # controlnet(s) inference\n if guess_mode and do_classifier_free_guidance:\n # Infer ControlNet only for the conditional batch.\n control_model_input = latents\n control_model_input = self.scheduler.scale_model_input(control_model_input, t)\n controlnet_prompt_embeds = prompt_embeds.chunk(2)[1]\n controlnet_added_cond_kwargs = {\n \"text_embeds\": add_text_embeds.chunk(2)[1],\n \"time_ids\": add_time_ids.chunk(2)[1],\n }\n else:\n control_model_input = latent_model_input\n controlnet_prompt_embeds = prompt_embeds\n controlnet_added_cond_kwargs = added_cond_kwargs\n\n if isinstance(controlnet_keep[i], list):\n cond_scale = [c * s for c, s in zip(controlnet_conditioning_scale, controlnet_keep[i])]\n else:\n controlnet_cond_scale = controlnet_conditioning_scale\n if isinstance(controlnet_cond_scale, list):\n controlnet_cond_scale = controlnet_cond_scale[0]\n cond_scale = controlnet_cond_scale * controlnet_keep[i]\n\n # # Resize control_image to match the size of the input to the controlnet\n # if control_image.shape[-2:] != control_model_input.shape[-2:]:\n # control_image = F.interpolate(control_image, size=control_model_input.shape[-2:], mode=\"bilinear\", align_corners=False)\n\n down_block_res_samples, mid_block_res_sample = self.controlnet(\n control_model_input,\n t,\n encoder_hidden_states=controlnet_prompt_embeds,\n controlnet_cond=control_image,\n conditioning_scale=cond_scale,\n guess_mode=guess_mode,\n added_cond_kwargs=controlnet_added_cond_kwargs,\n return_dict=False,\n )\n\n if guess_mode and do_classifier_free_guidance:\n # Infered ControlNet only for the conditional batch.\n # To apply the output of ControlNet to both the unconditional and conditional batches,\n # add 0 to the unconditional batch to keep it unchanged.\n down_block_res_samples = [torch.cat([torch.zeros_like(d), d]) for d in down_block_res_samples]\n mid_block_res_sample = torch.cat([torch.zeros_like(mid_block_res_sample), mid_block_res_sample])\n\n if num_channels_unet == 9:\n latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)\n\n # predict the noise residual\n noise_pred = self.unet(\n latent_model_input,\n t,\n encoder_hidden_states=prompt_embeds,\n cross_attention_kwargs=cross_attention_kwargs,\n down_block_additional_residuals=down_block_res_samples,\n mid_block_additional_residual=mid_block_res_sample,\n added_cond_kwargs=added_cond_kwargs,\n return_dict=False,\n )[0]\n\n # perform guidance\n if do_classifier_free_guidance:\n noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\n noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\n\n if do_classifier_free_guidance and guidance_rescale > 0.0:\n print(\"rescale: \", guidance_rescale)\n # Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf\n noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale)\n\n # compute the previous noisy sample x_t -> x_t-1\n latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]\n\n if num_channels_unet == 4:\n init_latents_proper = image_latents[:1]\n init_mask = mask[:1]\n\n if i < len(timesteps) - 1:\n noise_timestep = timesteps[i + 1]\n init_latents_proper = self.scheduler.add_noise(\n init_latents_proper, noise, torch.tensor([noise_timestep])\n )\n\n latents = (1 - init_mask) * init_latents_proper + init_mask * latents\n\n # call the callback, if provided\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\n progress_bar.update()\n if callback is not None and i % callback_steps == 0:\n callback(i, t, latents)\n\n # make sure the VAE is in float32 mode, as it overflows in float16\n if self.vae.dtype == torch.float16 and self.vae.config.force_upcast:\n self.upcast_vae()\n latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)\n\n # If we do sequential model offloading, let's offload unet and controlnet\n # manually for max memory savings\n if hasattr(self, \"final_offload_hook\") and self.final_offload_hook is not None:\n self.unet.to(\"cpu\")\n self.controlnet.to(\"cpu\")\n torch.cuda.empty_cache()\n\n if not output_type == \"latent\":\n image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]\n else:\n return StableDiffusionXLPipelineOutput(images=latents)\n\n # apply watermark if available\n if self.watermark is not None:\n image = self.watermark.apply_watermark(image)\n\n image = self.image_processor.postprocess(image, output_type=output_type)\n\n # Offload last model to CPU\n if hasattr(self, \"final_offload_hook\") and self.final_offload_hook is not None:\n self.final_offload_hook.offload()\n\n if not return_dict:\n return (image,)\n\n return StableDiffusionXLPipelineOutput(images=image)"}],"string":"[\n {\n \"identifier\": \"CustomStableDiffusionControlNetInpaintPipeline\",\n \"path\": \"relighting/pipeline.py\",\n \"snippet\": \"class CustomStableDiffusionControlNetInpaintPipeline(StableDiffusionControlNetInpaintPipeline):\\n @torch.no_grad()\\n def __call__(\\n self,\\n prompt: Union[str, List[str]] = None,\\n image: PipelineImageInput = None,\\n mask_image: PipelineImageInput = None,\\n control_image: PipelineImageInput = None,\\n height: Optional[int] = None,\\n width: Optional[int] = None,\\n strength: float = 1.0,\\n num_inference_steps: int = 50,\\n guidance_scale: float = 7.5,\\n negative_prompt: Optional[Union[str, List[str]]] = None,\\n num_images_per_prompt: Optional[int] = 1,\\n eta: float = 0.0,\\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\\n latents: Optional[torch.FloatTensor] = None,\\n prompt_embeds: Optional[torch.FloatTensor] = None,\\n negative_prompt_embeds: Optional[torch.FloatTensor] = None,\\n output_type: Optional[str] = \\\"pil\\\",\\n return_dict: bool = True,\\n callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,\\n callback_steps: int = 1,\\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\\n controlnet_conditioning_scale: Union[float, List[float]] = 0.5,\\n guess_mode: bool = False,\\n control_guidance_start: Union[float, List[float]] = 0.0,\\n control_guidance_end: Union[float, List[float]] = 1.0,\\n newx: int = 0,\\n newy: int = 0,\\n newr: int = 256,\\n current_seed=0,\\n use_noise_moving=True,\\n ):\\n # OVERWRITE METHODS\\n self.prepare_mask_latents = custom_prepare_mask_latents.__get__(self, CustomStableDiffusionControlNetInpaintPipeline)\\n self.prepare_latents = custom_prepare_latents.__get__(self, CustomStableDiffusionControlNetInpaintPipeline)\\n\\n controlnet = self.controlnet._orig_mod if is_compiled_module(self.controlnet) else self.controlnet\\n\\n # align format for control guidance\\n if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list):\\n control_guidance_start = len(control_guidance_end) * [control_guidance_start]\\n elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list):\\n control_guidance_end = len(control_guidance_start) * [control_guidance_end]\\n elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list):\\n mult = len(controlnet.nets) if isinstance(controlnet, MultiControlNetModel) else 1\\n control_guidance_start, control_guidance_end = mult * [control_guidance_start], mult * [\\n control_guidance_end\\n ]\\n\\n # 1. Check inputs. Raise error if not correct\\n self.check_inputs(\\n prompt,\\n control_image,\\n height,\\n width,\\n callback_steps,\\n negative_prompt,\\n prompt_embeds,\\n negative_prompt_embeds,\\n controlnet_conditioning_scale,\\n control_guidance_start,\\n control_guidance_end,\\n )\\n\\n # 2. Define call parameters\\n if prompt is not None and isinstance(prompt, str):\\n batch_size = 1\\n elif prompt is not None and isinstance(prompt, list):\\n batch_size = len(prompt)\\n else:\\n batch_size = prompt_embeds.shape[0]\\n\\n device = self._execution_device\\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\\n # corresponds to doing no classifier free guidance.\\n do_classifier_free_guidance = guidance_scale > 1.0\\n\\n if isinstance(controlnet, MultiControlNetModel) and isinstance(controlnet_conditioning_scale, float):\\n controlnet_conditioning_scale = [controlnet_conditioning_scale] * len(controlnet.nets)\\n\\n global_pool_conditions = (\\n controlnet.config.global_pool_conditions\\n if isinstance(controlnet, ControlNetModel)\\n else controlnet.nets[0].config.global_pool_conditions\\n )\\n guess_mode = guess_mode or global_pool_conditions\\n\\n # 3. Encode input prompt\\n text_encoder_lora_scale = (\\n cross_attention_kwargs.get(\\\"scale\\\", None) if cross_attention_kwargs is not None else None\\n )\\n prompt_embeds, negative_prompt_embeds = self.encode_prompt(\\n prompt,\\n device,\\n num_images_per_prompt,\\n do_classifier_free_guidance,\\n negative_prompt,\\n prompt_embeds=prompt_embeds,\\n negative_prompt_embeds=negative_prompt_embeds,\\n lora_scale=text_encoder_lora_scale,\\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 if do_classifier_free_guidance:\\n prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])\\n\\n # 4. Prepare image\\n if isinstance(controlnet, ControlNetModel):\\n control_image = self.prepare_control_image(\\n image=control_image,\\n width=width,\\n height=height,\\n batch_size=batch_size * num_images_per_prompt,\\n num_images_per_prompt=num_images_per_prompt,\\n device=device,\\n dtype=controlnet.dtype,\\n do_classifier_free_guidance=do_classifier_free_guidance,\\n guess_mode=guess_mode,\\n )\\n elif isinstance(controlnet, MultiControlNetModel):\\n control_images = []\\n\\n for control_image_ in control_image:\\n control_image_ = self.prepare_control_image(\\n image=control_image_,\\n width=width,\\n height=height,\\n batch_size=batch_size * num_images_per_prompt,\\n num_images_per_prompt=num_images_per_prompt,\\n device=device,\\n dtype=controlnet.dtype,\\n do_classifier_free_guidance=do_classifier_free_guidance,\\n guess_mode=guess_mode,\\n )\\n\\n control_images.append(control_image_)\\n\\n control_image = control_images\\n else:\\n assert False\\n\\n # 4. Preprocess mask and image - resizes image and mask w.r.t height and width\\n init_image = self.image_processor.preprocess(image, height=height, width=width)\\n init_image = init_image.to(dtype=torch.float32)\\n\\n mask = self.mask_processor.preprocess(mask_image, height=height, width=width)\\n\\n masked_image = init_image * (mask < 0.5)\\n _, _, height, width = init_image.shape\\n\\n # 5. Prepare timesteps\\n self.scheduler.set_timesteps(num_inference_steps, device=device)\\n timesteps, num_inference_steps = self.get_timesteps(\\n num_inference_steps=num_inference_steps, strength=strength, device=device\\n )\\n # at which timestep to set the initial noise (n.b. 50% if strength is 0.5)\\n latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)\\n # create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise\\n is_strength_max = strength == 1.0\\n\\n # 6. Prepare latent variables\\n num_channels_latents = self.vae.config.latent_channels\\n num_channels_unet = self.unet.config.in_channels\\n return_image_latents = num_channels_unet == 4\\n\\n # EDITED HERE\\n latents_outputs = self.prepare_latents(\\n batch_size * num_images_per_prompt,\\n num_channels_latents,\\n height,\\n width,\\n prompt_embeds.dtype,\\n device,\\n generator,\\n latents,\\n image=init_image,\\n timestep=latent_timestep,\\n is_strength_max=is_strength_max,\\n return_noise=True,\\n return_image_latents=return_image_latents,\\n newx=newx,\\n newy=newy,\\n newr=newr,\\n current_seed=current_seed,\\n use_noise_moving=use_noise_moving,\\n )\\n\\n if return_image_latents:\\n latents, noise, image_latents = latents_outputs\\n else:\\n latents, noise = latents_outputs\\n\\n # 7. Prepare mask latent variables\\n mask, masked_image_latents = self.prepare_mask_latents(\\n mask,\\n masked_image,\\n batch_size * num_images_per_prompt,\\n height,\\n width,\\n prompt_embeds.dtype,\\n device,\\n generator,\\n do_classifier_free_guidance,\\n )\\n\\n # 7. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline\\n extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)\\n\\n # 7.1 Create tensor stating which controlnets to keep\\n controlnet_keep = []\\n for i in range(len(timesteps)):\\n keeps = [\\n 1.0 - float(i / len(timesteps) < s or (i + 1) / len(timesteps) > e)\\n for s, e in zip(control_guidance_start, control_guidance_end)\\n ]\\n controlnet_keep.append(keeps[0] if isinstance(controlnet, ControlNetModel) else keeps)\\n\\n # 8. Denoising loop\\n num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order\\n with self.progress_bar(total=num_inference_steps) as progress_bar:\\n for i, t in enumerate(timesteps):\\n # expand the latents if we are doing classifier free guidance\\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\\n\\n # controlnet(s) inference\\n if guess_mode and do_classifier_free_guidance:\\n # Infer ControlNet only for the conditional batch.\\n control_model_input = latents\\n control_model_input = self.scheduler.scale_model_input(control_model_input, t)\\n controlnet_prompt_embeds = prompt_embeds.chunk(2)[1]\\n else:\\n control_model_input = latent_model_input\\n controlnet_prompt_embeds = prompt_embeds\\n\\n if isinstance(controlnet_keep[i], list):\\n cond_scale = [c * s for c, s in zip(controlnet_conditioning_scale, controlnet_keep[i])]\\n else:\\n controlnet_cond_scale = controlnet_conditioning_scale\\n if isinstance(controlnet_cond_scale, list):\\n controlnet_cond_scale = controlnet_cond_scale[0]\\n cond_scale = controlnet_cond_scale * controlnet_keep[i]\\n\\n down_block_res_samples, mid_block_res_sample = self.controlnet(\\n control_model_input,\\n t,\\n encoder_hidden_states=controlnet_prompt_embeds,\\n controlnet_cond=control_image,\\n conditioning_scale=cond_scale,\\n guess_mode=guess_mode,\\n return_dict=False,\\n )\\n\\n if guess_mode and do_classifier_free_guidance:\\n # Infered ControlNet only for the conditional batch.\\n # To apply the output of ControlNet to both the unconditional and conditional batches,\\n # add 0 to the unconditional batch to keep it unchanged.\\n down_block_res_samples = [torch.cat([torch.zeros_like(d), d]) for d in down_block_res_samples]\\n mid_block_res_sample = torch.cat([torch.zeros_like(mid_block_res_sample), mid_block_res_sample])\\n\\n # predict the noise residual\\n if num_channels_unet == 9:\\n latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)\\n\\n noise_pred = self.unet(\\n latent_model_input,\\n t,\\n encoder_hidden_states=prompt_embeds,\\n cross_attention_kwargs=cross_attention_kwargs,\\n down_block_additional_residuals=down_block_res_samples,\\n mid_block_additional_residual=mid_block_res_sample,\\n return_dict=False,\\n )[0]\\n\\n # perform guidance\\n if do_classifier_free_guidance:\\n noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\\n noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\\n\\n # compute the previous noisy sample x_t -> x_t-1\\n latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]\\n\\n if num_channels_unet == 4:\\n init_latents_proper = image_latents[:1]\\n init_mask = mask[:1]\\n\\n if i < len(timesteps) - 1:\\n noise_timestep = timesteps[i + 1]\\n init_latents_proper = self.scheduler.add_noise(\\n init_latents_proper, noise, torch.tensor([noise_timestep])\\n )\\n\\n latents = (1 - init_mask) * init_latents_proper + init_mask * latents\\n\\n # call the callback, if provided\\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\\n progress_bar.update()\\n if callback is not None and i % callback_steps == 0:\\n callback(i, t, latents)\\n\\n # If we do sequential model offloading, let's offload unet and controlnet\\n # manually for max memory savings\\n if hasattr(self, \\\"final_offload_hook\\\") and self.final_offload_hook is not None:\\n self.unet.to(\\\"cpu\\\")\\n self.controlnet.to(\\\"cpu\\\")\\n torch.cuda.empty_cache()\\n\\n if not output_type == \\\"latent\\\":\\n image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]\\n image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)\\n else:\\n image = latents\\n has_nsfw_concept = None\\n\\n if has_nsfw_concept is None:\\n do_denormalize = [True] * image.shape[0]\\n else:\\n do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]\\n\\n image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)\\n\\n # Offload all models\\n self.maybe_free_model_hooks()\\n\\n if not return_dict:\\n return (image, has_nsfw_concept)\\n\\n return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)\"\n },\n {\n \"identifier\": \"CustomStableDiffusionInpaintPipeline\",\n \"path\": \"relighting/pipeline_inpaintonly.py\",\n \"snippet\": \"class CustomStableDiffusionInpaintPipeline(StableDiffusionInpaintPipeline):\\n @torch.no_grad()\\n def __call__(\\n self,\\n prompt: Union[str, List[str]] = None,\\n image: PipelineImageInput = None,\\n mask_image: PipelineImageInput = None,\\n masked_image_latents: torch.FloatTensor = None,\\n height: Optional[int] = None,\\n width: Optional[int] = None,\\n strength: float = 1.0,\\n num_inference_steps: int = 50,\\n guidance_scale: float = 7.5,\\n negative_prompt: Optional[Union[str, List[str]]] = None,\\n num_images_per_prompt: Optional[int] = 1,\\n eta: float = 0.0,\\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\\n latents: Optional[torch.FloatTensor] = None,\\n prompt_embeds: Optional[torch.FloatTensor] = None,\\n negative_prompt_embeds: Optional[torch.FloatTensor] = None,\\n output_type: Optional[str] = \\\"pil\\\",\\n return_dict: bool = True,\\n callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,\\n callback_steps: int = 1,\\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\\n newx: int = 0,\\n newy: int = 0,\\n newr: int = 256,\\n current_seed=0,\\n use_noise_moving=True,\\n ):\\n # OVERWRITE METHODS\\n self.prepare_mask_latents = custom_prepare_mask_latents.__get__(self, CustomStableDiffusionInpaintPipeline)\\n self.prepare_latents = custom_prepare_latents.__get__(self, CustomStableDiffusionInpaintPipeline)\\n\\n # 0. Default height and width to unet\\n height = height or self.unet.config.sample_size * self.vae_scale_factor\\n width = width or self.unet.config.sample_size * self.vae_scale_factor\\n\\n # 1. Check inputs\\n self.check_inputs(\\n prompt,\\n height,\\n width,\\n strength,\\n callback_steps,\\n negative_prompt,\\n prompt_embeds,\\n negative_prompt_embeds,\\n )\\n\\n # 2. Define call parameters\\n if prompt is not None and isinstance(prompt, str):\\n batch_size = 1\\n elif prompt is not None and isinstance(prompt, list):\\n batch_size = len(prompt)\\n else:\\n batch_size = prompt_embeds.shape[0]\\n\\n device = self._execution_device\\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\\n # corresponds to doing no classifier free guidance.\\n do_classifier_free_guidance = guidance_scale > 1.0\\n\\n # 3. Encode input prompt\\n text_encoder_lora_scale = (\\n cross_attention_kwargs.get(\\\"scale\\\", None) if cross_attention_kwargs is not None else None\\n )\\n prompt_embeds, negative_prompt_embeds = self.encode_prompt(\\n prompt,\\n device,\\n num_images_per_prompt,\\n do_classifier_free_guidance,\\n negative_prompt,\\n prompt_embeds=prompt_embeds,\\n negative_prompt_embeds=negative_prompt_embeds,\\n lora_scale=text_encoder_lora_scale,\\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 if do_classifier_free_guidance:\\n prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])\\n\\n # 4. set timesteps\\n self.scheduler.set_timesteps(num_inference_steps, device=device)\\n timesteps, num_inference_steps = self.get_timesteps(\\n num_inference_steps=num_inference_steps, strength=strength, device=device\\n )\\n # check that number of inference steps is not < 1 - as this doesn't make sense\\n if num_inference_steps < 1:\\n raise ValueError(\\n f\\\"After adjusting the num_inference_steps by strength parameter: {strength}, the number of pipeline\\\"\\n f\\\"steps is {num_inference_steps} which is < 1 and not appropriate for this pipeline.\\\"\\n )\\n # at which timestep to set the initial noise (n.b. 50% if strength is 0.5)\\n latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)\\n # create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise\\n is_strength_max = strength == 1.0\\n\\n # 5. Preprocess mask and image\\n\\n init_image = self.image_processor.preprocess(image, height=height, width=width)\\n init_image = init_image.to(dtype=torch.float32)\\n\\n # 6. Prepare latent variables\\n num_channels_latents = self.vae.config.latent_channels\\n num_channels_unet = self.unet.config.in_channels\\n return_image_latents = num_channels_unet == 4\\n\\n latents_outputs = self.prepare_latents(\\n batch_size * num_images_per_prompt,\\n num_channels_latents,\\n height,\\n width,\\n prompt_embeds.dtype,\\n device,\\n generator,\\n latents,\\n image=init_image,\\n timestep=latent_timestep,\\n is_strength_max=is_strength_max,\\n return_noise=True,\\n return_image_latents=return_image_latents,\\n newx=newx,\\n newy=newy,\\n newr=newr,\\n current_seed=current_seed,\\n use_noise_moving=use_noise_moving,\\n )\\n\\n if return_image_latents:\\n latents, noise, image_latents = latents_outputs\\n else:\\n latents, noise = latents_outputs\\n\\n # 7. Prepare mask latent variables\\n mask_condition = self.mask_processor.preprocess(mask_image, height=height, width=width)\\n\\n if masked_image_latents is None:\\n masked_image = init_image * (mask_condition < 0.5)\\n else:\\n masked_image = masked_image_latents\\n\\n mask, masked_image_latents = self.prepare_mask_latents(\\n mask_condition,\\n masked_image,\\n batch_size * num_images_per_prompt,\\n height,\\n width,\\n prompt_embeds.dtype,\\n device,\\n generator,\\n do_classifier_free_guidance,\\n )\\n\\n # 8. Check that sizes of mask, masked image and latents match\\n if num_channels_unet == 9:\\n # default case for runwayml/stable-diffusion-inpainting\\n num_channels_mask = mask.shape[1]\\n num_channels_masked_image = masked_image_latents.shape[1]\\n if num_channels_latents + num_channels_mask + num_channels_masked_image != self.unet.config.in_channels:\\n raise ValueError(\\n f\\\"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects\\\"\\n f\\\" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +\\\"\\n f\\\" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image}\\\"\\n f\\\" = {num_channels_latents+num_channels_masked_image+num_channels_mask}. Please verify the config of\\\"\\n \\\" `pipeline.unet` or your `mask_image` or `image` input.\\\"\\n )\\n elif num_channels_unet != 4:\\n raise ValueError(\\n f\\\"The unet {self.unet.__class__} should have either 4 or 9 input channels, not {self.unet.config.in_channels}.\\\"\\n )\\n\\n # 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline\\n extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)\\n\\n # 10. Denoising loop\\n num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order\\n with self.progress_bar(total=num_inference_steps) as progress_bar:\\n for i, t in enumerate(timesteps):\\n # expand the latents if we are doing classifier free guidance\\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\\n\\n # concat latents, mask, masked_image_latents in the channel dimension\\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\\n\\n if num_channels_unet == 9:\\n latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)\\n\\n # predict the noise residual\\n noise_pred = self.unet(\\n latent_model_input,\\n t,\\n encoder_hidden_states=prompt_embeds,\\n cross_attention_kwargs=cross_attention_kwargs,\\n return_dict=False,\\n )[0]\\n\\n # perform guidance\\n if do_classifier_free_guidance:\\n noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\\n noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\\n\\n # compute the previous noisy sample x_t -> x_t-1\\n latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]\\n\\n if num_channels_unet == 4:\\n init_latents_proper = image_latents[:1]\\n init_mask = mask[:1]\\n\\n if i < len(timesteps) - 1:\\n noise_timestep = timesteps[i + 1]\\n init_latents_proper = self.scheduler.add_noise(\\n init_latents_proper, noise, torch.tensor([noise_timestep])\\n )\\n\\n latents = (1 - init_mask) * init_latents_proper + init_mask * latents\\n\\n # call the callback, if provided\\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\\n progress_bar.update()\\n if callback is not None and i % callback_steps == 0:\\n callback(i, t, latents)\\n\\n if not output_type == \\\"latent\\\":\\n condition_kwargs = {}\\n if isinstance(self.vae, AsymmetricAutoencoderKL):\\n init_image = init_image.to(device=device, dtype=masked_image_latents.dtype)\\n init_image_condition = init_image.clone()\\n init_image = self._encode_vae_image(init_image, generator=generator)\\n mask_condition = mask_condition.to(device=device, dtype=masked_image_latents.dtype)\\n condition_kwargs = {\\\"image\\\": init_image_condition, \\\"mask\\\": mask_condition}\\n image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False, **condition_kwargs)[0]\\n image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)\\n else:\\n image = latents\\n has_nsfw_concept = None\\n\\n if has_nsfw_concept is None:\\n do_denormalize = [True] * image.shape[0]\\n else:\\n do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]\\n\\n image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)\\n\\n # Offload all models\\n self.maybe_free_model_hooks()\\n\\n if not return_dict:\\n return (image, has_nsfw_concept)\\n\\n return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)\"\n },\n {\n \"identifier\": \"CustomStableDiffusionXLInpaintPipeline\",\n \"path\": \"relighting/pipeline_inpaintonly.py\",\n \"snippet\": \"class CustomStableDiffusionXLInpaintPipeline(StableDiffusionXLInpaintPipeline):\\n @torch.no_grad()\\n def __call__(\\n self,\\n prompt: Union[str, List[str]] = None,\\n prompt_2: Optional[Union[str, List[str]]] = None,\\n image: PipelineImageInput = None,\\n mask_image: PipelineImageInput = None,\\n masked_image_latents: torch.FloatTensor = None,\\n height: Optional[int] = None,\\n width: Optional[int] = None,\\n strength: float = 0.9999,\\n num_inference_steps: int = 50,\\n denoising_start: Optional[float] = None,\\n denoising_end: Optional[float] = None,\\n guidance_scale: float = 7.5,\\n negative_prompt: Optional[Union[str, List[str]]] = None,\\n negative_prompt_2: Optional[Union[str, List[str]]] = None,\\n num_images_per_prompt: Optional[int] = 1,\\n eta: float = 0.0,\\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\\n latents: Optional[torch.FloatTensor] = None,\\n prompt_embeds: Optional[torch.FloatTensor] = None,\\n negative_prompt_embeds: Optional[torch.FloatTensor] = None,\\n pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\\n negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\\n output_type: Optional[str] = \\\"pil\\\",\\n return_dict: bool = True,\\n callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,\\n callback_steps: int = 1,\\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\\n guidance_rescale: float = 0.0,\\n original_size: Tuple[int, int] = None,\\n crops_coords_top_left: Tuple[int, int] = (0, 0),\\n target_size: Tuple[int, int] = None,\\n negative_original_size: Optional[Tuple[int, int]] = None,\\n negative_crops_coords_top_left: Tuple[int, int] = (0, 0),\\n negative_target_size: Optional[Tuple[int, int]] = None,\\n aesthetic_score: float = 6.0,\\n negative_aesthetic_score: float = 2.5,\\n newx: int = 0,\\n newy: int = 0,\\n newr: int = 256,\\n current_seed=0,\\n use_noise_moving=True,\\n ):\\n # OVERWRITE METHODS\\n self.prepare_mask_latents = custom_prepare_mask_latents.__get__(self, CustomStableDiffusionXLInpaintPipeline)\\n self.prepare_latents = custom_prepare_latents.__get__(self, CustomStableDiffusionXLInpaintPipeline)\\n\\n # 0. Default height and width to unet\\n height = height or self.unet.config.sample_size * self.vae_scale_factor\\n width = width or self.unet.config.sample_size * self.vae_scale_factor\\n\\n # 1. Check inputs\\n self.check_inputs(\\n prompt,\\n prompt_2,\\n height,\\n width,\\n strength,\\n callback_steps,\\n negative_prompt,\\n negative_prompt_2,\\n prompt_embeds,\\n negative_prompt_embeds,\\n )\\n\\n # 2. Define call parameters\\n if prompt is not None and isinstance(prompt, str):\\n batch_size = 1\\n elif prompt is not None and isinstance(prompt, list):\\n batch_size = len(prompt)\\n else:\\n batch_size = prompt_embeds.shape[0]\\n\\n device = self._execution_device\\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\\n # corresponds to doing no classifier free guidance.\\n do_classifier_free_guidance = guidance_scale > 1.0\\n\\n # 3. Encode input prompt\\n text_encoder_lora_scale = (\\n cross_attention_kwargs.get(\\\"scale\\\", None) if cross_attention_kwargs is not None else None\\n )\\n\\n (\\n prompt_embeds,\\n negative_prompt_embeds,\\n pooled_prompt_embeds,\\n negative_pooled_prompt_embeds,\\n ) = self.encode_prompt(\\n prompt=prompt,\\n prompt_2=prompt_2,\\n device=device,\\n num_images_per_prompt=num_images_per_prompt,\\n do_classifier_free_guidance=do_classifier_free_guidance,\\n negative_prompt=negative_prompt,\\n negative_prompt_2=negative_prompt_2,\\n prompt_embeds=prompt_embeds,\\n negative_prompt_embeds=negative_prompt_embeds,\\n pooled_prompt_embeds=pooled_prompt_embeds,\\n negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,\\n lora_scale=text_encoder_lora_scale,\\n )\\n\\n # 4. set timesteps\\n def denoising_value_valid(dnv):\\n return isinstance(denoising_end, float) and 0 < dnv < 1\\n\\n self.scheduler.set_timesteps(num_inference_steps, device=device)\\n timesteps, num_inference_steps = self.get_timesteps(\\n num_inference_steps, strength, device, denoising_start=denoising_start if denoising_value_valid else None\\n )\\n # check that number of inference steps is not < 1 - as this doesn't make sense\\n if num_inference_steps < 1:\\n raise ValueError(\\n f\\\"After adjusting the num_inference_steps by strength parameter: {strength}, the number of pipeline\\\"\\n f\\\"steps is {num_inference_steps} which is < 1 and not appropriate for this pipeline.\\\"\\n )\\n # at which timestep to set the initial noise (n.b. 50% if strength is 0.5)\\n latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)\\n # create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise\\n is_strength_max = strength == 1.0\\n\\n # 5. Preprocess mask and image\\n init_image = self.image_processor.preprocess(image, height=height, width=width)\\n init_image = init_image.to(dtype=torch.float32)\\n\\n mask = self.mask_processor.preprocess(mask_image, height=height, width=width)\\n\\n if masked_image_latents is not None:\\n masked_image = masked_image_latents\\n elif init_image.shape[1] == 4:\\n # if images are in latent space, we can't mask it\\n masked_image = None\\n else:\\n masked_image = init_image * (mask < 0.5)\\n\\n # 6. Prepare latent variables\\n num_channels_latents = self.vae.config.latent_channels\\n num_channels_unet = self.unet.config.in_channels\\n return_image_latents = num_channels_unet == 4\\n\\n # add_noise = True if denoising_start is None else False\\n latents_outputs = self.prepare_latents(\\n batch_size * num_images_per_prompt,\\n num_channels_latents,\\n height,\\n width,\\n prompt_embeds.dtype,\\n device,\\n generator,\\n latents,\\n image=init_image,\\n timestep=latent_timestep,\\n is_strength_max=is_strength_max,\\n return_noise=True,\\n return_image_latents=return_image_latents,\\n newx=newx,\\n newy=newy,\\n newr=newr,\\n current_seed=current_seed,\\n use_noise_moving=use_noise_moving,\\n )\\n\\n if return_image_latents:\\n latents, noise, image_latents = latents_outputs\\n else:\\n latents, noise = latents_outputs\\n\\n # 7. Prepare mask latent variables\\n mask, masked_image_latents = self.prepare_mask_latents(\\n mask,\\n masked_image,\\n batch_size * num_images_per_prompt,\\n height,\\n width,\\n prompt_embeds.dtype,\\n device,\\n generator,\\n do_classifier_free_guidance,\\n )\\n\\n # 8. Check that sizes of mask, masked image and latents match\\n if num_channels_unet == 9:\\n # default case for runwayml/stable-diffusion-inpainting\\n num_channels_mask = mask.shape[1]\\n num_channels_masked_image = masked_image_latents.shape[1]\\n if num_channels_latents + num_channels_mask + num_channels_masked_image != self.unet.config.in_channels:\\n raise ValueError(\\n f\\\"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects\\\"\\n f\\\" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +\\\"\\n f\\\" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image}\\\"\\n f\\\" = {num_channels_latents+num_channels_masked_image+num_channels_mask}. Please verify the config of\\\"\\n \\\" `pipeline.unet` or your `mask_image` or `image` input.\\\"\\n )\\n elif num_channels_unet != 4:\\n raise ValueError(\\n f\\\"The unet {self.unet.__class__} should have either 4 or 9 input channels, not {self.unet.config.in_channels}.\\\"\\n )\\n # 8.1 Prepare extra step kwargs.\\n extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)\\n\\n # 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline\\n height, width = latents.shape[-2:]\\n height = height * self.vae_scale_factor\\n width = width * self.vae_scale_factor\\n\\n original_size = original_size or (height, width)\\n target_size = target_size or (height, width)\\n\\n # 10. Prepare added time ids & embeddings\\n if negative_original_size is None:\\n negative_original_size = original_size\\n if negative_target_size is None:\\n negative_target_size = target_size\\n\\n add_text_embeds = pooled_prompt_embeds\\n add_time_ids, add_neg_time_ids = self._get_add_time_ids(\\n original_size,\\n crops_coords_top_left,\\n target_size,\\n aesthetic_score,\\n negative_aesthetic_score,\\n negative_original_size,\\n negative_crops_coords_top_left,\\n negative_target_size,\\n dtype=prompt_embeds.dtype,\\n )\\n add_time_ids = add_time_ids.repeat(batch_size * num_images_per_prompt, 1)\\n\\n if do_classifier_free_guidance:\\n prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)\\n add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0)\\n add_neg_time_ids = add_neg_time_ids.repeat(batch_size * num_images_per_prompt, 1)\\n add_time_ids = torch.cat([add_neg_time_ids, add_time_ids], dim=0)\\n\\n prompt_embeds = prompt_embeds.to(device)\\n add_text_embeds = add_text_embeds.to(device)\\n add_time_ids = add_time_ids.to(device)\\n\\n # 11. Denoising loop\\n num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0)\\n\\n if (\\n denoising_end is not None\\n and denoising_start is not None\\n and denoising_value_valid(denoising_end)\\n and denoising_value_valid(denoising_start)\\n and denoising_start >= denoising_end\\n ):\\n raise ValueError(\\n f\\\"`denoising_start`: {denoising_start} cannot be larger than or equal to `denoising_end`: \\\"\\n + f\\\" {denoising_end} when using type float.\\\"\\n )\\n elif denoising_end is not None and denoising_value_valid(denoising_end):\\n discrete_timestep_cutoff = int(\\n round(\\n self.scheduler.config.num_train_timesteps\\n - (denoising_end * self.scheduler.config.num_train_timesteps)\\n )\\n )\\n num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))\\n timesteps = timesteps[:num_inference_steps]\\n\\n with self.progress_bar(total=num_inference_steps) as progress_bar:\\n for i, t in enumerate(timesteps):\\n # expand the latents if we are doing classifier free guidance\\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\\n\\n # concat latents, mask, masked_image_latents in the channel dimension\\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\\n\\n if num_channels_unet == 9:\\n latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)\\n\\n # predict the noise residual\\n added_cond_kwargs = {\\\"text_embeds\\\": add_text_embeds, \\\"time_ids\\\": add_time_ids}\\n noise_pred = self.unet(\\n latent_model_input,\\n t,\\n encoder_hidden_states=prompt_embeds,\\n cross_attention_kwargs=cross_attention_kwargs,\\n added_cond_kwargs=added_cond_kwargs,\\n return_dict=False,\\n )[0]\\n\\n # perform guidance\\n if do_classifier_free_guidance:\\n noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\\n noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\\n\\n if do_classifier_free_guidance and guidance_rescale > 0.0:\\n # Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf\\n noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale)\\n\\n # compute the previous noisy sample x_t -> x_t-1\\n latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]\\n\\n if num_channels_unet == 4:\\n init_latents_proper = image_latents[:1]\\n init_mask = mask[:1]\\n\\n if i < len(timesteps) - 1:\\n noise_timestep = timesteps[i + 1]\\n init_latents_proper = self.scheduler.add_noise(\\n init_latents_proper, noise, torch.tensor([noise_timestep])\\n )\\n\\n latents = (1 - init_mask) * init_latents_proper + init_mask * latents\\n\\n # call the callback, if provided\\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\\n progress_bar.update()\\n if callback is not None and i % callback_steps == 0:\\n callback(i, t, latents)\\n\\n if not output_type == \\\"latent\\\":\\n # make sure the VAE is in float32 mode, as it overflows in float16\\n needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast\\n\\n if needs_upcasting:\\n self.upcast_vae()\\n latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)\\n\\n image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]\\n\\n # cast back to fp16 if needed\\n if needs_upcasting:\\n self.vae.to(dtype=torch.float16)\\n else:\\n return StableDiffusionXLPipelineOutput(images=latents)\\n\\n # apply watermark if available\\n if self.watermark is not None:\\n image = self.watermark.apply_watermark(image)\\n\\n image = self.image_processor.postprocess(image, output_type=output_type)\\n\\n # Offload all models\\n self.maybe_free_model_hooks()\\n\\n if not return_dict:\\n return (image,)\\n\\n return StableDiffusionXLPipelineOutput(images=image)\"\n },\n {\n \"identifier\": \"SAMPLERS\",\n \"path\": \"relighting/argument.py\",\n \"snippet\": \"SAMPLERS = {\\n \\\"ddim\\\": DDIMScheduler,\\n \\\"ddpm\\\": DDPMScheduler,\\n \\\"unipc\\\": UniPCMultistepScheduler,\\n}\"\n },\n {\n \"identifier\": \"VAE_MODELS\",\n \"path\": \"relighting/argument.py\",\n \"snippet\": \"VAE_MODELS = {\\n \\\"sdxl\\\": \\\"madebyollin/sdxl-vae-fp16-fix\\\",\\n \\\"sdxl_fast\\\": \\\"madebyollin/sdxl-vae-fp16-fix\\\",\\n}\"\n },\n {\n \"identifier\": \"DEPTH_ESTIMATOR\",\n \"path\": \"relighting/argument.py\",\n \"snippet\": \"DEPTH_ESTIMATOR = \\\"Intel/dpt-hybrid-midas\\\"\"\n },\n {\n \"identifier\": \"get_control_signal_type\",\n \"path\": \"relighting/argument.py\",\n \"snippet\": \"def get_control_signal_type(controlnet):\\n if \\\"normal\\\" in controlnet:\\n return \\\"normal\\\"\\n elif \\\"depth\\\" in controlnet:\\n return \\\"depth\\\"\\n else:\\n raise NotImplementedError\"\n },\n {\n \"identifier\": \"estimate_scene_depth\",\n \"path\": \"relighting/image_processor.py\",\n \"snippet\": \"def estimate_scene_depth(image, depth_estimator):\\n #image = feature_extractor(images=image, return_tensors=\\\"pt\\\").pixel_values.to(\\\"cuda\\\")\\n #with torch.no_grad(), torch.autocast(\\\"cuda\\\"):\\n # depth_map = depth_estimator(image).predicted_depth\\n\\n depth_map = depth_estimator(image)['predicted_depth']\\n W, H = image.size\\n depth_map = torch.nn.functional.interpolate(\\n depth_map.unsqueeze(1),\\n size=(H, W),\\n mode=\\\"bicubic\\\",\\n align_corners=False,\\n )\\n depth_min = torch.amin(depth_map, dim=[1, 2, 3], keepdim=True)\\n depth_max = torch.amax(depth_map, dim=[1, 2, 3], keepdim=True)\\n depth_map = (depth_map - depth_min) / (depth_max - depth_min)\\n image = torch.cat([depth_map] * 3, dim=1)\\n\\n image = image.permute(0, 2, 3, 1).cpu().numpy()[0]\\n image = Image.fromarray((image * 255.0).clip(0, 255).astype(np.uint8))\\n return image\"\n },\n {\n \"identifier\": \"estimate_scene_normal\",\n \"path\": \"relighting/image_processor.py\",\n \"snippet\": \"def estimate_scene_normal(image, depth_estimator):\\n # can be improve speed do not going back and float between numpy and torch\\n normal_image = depth_estimator(image)['predicted_depth'][0]\\n\\n normal_image = normal_image.numpy()\\n\\n # upsizing image depth to match input\\n hw = np.array(image).shape[:2]\\n normal_image = skimage.transform.resize(normal_image, hw, preserve_range=True)\\n\\n image_depth = normal_image.copy()\\n image_depth -= np.min(image_depth)\\n image_depth /= np.max(image_depth)\\n \\n bg_threhold = 0.4\\n\\n x = cv2.Sobel(normal_image, cv2.CV_32F, 1, 0, ksize=3)\\n x[image_depth < bg_threhold] = 0\\n\\n y = cv2.Sobel(normal_image, cv2.CV_32F, 0, 1, ksize=3)\\n y[image_depth < bg_threhold] = 0\\n\\n z = np.ones_like(x) * np.pi * 2.0\\n\\n normal_image = np.stack([x, y, z], axis=2)\\n normal_image /= np.sum(normal_image ** 2.0, axis=2, keepdims=True) ** 0.5\\n\\n # rescale back to image size\\n return normal_image\"\n },\n {\n \"identifier\": \"merge_normal_map\",\n \"path\": \"relighting/image_processor.py\",\n \"snippet\": \"def merge_normal_map(normal_map, normal_ball, mask_ball, x, y):\\n \\\"\\\"\\\"\\n Merge a ball to normal map using mask\\n @params\\n normal_amp (np.array) - normal map of the scene [height, width, 3]\\n normal_ball (np.array) - normal map of the ball [ball_height, ball_width, 3]\\n mask_ball (np.array) - mask of the ball [ball_height, ball_width]\\n x (int) - x position of the ball (top-left)\\n y (int) - y position of the ball (top-left)\\n @return\\n normal_mapthe merge normal map [height, width, 3] \\n \\\"\\\"\\\"\\n result = normal_map.copy()\\n\\n mask_ball = mask_ball[..., None]\\n ball = (normal_ball * mask_ball) # alpha blending the ball\\n unball = (normal_map[y:y+normal_ball.shape[0], x:x+normal_ball.shape[1]] * (1 - mask_ball)) # alpha blending the normal map\\n result[y:y+normal_ball.shape[0], x:x+normal_ball.shape[1]] = ball+unball # add them together\\n return result\"\n },\n {\n \"identifier\": \"fill_depth_circular\",\n \"path\": \"relighting/image_processor.py\",\n \"snippet\": \"def fill_depth_circular(depth_image, x, y, r):\\n depth_image = np.array(depth_image)\\n\\n for i in range(depth_image.shape[0]):\\n for j in range(depth_image.shape[1]):\\n xy = (i - x - r//2)**2 + (j - y - r//2)**2\\n # if xy <= rr**2:\\n # depth_image[j, i, :] = 255\\n # depth_image[j, i, :] = int(minv + (maxv - minv) * z)\\n if xy <= (r // 2)**2:\\n depth_image[j, i, :] = 255\\n \\n depth_image = Image.fromarray(depth_image)\\n return depth_image\"\n },\n {\n \"identifier\": \"get_ideal_normal_ball\",\n \"path\": \"relighting/ball_processor.py\",\n \"snippet\": \"def get_ideal_normal_ball(size, flip_x=True):\\n \\\"\\\"\\\"\\n Generate normal ball for specific size \\n Normal map is x \\\"left\\\", y up, z into the screen \\n (we flip X to match sobel operator)\\n @params\\n - size (int) - single value of height and width\\n @return:\\n - normal_map (np.array) - normal map [size, size, 3]\\n - mask (np.array) - mask that make a valid normal map [size,size]\\n \\\"\\\"\\\"\\n # we flip x to match sobel operator\\n x = torch.linspace(1, -1, size)\\n y = torch.linspace(1, -1, size)\\n x = x.flip(dims=(-1,)) if not flip_x else x\\n\\n y, x = torch.meshgrid(y, x)\\n z = (1 - x**2 - y**2)\\n mask = z >= 0\\n\\n # clean up invalid value outsize the mask\\n x = x * mask\\n y = y * mask\\n z = z * mask\\n \\n # get real z value\\n z = torch.sqrt(z)\\n \\n # clean up normal map value outside mask \\n normal_map = torch.cat([x[..., None], y[..., None], z[..., None]], dim=-1)\\n normal_map = normal_map.numpy()\\n mask = mask.numpy()\\n return normal_map, mask\"\n },\n {\n \"identifier\": \"crop_ball\",\n \"path\": \"relighting/ball_processor.py\",\n \"snippet\": \"def crop_ball(image, mask_ball, x, y, size, apply_mask=True, bg_color = (0, 0, 0)):\\n if isinstance(image, Image.Image):\\n result = np.array(image)\\n else:\\n result = image.copy()\\n \\n result = result[y:y+size, x:x+size]\\n if apply_mask:\\n result[~mask_ball] = bg_color\\n return result\"\n },\n {\n \"identifier\": \"CustomStableDiffusionXLControlNetInpaintPipeline\",\n \"path\": \"relighting/pipeline_xl.py\",\n \"snippet\": \"class CustomStableDiffusionXLControlNetInpaintPipeline(StableDiffusionXLControlNetInpaintPipeline):\\n @torch.no_grad()\\n def __call__(\\n self,\\n prompt: Union[str, List[str]] = None,\\n prompt_2: Optional[Union[str, List[str]]] = None,\\n image: PipelineImageInput = None,\\n mask_image: PipelineImageInput = None,\\n control_image: Union[\\n PipelineImageInput,\\n List[PipelineImageInput],\\n ] = None,\\n height: Optional[int] = None,\\n width: Optional[int] = None,\\n strength: float = 0.9999,\\n num_inference_steps: int = 50,\\n denoising_start: Optional[float] = None,\\n denoising_end: Optional[float] = None,\\n guidance_scale: float = 5.0,\\n negative_prompt: Optional[Union[str, List[str]]] = None,\\n negative_prompt_2: Optional[Union[str, List[str]]] = None,\\n num_images_per_prompt: Optional[int] = 1,\\n eta: float = 0.0,\\n generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\\n latents: Optional[torch.FloatTensor] = None,\\n prompt_embeds: Optional[torch.FloatTensor] = None,\\n negative_prompt_embeds: Optional[torch.FloatTensor] = None,\\n pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\\n negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\\n output_type: Optional[str] = \\\"pil\\\",\\n return_dict: bool = True,\\n callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,\\n callback_steps: int = 1,\\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\\n controlnet_conditioning_scale: Union[float, List[float]] = 1.0,\\n guess_mode: bool = False,\\n control_guidance_start: Union[float, List[float]] = 0.0,\\n control_guidance_end: Union[float, List[float]] = 1.0,\\n guidance_rescale: float = 0.0,\\n original_size: Tuple[int, int] = None,\\n crops_coords_top_left: Tuple[int, int] = (0, 0),\\n target_size: Tuple[int, int] = None,\\n aesthetic_score: float = 6.0,\\n negative_aesthetic_score: float = 2.5,\\n newx: int = 0,\\n newy: int = 0,\\n newr: int = 256,\\n current_seed=0,\\n use_noise_moving=True,\\n ):\\n # OVERWRITE METHODS\\n self.prepare_mask_latents = custom_prepare_mask_latents.__get__(self, CustomStableDiffusionXLControlNetInpaintPipeline)\\n self.prepare_latents = custom_prepare_latents.__get__(self, CustomStableDiffusionXLControlNetInpaintPipeline)\\n\\n controlnet = self.controlnet._orig_mod if is_compiled_module(self.controlnet) else self.controlnet\\n\\n # align format for control guidance\\n if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list):\\n control_guidance_start = len(control_guidance_end) * [control_guidance_start]\\n elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list):\\n control_guidance_end = len(control_guidance_start) * [control_guidance_end]\\n elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list):\\n mult = len(controlnet.nets) if isinstance(controlnet, MultiControlNetModel) else 1\\n control_guidance_start, control_guidance_end = mult * [control_guidance_start], mult * [\\n control_guidance_end\\n ]\\n\\n # # 0.0 Default height and width to unet\\n # height = height or self.unet.config.sample_size * self.vae_scale_factor\\n # width = width or self.unet.config.sample_size * self.vae_scale_factor\\n\\n # 0.1 align format for control guidance\\n if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list):\\n control_guidance_start = len(control_guidance_end) * [control_guidance_start]\\n elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list):\\n control_guidance_end = len(control_guidance_start) * [control_guidance_end]\\n elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list):\\n mult = len(controlnet.nets) if isinstance(controlnet, MultiControlNetModel) else 1\\n control_guidance_start, control_guidance_end = mult * [control_guidance_start], mult * [\\n control_guidance_end\\n ]\\n\\n # 1. Check inputs\\n self.check_inputs(\\n prompt,\\n prompt_2,\\n control_image,\\n strength,\\n num_inference_steps,\\n callback_steps,\\n negative_prompt,\\n negative_prompt_2,\\n prompt_embeds,\\n negative_prompt_embeds,\\n pooled_prompt_embeds,\\n negative_pooled_prompt_embeds,\\n controlnet_conditioning_scale,\\n control_guidance_start,\\n control_guidance_end,\\n )\\n\\n # 2. Define call parameters\\n if prompt is not None and isinstance(prompt, str):\\n batch_size = 1\\n elif prompt is not None and isinstance(prompt, list):\\n batch_size = len(prompt)\\n else:\\n batch_size = prompt_embeds.shape[0]\\n\\n device = self._execution_device\\n # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)\\n # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`\\n # corresponds to doing no classifier free guidance.\\n do_classifier_free_guidance = guidance_scale > 1.0\\n\\n if isinstance(controlnet, MultiControlNetModel) and isinstance(controlnet_conditioning_scale, float):\\n controlnet_conditioning_scale = [controlnet_conditioning_scale] * len(controlnet.nets)\\n\\n # 3. Encode input prompt\\n text_encoder_lora_scale = (\\n cross_attention_kwargs.get(\\\"scale\\\", None) if cross_attention_kwargs is not None else None\\n )\\n\\n (\\n prompt_embeds,\\n negative_prompt_embeds,\\n pooled_prompt_embeds,\\n negative_pooled_prompt_embeds,\\n ) = self.encode_prompt(\\n prompt=prompt,\\n prompt_2=prompt_2,\\n device=device,\\n num_images_per_prompt=num_images_per_prompt,\\n do_classifier_free_guidance=do_classifier_free_guidance,\\n negative_prompt=negative_prompt,\\n negative_prompt_2=negative_prompt_2,\\n prompt_embeds=prompt_embeds,\\n negative_prompt_embeds=negative_prompt_embeds,\\n pooled_prompt_embeds=pooled_prompt_embeds,\\n negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,\\n lora_scale=text_encoder_lora_scale,\\n )\\n\\n # 4. set timesteps\\n def denoising_value_valid(dnv):\\n return isinstance(denoising_end, float) and 0 < dnv < 1\\n\\n self.scheduler.set_timesteps(num_inference_steps, device=device)\\n timesteps, num_inference_steps = self.get_timesteps(\\n num_inference_steps, strength, device, denoising_start=denoising_start if denoising_value_valid else None\\n )\\n # check that number of inference steps is not < 1 - as this doesn't make sense\\n if num_inference_steps < 1:\\n raise ValueError(\\n f\\\"After adjusting the num_inference_steps by strength parameter: {strength}, the number of pipeline\\\"\\n f\\\"steps is {num_inference_steps} which is < 1 and not appropriate for this pipeline.\\\"\\n )\\n # at which timestep to set the initial noise (n.b. 50% if strength is 0.5)\\n latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)\\n # create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise\\n is_strength_max = strength == 1.0\\n\\n # 5. Preprocess mask and image - resizes image and mask w.r.t height and width\\n # 5.1 Prepare init image\\n init_image = self.image_processor.preprocess(image, height=height, width=width)\\n init_image = init_image.to(dtype=torch.float32)\\n\\n # 5.2 Prepare control images\\n if isinstance(controlnet, ControlNetModel):\\n control_image = self.prepare_control_image(\\n image=control_image,\\n width=width,\\n height=height,\\n batch_size=batch_size * num_images_per_prompt,\\n num_images_per_prompt=num_images_per_prompt,\\n device=device,\\n dtype=controlnet.dtype,\\n do_classifier_free_guidance=do_classifier_free_guidance,\\n guess_mode=guess_mode,\\n )\\n elif isinstance(controlnet, MultiControlNetModel):\\n control_images = []\\n\\n for control_image_ in control_image:\\n control_image_ = self.prepare_control_image(\\n image=control_image_,\\n width=width,\\n height=height,\\n batch_size=batch_size * num_images_per_prompt,\\n num_images_per_prompt=num_images_per_prompt,\\n device=device,\\n dtype=controlnet.dtype,\\n do_classifier_free_guidance=do_classifier_free_guidance,\\n guess_mode=guess_mode,\\n )\\n\\n control_images.append(control_image_)\\n\\n control_image = control_images\\n else:\\n raise ValueError(f\\\"{controlnet.__class__} is not supported.\\\")\\n\\n # 5.3 Prepare mask\\n mask = self.mask_processor.preprocess(mask_image, height=height, width=width)\\n\\n masked_image = init_image * (mask < 0.5)\\n _, _, height, width = init_image.shape\\n\\n # 6. Prepare latent variables\\n num_channels_latents = self.vae.config.latent_channels\\n num_channels_unet = self.unet.config.in_channels\\n return_image_latents = num_channels_unet == 4\\n\\n add_noise = True if denoising_start is None else False\\n latents_outputs = self.prepare_latents(\\n batch_size * num_images_per_prompt,\\n num_channels_latents,\\n height,\\n width,\\n prompt_embeds.dtype,\\n device,\\n generator,\\n latents,\\n image=init_image,\\n timestep=latent_timestep,\\n is_strength_max=is_strength_max,\\n return_noise=True,\\n return_image_latents=return_image_latents,\\n newx=newx,\\n newy=newy,\\n newr=newr,\\n current_seed=current_seed,\\n use_noise_moving=use_noise_moving,\\n )\\n\\n if return_image_latents:\\n latents, noise, image_latents = latents_outputs\\n else:\\n latents, noise = latents_outputs\\n\\n # 7. Prepare mask latent variables\\n mask, masked_image_latents = self.prepare_mask_latents(\\n mask,\\n masked_image,\\n batch_size * num_images_per_prompt,\\n height,\\n width,\\n prompt_embeds.dtype,\\n device,\\n generator,\\n do_classifier_free_guidance,\\n )\\n\\n # 8. Check that sizes of mask, masked image and latents match\\n if num_channels_unet == 9:\\n # default case for runwayml/stable-diffusion-inpainting\\n num_channels_mask = mask.shape[1]\\n num_channels_masked_image = masked_image_latents.shape[1]\\n if num_channels_latents + num_channels_mask + num_channels_masked_image != self.unet.config.in_channels:\\n raise ValueError(\\n f\\\"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects\\\"\\n f\\\" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +\\\"\\n f\\\" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image}\\\"\\n f\\\" = {num_channels_latents+num_channels_masked_image+num_channels_mask}. Please verify the config of\\\"\\n \\\" `pipeline.unet` or your `mask_image` or `image` input.\\\"\\n )\\n elif num_channels_unet != 4:\\n raise ValueError(\\n f\\\"The unet {self.unet.__class__} should have either 4 or 9 input channels, not {self.unet.config.in_channels}.\\\"\\n )\\n # 8.1 Prepare extra step kwargs.\\n extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)\\n\\n # 8.2 Create tensor stating which controlnets to keep\\n controlnet_keep = []\\n for i in range(len(timesteps)):\\n keeps = [\\n 1.0 - float(i / len(timesteps) < s or (i + 1) / len(timesteps) > e)\\n for s, e in zip(control_guidance_start, control_guidance_end)\\n ]\\n if isinstance(self.controlnet, MultiControlNetModel):\\n controlnet_keep.append(keeps)\\n else:\\n controlnet_keep.append(keeps[0])\\n\\n # 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline\\n height, width = latents.shape[-2:]\\n height = height * self.vae_scale_factor\\n width = width * self.vae_scale_factor\\n\\n original_size = original_size or (height, width)\\n target_size = target_size or (height, width)\\n\\n # 10. Prepare added time ids & embeddings\\n add_text_embeds = pooled_prompt_embeds\\n add_time_ids, add_neg_time_ids = self._get_add_time_ids(\\n original_size,\\n crops_coords_top_left,\\n target_size,\\n aesthetic_score,\\n negative_aesthetic_score,\\n dtype=prompt_embeds.dtype,\\n )\\n add_time_ids = add_time_ids.repeat(batch_size * num_images_per_prompt, 1)\\n\\n if do_classifier_free_guidance:\\n prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)\\n add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0)\\n add_neg_time_ids = add_neg_time_ids.repeat(batch_size * num_images_per_prompt, 1)\\n add_time_ids = torch.cat([add_neg_time_ids, add_time_ids], dim=0)\\n\\n prompt_embeds = prompt_embeds.to(device)\\n add_text_embeds = add_text_embeds.to(device)\\n add_time_ids = add_time_ids.to(device)\\n\\n # 11. Denoising loop\\n num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0)\\n\\n if (\\n denoising_end is not None\\n and denoising_start is not None\\n and denoising_value_valid(denoising_end)\\n and denoising_value_valid(denoising_start)\\n and denoising_start >= denoising_end\\n ):\\n raise ValueError(\\n f\\\"`denoising_start`: {denoising_start} cannot be larger than or equal to `denoising_end`: \\\"\\n + f\\\" {denoising_end} when using type float.\\\"\\n )\\n elif denoising_end is not None and denoising_value_valid(denoising_end):\\n discrete_timestep_cutoff = int(\\n round(\\n self.scheduler.config.num_train_timesteps\\n - (denoising_end * self.scheduler.config.num_train_timesteps)\\n )\\n )\\n num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))\\n timesteps = timesteps[:num_inference_steps]\\n\\n with self.progress_bar(total=num_inference_steps) as progress_bar:\\n for i, t in enumerate(timesteps):\\n # expand the latents if we are doing classifier free guidance\\n latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\\n\\n # concat latents, mask, masked_image_latents in the channel dimension\\n latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\\n\\n added_cond_kwargs = {\\\"text_embeds\\\": add_text_embeds, \\\"time_ids\\\": add_time_ids}\\n\\n # controlnet(s) inference\\n if guess_mode and do_classifier_free_guidance:\\n # Infer ControlNet only for the conditional batch.\\n control_model_input = latents\\n control_model_input = self.scheduler.scale_model_input(control_model_input, t)\\n controlnet_prompt_embeds = prompt_embeds.chunk(2)[1]\\n controlnet_added_cond_kwargs = {\\n \\\"text_embeds\\\": add_text_embeds.chunk(2)[1],\\n \\\"time_ids\\\": add_time_ids.chunk(2)[1],\\n }\\n else:\\n control_model_input = latent_model_input\\n controlnet_prompt_embeds = prompt_embeds\\n controlnet_added_cond_kwargs = added_cond_kwargs\\n\\n if isinstance(controlnet_keep[i], list):\\n cond_scale = [c * s for c, s in zip(controlnet_conditioning_scale, controlnet_keep[i])]\\n else:\\n controlnet_cond_scale = controlnet_conditioning_scale\\n if isinstance(controlnet_cond_scale, list):\\n controlnet_cond_scale = controlnet_cond_scale[0]\\n cond_scale = controlnet_cond_scale * controlnet_keep[i]\\n\\n # # Resize control_image to match the size of the input to the controlnet\\n # if control_image.shape[-2:] != control_model_input.shape[-2:]:\\n # control_image = F.interpolate(control_image, size=control_model_input.shape[-2:], mode=\\\"bilinear\\\", align_corners=False)\\n\\n down_block_res_samples, mid_block_res_sample = self.controlnet(\\n control_model_input,\\n t,\\n encoder_hidden_states=controlnet_prompt_embeds,\\n controlnet_cond=control_image,\\n conditioning_scale=cond_scale,\\n guess_mode=guess_mode,\\n added_cond_kwargs=controlnet_added_cond_kwargs,\\n return_dict=False,\\n )\\n\\n if guess_mode and do_classifier_free_guidance:\\n # Infered ControlNet only for the conditional batch.\\n # To apply the output of ControlNet to both the unconditional and conditional batches,\\n # add 0 to the unconditional batch to keep it unchanged.\\n down_block_res_samples = [torch.cat([torch.zeros_like(d), d]) for d in down_block_res_samples]\\n mid_block_res_sample = torch.cat([torch.zeros_like(mid_block_res_sample), mid_block_res_sample])\\n\\n if num_channels_unet == 9:\\n latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)\\n\\n # predict the noise residual\\n noise_pred = self.unet(\\n latent_model_input,\\n t,\\n encoder_hidden_states=prompt_embeds,\\n cross_attention_kwargs=cross_attention_kwargs,\\n down_block_additional_residuals=down_block_res_samples,\\n mid_block_additional_residual=mid_block_res_sample,\\n added_cond_kwargs=added_cond_kwargs,\\n return_dict=False,\\n )[0]\\n\\n # perform guidance\\n if do_classifier_free_guidance:\\n noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\\n noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\\n\\n if do_classifier_free_guidance and guidance_rescale > 0.0:\\n print(\\\"rescale: \\\", guidance_rescale)\\n # Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf\\n noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale)\\n\\n # compute the previous noisy sample x_t -> x_t-1\\n latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]\\n\\n if num_channels_unet == 4:\\n init_latents_proper = image_latents[:1]\\n init_mask = mask[:1]\\n\\n if i < len(timesteps) - 1:\\n noise_timestep = timesteps[i + 1]\\n init_latents_proper = self.scheduler.add_noise(\\n init_latents_proper, noise, torch.tensor([noise_timestep])\\n )\\n\\n latents = (1 - init_mask) * init_latents_proper + init_mask * latents\\n\\n # call the callback, if provided\\n if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\\n progress_bar.update()\\n if callback is not None and i % callback_steps == 0:\\n callback(i, t, latents)\\n\\n # make sure the VAE is in float32 mode, as it overflows in float16\\n if self.vae.dtype == torch.float16 and self.vae.config.force_upcast:\\n self.upcast_vae()\\n latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)\\n\\n # If we do sequential model offloading, let's offload unet and controlnet\\n # manually for max memory savings\\n if hasattr(self, \\\"final_offload_hook\\\") and self.final_offload_hook is not None:\\n self.unet.to(\\\"cpu\\\")\\n self.controlnet.to(\\\"cpu\\\")\\n torch.cuda.empty_cache()\\n\\n if not output_type == \\\"latent\\\":\\n image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]\\n else:\\n return StableDiffusionXLPipelineOutput(images=latents)\\n\\n # apply watermark if available\\n if self.watermark is not None:\\n image = self.watermark.apply_watermark(image)\\n\\n image = self.image_processor.postprocess(image, output_type=output_type)\\n\\n # Offload last model to CPU\\n if hasattr(self, \\\"final_offload_hook\\\") and self.final_offload_hook is not None:\\n self.final_offload_hook.offload()\\n\\n if not return_dict:\\n return (image,)\\n\\n return StableDiffusionXLPipelineOutput(images=image)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import torch\nimport numpy as np\nimport os\nimport pickle\nfrom diffusers import ControlNetModel, AutoencoderKL\nfrom PIL import Image\nfrom tqdm.auto import tqdm\nfrom transformers import pipeline as transformers_pipeline\nfrom relighting.pipeline import CustomStableDiffusionControlNetInpaintPipeline\nfrom relighting.pipeline_inpaintonly import CustomStableDiffusionInpaintPipeline, CustomStableDiffusionXLInpaintPipeline\nfrom relighting.argument import SAMPLERS, VAE_MODELS, DEPTH_ESTIMATOR, get_control_signal_type\nfrom relighting.image_processor import (\n estimate_scene_depth,\n estimate_scene_normal,\n merge_normal_map,\n fill_depth_circular\n)\nfrom relighting.ball_processor import get_ideal_normal_ball, crop_ball\nfrom relighting.pipeline_xl import CustomStableDiffusionXLControlNetInpaintPipeline"},"token_num":{"kind":"number","value":17552,"string":"17,552"},"cropped_code":{"kind":"string","value":"\n\n\nclass NoWaterMark:\n def apply_watermark(self, *args, **kwargs):\n return args[0]\n\nclass ControlSignalGenerator():\n def __init__(self, sd_arch, control_signal_type, device):\n self.sd_arch = sd_arch\n self.control_signal_type = control_signal_type\n self.device = device\n\n def process_sd_depth(self, input_image, normal_ball=None, mask_ball=None, x=None, y=None, r=None):\n if getattr(self, 'depth_estimator', None) is None:\n self.depth_estimator = transformers_pipeline(\"depth-estimation\", device=self.device.index)\n\n control_image = self.depth_estimator(input_image)['depth']\n control_image = np.array(control_image)\n control_image = control_image[:, :, None]\n control_image = np.concatenate([control_image, control_image, control_image], axis=2)\n control_image = Image.fromarray(control_image)\n \n control_image = fill_depth_circular(control_image, x, y, r)\n return control_image\n\n def process_sdxl_depth(self, input_image, normal_ball=None, mask_ball=None, x=None, y=None, r=None):\n if getattr(self, 'depth_estimator', None) is None:\n"},"all_code":{"kind":"string","value":"\n\n\nclass NoWaterMark:\n def apply_watermark(self, *args, **kwargs):\n return args[0]\n\nclass ControlSignalGenerator():\n def __init__(self, sd_arch, control_signal_type, device):\n self.sd_arch = sd_arch\n self.control_signal_type = control_signal_type\n self.device = device\n\n def process_sd_depth(self, input_image, normal_ball=None, mask_ball=None, x=None, y=None, r=None):\n if getattr(self, 'depth_estimator', None) is None:\n self.depth_estimator = transformers_pipeline(\"depth-estimation\", device=self.device.index)\n\n control_image = self.depth_estimator(input_image)['depth']\n control_image = np.array(control_image)\n control_image = control_image[:, :, None]\n control_image = np.concatenate([control_image, control_image, control_image], axis=2)\n control_image = Image.fromarray(control_image)\n \n control_image = fill_depth_circular(control_image, x, y, r)\n return control_image\n\n def process_sdxl_depth(self, input_image, normal_ball=None, mask_ball=None, x=None, y=None, r=None):\n if getattr(self, 'depth_estimator', None) is None:"},"next_line":{"kind":"string","value":" self.depth_estimator = transformers_pipeline(\"depth-estimation\", model=DEPTH_ESTIMATOR, device=self.device.index)"},"gold_snippet_index":{"kind":"number","value":5,"string":"5"},"created_at":{"kind":"string","value":"2023-12-07 14:03:31+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5969,"cells":{"repo_name":{"kind":"string","value":"modelscope/normal-depth-diffusion"},"file_path":{"kind":"string","value":"ldm/models/diffusion/ddpm.py"},"context":{"kind":"list like","value":[{"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=[],\n image_key='image',\n colorize_nlabels=None,\n monitor=None,\n prior_model=None,\n prior_normal=None,\n using_rgb=True):\n super().__init__()\n self.image_key = image_key\n self.encoder = Encoder(**ddconfig)\n self.decoder = Decoder(**ddconfig)\n self.loss = instantiate_from_config(lossconfig)\n self.prior_model = prior_model\n self.using_rgb = using_rgb\n\n assert ddconfig['double_z']\n self.quant_conv = torch.nn.Conv2d(2 * ddconfig['z_channels'],\n 2 * embed_dim, 1)\n self.post_quant_conv = torch.nn.Conv2d(embed_dim,\n ddconfig['z_channels'], 1)\n self.embed_dim = embed_dim\n if colorize_nlabels is not None:\n assert type(colorize_nlabels) == int\n self.register_buffer('colorize',\n torch.randn(3, colorize_nlabels, 1, 1))\n if monitor is not None:\n self.monitor = monitor\n\n if prior_model is not None:\n self.prior_model = instantiate_from_config(prior_model)\n if prior_normal is not None:\n self.prior_normal = instantiate_from_config(prior_normal)\n\n if ckpt_path is not None:\n self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)\n\n def init_from_ckpt(self, path, ignore_keys=list()):\n try:\n sd = torch.load(path, map_location='cpu')['state_dict']\n except:\n sd = torch.load(path, map_location='cpu')\n\n keys = list(sd.keys())\n for k in keys:\n for ik in ignore_keys:\n if k.startswith(ik):\n print('Deleting key {} from state_dict.'.format(k))\n del sd[k]\n m, u = self.load_state_dict(sd, strict=False)\n if len(m) > 0:\n print('missing keys:')\n print(m)\n if len(u) > 0:\n print('unexpected keys:')\n print(u)\n\n print(f'Restored from {path}')\n\n def encode(self, x):\n h = self.encoder(x)\n moments = self.quant_conv(h)\n posterior = DiagonalGaussianDistribution(moments)\n return posterior\n\n def decode(self, z):\n z = self.post_quant_conv(z)\n dec = self.decoder(z)\n return dec\n\n def prior_to_eval(self):\n\n if self.prior_model is not None:\n self.prior_model.eval()\n\n if self.prior_normal is not None:\n self.prior_normal.eval()\n\n @torch.no_grad()\n def prior_inference(self, inputs, prior_inputs):\n # depth prior model\n # midas or zoe is 384 model\n prior_results = {}\n\n self.prior_to_eval()\n\n model_prior_results = self.prior_model(prior_inputs)\n prior_results.update(model_prior_results)\n\n # using normal map\n if not self.using_rgb:\n normal_prior = self.prior_normal(prior_inputs)\n prior_results.update(normal_prior)\n\n resize_prior_results = {}\n _, __, h, w = inputs.shape\n\n for key in prior_results.keys():\n resize_prior_results[key] = F.interpolate(\n prior_results[key], (w, h), mode='bilinear')\n\n if self.using_rgb:\n return torch.cat([inputs, resize_prior_results['depth']], dim=1)\n else:\n return torch.cat([\n resize_prior_results['normal'], resize_prior_results['depth']\n ],\n dim=1)\n\n def forward(self, input, sample_posterior=True):\n\n posterior = self.encode(input)\n if sample_posterior:\n z = posterior.sample()\n else:\n z = posterior.mode()\n dec = self.decode(z)\n return dec, posterior\n\n def get_input(self, batch, k):\n x = batch[k]\n if len(x.shape) == 3:\n x = x[..., None]\n x = x.permute(0, 3, 1,\n 2).to(memory_format=torch.contiguous_format).float()\n return x\n\n def training_step(self, batch, batch_idx, optimizer_idx):\n\n inputs = self.get_input(batch, self.image_key)\n if self.prior_model is not None:\n inputs = self.prior_inference(inputs, batch['prior'])\n\n reconstructions, posterior = self(inputs)\n\n if optimizer_idx == 0:\n # train encoder+decoder+logvar\n aeloss, log_dict_ae = self.loss(\n inputs,\n reconstructions,\n posterior,\n optimizer_idx,\n self.global_step,\n last_layer=self.get_last_layer(),\n split='train')\n\n self.log(\n 'rec_loss',\n log_dict_ae['train/rec_loss'],\n prog_bar=True,\n logger=True,\n on_step=True,\n on_epoch=True)\n self.log(\n 'aeloss',\n aeloss,\n prog_bar=True,\n logger=True,\n on_step=True,\n on_epoch=True)\n self.log_dict(\n log_dict_ae,\n prog_bar=False,\n logger=True,\n on_step=True,\n on_epoch=False)\n return aeloss\n\n if optimizer_idx == 1:\n # train the discriminator\n discloss, log_dict_disc = self.loss(\n inputs,\n reconstructions,\n posterior,\n optimizer_idx,\n self.global_step,\n last_layer=self.get_last_layer(),\n split='train')\n\n self.log(\n 'discloss',\n discloss,\n prog_bar=True,\n logger=True,\n on_step=True,\n on_epoch=True)\n self.log_dict(\n log_dict_disc,\n prog_bar=False,\n logger=True,\n on_step=True,\n on_epoch=False)\n return discloss\n\n def validation_step(self, batch, batch_idx):\n inputs = self.get_input(batch, self.image_key)\n reconstructions, posterior = self(inputs)\n aeloss, log_dict_ae = self.loss(\n inputs,\n reconstructions,\n posterior,\n 0,\n self.global_step,\n last_layer=self.get_last_layer(),\n split='val')\n\n discloss, log_dict_disc = self.loss(\n inputs,\n reconstructions,\n posterior,\n 1,\n self.global_step,\n last_layer=self.get_last_layer(),\n split='val')\n\n self.log('val/rec_loss', log_dict_ae['val/rec_loss'])\n self.log_dict(log_dict_ae)\n self.log_dict(log_dict_disc)\n return self.log_dict\n\n @torch.no_grad()\n def test_step(self, batch, batch_idx):\n pass\n\n @torch.no_grad()\n def sample_imgs(self, batch):\n '''using to test for sampling image\n\n '''\n inputs = self.get_input(batch, self.image_key)\n reconstructions, posterior = self(inputs)\n\n return {'samples': reconstructions}\n\n def configure_optimizers(self):\n lr = self.learning_rate\n opt_ae = torch.optim.Adam(\n list(self.encoder.parameters()) + list(self.decoder.parameters())\n + list(self.quant_conv.parameters())\n + list(self.post_quant_conv.parameters()),\n lr=lr,\n betas=(0.5, 0.9))\n opt_disc = torch.optim.Adam(\n self.loss.discriminator.parameters(), lr=lr, betas=(0.5, 0.9))\n\n return [opt_ae, opt_disc], []\n\n def get_last_layer(self):\n return self.decoder.conv_out.weight\n\n @torch.no_grad()\n def log_images(self, batch, only_inputs=False, **kwargs):\n log = dict()\n x = self.get_input(batch, self.image_key)\n x = x.to(self.device)\n if not only_inputs:\n xrec, posterior = self(x)\n xrec = repeat(xrec[:, 0, ...], 'b h w -> b c h w', c=3)\n\n if x.shape[1] > 3:\n # colorize with random projection\n assert xrec.shape[1] > 3\n x = self.to_rgb(x)\n xrec = self.to_rgb(xrec)\n samples = self.decode(torch.randn_like(posterior.sample()))\n samples = repeat(samples[:, 0, ...], 'b h w -> b c h w', c=3)\n log['samples'] = samples\n\n log['reconstructions'] = xrec\n log['inputs'] = x\n return log\n\n @torch.no_grad()\n def log_rgbd(self, batch, only_inputs=False, **kwargs):\n log = dict()\n x = self.get_input(batch, self.image_key)\n\n if x.shape[1] == 3:\n if self.prior_model is not None:\n x = self.prior_inference(x, batch['prior'])\n\n x = x.to(self.device)\n if not only_inputs:\n xrec, posterior = self(x)\n samples = self.decode(torch.randn_like(posterior.sample()))\n log['samples'] = samples\n log['reconstructions'] = xrec\n log['inputs'] = x\n return log\n\n def to_rgb(self, x):\n assert self.image_key == 'segmentation'\n if not hasattr(self, 'colorize'):\n self.register_buffer('colorize',\n torch.randn(3, x.shape[1], 1, 1).to(x))\n x = F.conv2d(x, weight=self.colorize)\n x = 2. * (x - x.min()) / (x.max() - x.min()) - 1.\n return x"},{"identifier":"IdentityFirstStage","path":"ldm/models/autoencoder.py","snippet":"class IdentityFirstStage(torch.nn.Module):\n\n def __init__(self, *args, vq_interface=False, **kwargs):\n self.vq_interface = vq_interface # TODO: Should be true by default but check to not break older stuff\n super().__init__()\n\n def encode(self, x, *args, **kwargs):\n return x\n\n def decode(self, x, *args, **kwargs):\n return x\n\n def quantize(self, x, *args, **kwargs):\n if self.vq_interface:\n return x, None, [None, None, None]\n return x\n\n def forward(self, x, *args, **kwargs):\n return x"},{"identifier":"VQModelInterface","path":"ldm/models/autoencoder.py","snippet":"class VQModelInterface(VQModel):\n\n def __init__(self, embed_dim, *args, **kwargs):\n super().__init__(embed_dim=embed_dim, *args, **kwargs)\n self.embed_dim = embed_dim\n\n def encode(self, x):\n h = self.encoder(x)\n h = self.quant_conv(h)\n return h\n\n def decode(self, h, force_not_quantize=False):\n # also go through quantization layer\n if not force_not_quantize:\n quant, emb_loss, info = self.quantize(h)\n else:\n quant = h\n quant = self.post_quant_conv(quant)\n dec = self.decoder(quant)\n return dec"},{"identifier":"DDIMSampler","path":"ldm/models/diffusion/ddim.py","snippet":"class DDIMSampler(object):\n\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,\n ddim_num_steps,\n ddim_discretize='uniform',\n ddim_eta=0.,\n verbose=True):\n self.ddim_timesteps = make_ddim_timesteps(\n ddim_discr_method=ddim_discretize,\n num_ddim_timesteps=ddim_num_steps,\n num_ddpm_timesteps=self.ddpm_num_timesteps,\n verbose=verbose)\n alphas_cumprod = self.model.alphas_cumprod\n assert alphas_cumprod.shape[\n 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\n .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',\n 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',\n to_torch(np.sqrt(alphas_cumprod.cpu())))\n self.register_buffer('sqrt_one_minus_alphas_cumprod',\n to_torch(np.sqrt(1. - alphas_cumprod.cpu())))\n self.register_buffer('log_one_minus_alphas_cumprod',\n to_torch(np.log(1. - alphas_cumprod.cpu())))\n self.register_buffer('sqrt_recip_alphas_cumprod',\n to_torch(np.sqrt(1. / alphas_cumprod.cpu())))\n self.register_buffer('sqrt_recipm1_alphas_cumprod',\n 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(\n alphacums=alphas_cumprod.cpu(),\n ddim_timesteps=self.ddim_timesteps,\n eta=ddim_eta,\n 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',\n 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',\n sigmas_for_original_sampling_steps)\n\n @torch.no_grad()\n def sample(\n 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,\n # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...\n **kwargs):\n if conditioning is not None:\n if isinstance(conditioning, dict):\n cbs = conditioning[list(conditioning.keys())[0]].shape[0]\n if cbs != batch_size:\n print(\n f'Warning: Got {cbs} conditionings but batch-size is {batch_size}'\n )\n else:\n if conditioning.shape[0] != batch_size:\n print(\n f'Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}'\n )\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\n samples, intermediates = self.ddim_sampling(\n conditioning,\n size,\n callback=callback,\n img_callback=img_callback,\n quantize_denoised=quantize_x0,\n mask=mask,\n 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 **kwargs)\n return samples, intermediates\n\n @torch.no_grad()\n def ddim_sampling(self,\n cond,\n shape,\n x_T=None,\n ddim_use_original_steps=False,\n callback=None,\n timesteps=None,\n quantize_denoised=False,\n mask=None,\n x0=None,\n img_callback=None,\n log_every_t=100,\n temperature=1.,\n noise_dropout=0.,\n score_corrector=None,\n corrector_kwargs=None,\n unconditional_guidance_scale=1.,\n unconditional_conditioning=None,\n **kwargs):\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(\n min(timesteps / self.ddim_timesteps.shape[0], 1)\n * 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(\n 0, timesteps)) if ddim_use_original_steps else np.flip(timesteps)\n total_steps = timesteps if ddim_use_original_steps else timesteps.shape[\n 0]\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(\n x0, ts) # TODO: deterministic forward pass?\n img = img_orig * mask + (1. - mask) * img\n\n outs = self.p_sample_ddim(\n img,\n cond,\n ts,\n index=index,\n use_original_steps=ddim_use_original_steps,\n quantize_denoised=quantize_denoised,\n temperature=temperature,\n noise_dropout=noise_dropout,\n score_corrector=score_corrector,\n corrector_kwargs=corrector_kwargs,\n unconditional_guidance_scale=unconditional_guidance_scale,\n unconditional_conditioning=unconditional_conditioning,\n **kwargs)\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,\n x,\n c,\n t,\n index,\n repeat_noise=False,\n use_original_steps=False,\n quantize_denoised=False,\n temperature=1.,\n noise_dropout=0.,\n score_corrector=None,\n corrector_kwargs=None,\n unconditional_guidance_scale=1.,\n unconditional_conditioning=None,\n dynamic_threshold=None,\n **kwargs):\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] = [\n torch.cat(\n [unconditional_conditioning[k][i], c[k][i]])\n for i in range(len(c[k]))\n ]\n elif isinstance(c[k], torch.Tensor):\n c_in[k] = torch.cat(\n [unconditional_conditioning[k], c[k]])\n else:\n assert c[k] == unconditional_conditioning[k]\n c_in[k] = 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(\n 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,\n c_in).chunk(2)\n # model_t = self.model.apply_model(x, t, c, **kwargs)\n # model_uncond = self.model.apply_model(x, t, unconditional_conditioning, **kwargs)\n model_output = model_uncond + unconditional_guidance_scale * (\n model_t - model_uncond)\n\n if self.model.parameterization == 'v':\n print('using 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,\n **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),\n sqrt_one_minus_alphas[index],\n 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,\n 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 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 (\n extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0\n + extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape)\n * noise)\n\n @torch.no_grad()\n def decode(self,\n x_latent,\n cond,\n t_start,\n unconditional_guidance_scale=1.0,\n unconditional_conditioning=None,\n use_original_steps=False,\n **kwargs):\n\n timesteps = np.arange(self.ddpm_num_timesteps\n ) 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\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], ),\n step,\n device=x_latent.device,\n dtype=torch.long)\n x_dec, _ = self.p_sample_ddim(\n x_dec,\n cond,\n ts,\n index=index,\n use_original_steps=use_original_steps,\n unconditional_guidance_scale=unconditional_guidance_scale,\n unconditional_conditioning=unconditional_conditioning,\n **kwargs)\n return x_dec"},{"identifier":"DPMSolverSampler","path":"ldm/models/diffusion/dpm_solver/sampler.py","snippet":"class DPMSolverSampler(object):\n\n def __init__(self, model, **kwargs):\n super().__init__()\n self.model = model\n to_torch = lambda x: x.clone().detach().to(torch.float32).to(model.\n device)\n self.register_buffer('alphas_cumprod', to_torch(model.alphas_cumprod))\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 @torch.no_grad()\n def sample(\n 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,\n # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...\n **kwargs):\n if conditioning is not None:\n if isinstance(conditioning, dict):\n cbs = conditioning[list(conditioning.keys())[0]].shape[0]\n if cbs != batch_size:\n print(\n f'Warning: Got {cbs} conditionings but batch-size is {batch_size}'\n )\n else:\n if conditioning.shape[0] != batch_size:\n print(\n f'Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}'\n )\n\n # sampling\n C, H, W = shape\n size = (batch_size, C, H, W)\n\n # print(f'Data shape for DPM-Solver sampling is {size}, sampling steps {S}')\n\n device = self.model.betas.device\n if x_T is None:\n img = torch.randn(size, device=device)\n else:\n img = x_T\n\n ns = NoiseScheduleVP('discrete', alphas_cumprod=self.alphas_cumprod)\n\n model_fn = model_wrapper(\n lambda x, t, c: self.model.apply_model(x, t, c),\n ns,\n model_type='noise',\n guidance_type='classifier-free',\n condition=conditioning,\n unconditional_condition=unconditional_conditioning,\n guidance_scale=unconditional_guidance_scale,\n )\n\n dpm_solver = DPM_Solver(\n model_fn, ns, predict_x0=True, thresholding=False)\n x = dpm_solver.sample(\n img,\n steps=S,\n skip_type='time_uniform',\n method='multistep',\n order=2,\n lower_order_final=True)\n\n return x.to(device), None"},{"identifier":"PLMSSampler","path":"ldm/models/diffusion/plms.py","snippet":"class PLMSSampler(object):\n\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,\n ddim_num_steps,\n ddim_discretize='uniform',\n ddim_eta=0.,\n verbose=True):\n if ddim_eta != 0:\n raise ValueError('ddim_eta must be 0 for PLMS')\n self.ddim_timesteps = make_ddim_timesteps(\n ddim_discr_method=ddim_discretize,\n num_ddim_timesteps=ddim_num_steps,\n num_ddpm_timesteps=self.ddpm_num_timesteps,\n verbose=verbose)\n alphas_cumprod = self.model.alphas_cumprod\n assert alphas_cumprod.shape[\n 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\n .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',\n 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',\n to_torch(np.sqrt(alphas_cumprod.cpu())))\n self.register_buffer('sqrt_one_minus_alphas_cumprod',\n to_torch(np.sqrt(1. - alphas_cumprod.cpu())))\n self.register_buffer('log_one_minus_alphas_cumprod',\n to_torch(np.log(1. - alphas_cumprod.cpu())))\n self.register_buffer('sqrt_recip_alphas_cumprod',\n to_torch(np.sqrt(1. / alphas_cumprod.cpu())))\n self.register_buffer('sqrt_recipm1_alphas_cumprod',\n 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(\n alphacums=alphas_cumprod.cpu(),\n ddim_timesteps=self.ddim_timesteps,\n eta=ddim_eta,\n 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',\n 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',\n sigmas_for_original_sampling_steps)\n\n @torch.no_grad()\n def sample(\n 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,\n # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...\n **kwargs):\n if conditioning is not None:\n if isinstance(conditioning, dict):\n cbs = conditioning[list(conditioning.keys())[0]].shape[0]\n if cbs != batch_size:\n print(\n f'Warning: Got {cbs} conditionings but batch-size is {batch_size}'\n )\n else:\n if conditioning.shape[0] != batch_size:\n print(\n f'Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}'\n )\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 PLMS sampling is {size}')\n\n samples, intermediates = self.plms_sampling(\n conditioning,\n size,\n callback=callback,\n img_callback=img_callback,\n quantize_denoised=quantize_x0,\n mask=mask,\n 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 )\n return samples, intermediates\n\n @torch.no_grad()\n def plms_sampling(\n self,\n cond,\n shape,\n x_T=None,\n ddim_use_original_steps=False,\n callback=None,\n timesteps=None,\n quantize_denoised=False,\n mask=None,\n x0=None,\n img_callback=None,\n log_every_t=100,\n temperature=1.,\n noise_dropout=0.,\n score_corrector=None,\n corrector_kwargs=None,\n unconditional_guidance_scale=1.,\n unconditional_conditioning=None,\n ):\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(\n min(timesteps / self.ddim_timesteps.shape[0], 1)\n * 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 = list(reversed(range(\n 0, timesteps))) if ddim_use_original_steps else np.flip(timesteps)\n total_steps = timesteps if ddim_use_original_steps else timesteps.shape[\n 0]\n print(f'Running PLMS Sampling with {total_steps} timesteps')\n\n iterator = tqdm(time_range, desc='PLMS Sampler', total=total_steps)\n old_eps = []\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 ts_next = torch.full((b, ),\n time_range[min(i + 1,\n len(time_range) - 1)],\n device=device,\n dtype=torch.long)\n\n if mask is not None:\n assert x0 is not None\n img_orig = self.model.q_sample(\n x0, ts) # TODO: deterministic forward pass?\n img = img_orig * mask + (1. - mask) * img\n\n outs = self.p_sample_plms(\n img,\n cond,\n ts,\n index=index,\n use_original_steps=ddim_use_original_steps,\n quantize_denoised=quantize_denoised,\n temperature=temperature,\n noise_dropout=noise_dropout,\n score_corrector=score_corrector,\n corrector_kwargs=corrector_kwargs,\n unconditional_guidance_scale=unconditional_guidance_scale,\n unconditional_conditioning=unconditional_conditioning,\n old_eps=old_eps,\n t_next=ts_next)\n img, pred_x0, e_t = outs\n old_eps.append(e_t)\n if len(old_eps) >= 4:\n old_eps.pop(0)\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_plms(self,\n x,\n c,\n t,\n index,\n repeat_noise=False,\n use_original_steps=False,\n quantize_denoised=False,\n temperature=1.,\n noise_dropout=0.,\n score_corrector=None,\n corrector_kwargs=None,\n unconditional_guidance_scale=1.,\n unconditional_conditioning=None,\n old_eps=None,\n t_next=None):\n b, *_, device = *x.shape, x.device\n\n def get_model_output(x, t):\n if unconditional_conditioning is None or unconditional_guidance_scale == 1.:\n e_t = self.model.apply_model(x, t, c)\n else:\n x_in = torch.cat([x] * 2)\n t_in = torch.cat([t] * 2)\n c_in = torch.cat([unconditional_conditioning, c])\n e_t_uncond, e_t = self.model.apply_model(x_in, t_in,\n c_in).chunk(2)\n e_t = e_t_uncond + unconditional_guidance_scale * (\n e_t - e_t_uncond)\n\n if score_corrector is not None:\n assert self.model.parameterization == 'eps'\n e_t = score_corrector.modify_score(self.model, e_t, x, t, c,\n **corrector_kwargs)\n\n return e_t\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\n def get_x_prev_and_pred_x0(e_t, index):\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),\n alphas_prev[index],\n 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),\n sqrt_one_minus_alphas[index],\n device=device)\n\n # current prediction for x_0\n pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()\n if quantize_denoised:\n pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)\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,\n 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 e_t = get_model_output(x, t)\n if len(old_eps) == 0:\n # Pseudo Improved Euler (2nd order)\n x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t, index)\n e_t_next = get_model_output(x_prev, t_next)\n e_t_prime = (e_t + e_t_next) / 2\n elif len(old_eps) == 1:\n # 2nd order Pseudo Linear Multistep (Adams-Bashforth)\n e_t_prime = (3 * e_t - old_eps[-1]) / 2\n elif len(old_eps) == 2:\n # 3nd order Pseudo Linear Multistep (Adams-Bashforth)\n e_t_prime = (23 * e_t - 16 * old_eps[-1] + 5 * old_eps[-2]) / 12\n elif len(old_eps) >= 3:\n # 4nd order Pseudo Linear Multistep (Adams-Bashforth)\n e_t_prime = (55 * e_t - 59 * old_eps[-1] + 37 * old_eps[-2]\n - 9 * old_eps[-3]) / 24\n\n x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t_prime, index)\n\n return x_prev, pred_x0, e_t"},{"identifier":"CrossAttention","path":"ldm/modules/attention.py","snippet":"class CrossAttention(nn.Module):\n\n def __init__(self,\n query_dim,\n context_dim=None,\n heads=8,\n dim_head=64,\n dropout=0.):\n super().__init__()\n inner_dim = dim_head * heads\n context_dim = default(context_dim, query_dim)\n\n self.scale = dim_head**-0.5\n self.heads = heads\n\n self.to_q = nn.Linear(query_dim, inner_dim, bias=False)\n self.to_k = nn.Linear(context_dim, inner_dim, bias=False)\n self.to_v = nn.Linear(context_dim, inner_dim, bias=False)\n\n self.to_out = nn.Sequential(\n nn.Linear(inner_dim, query_dim), nn.Dropout(dropout))\n\n def forward(self, x, context=None, mask=None):\n h = self.heads\n\n q = self.to_q(x)\n context = default(context, x)\n k = self.to_k(context)\n v = self.to_v(context)\n\n q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h),\n (q, k, v))\n\n sim = einsum('b i d, b j d -> b i j', q, k) * self.scale\n\n if exists(mask):\n mask = rearrange(mask, 'b ... -> b (...)')\n max_neg_value = -torch.finfo(sim.dtype).max\n mask = repeat(mask, 'b j -> (b h) () j', h=h)\n sim.masked_fill_(~mask, max_neg_value)\n\n # attention, what we cannot get enough of\n attn = sim.softmax(dim=-1)\n\n out = einsum('b i j, b j d -> b i d', attn, v)\n out = rearrange(out, '(b h) n d -> b n (h d)', h=h)\n return self.to_out(out)"},{"identifier":"extract_into_tensor","path":"ldm/modules/diffusionmodules/util.py","snippet":"def 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)))"},{"identifier":"make_beta_schedule","path":"ldm/modules/diffusionmodules/util.py","snippet":"def make_beta_schedule(schedule,\n n_timestep,\n linear_start=1e-4,\n linear_end=2e-2,\n cosine_s=8e-3):\n if schedule == 'linear':\n betas = (\n torch.linspace(\n linear_start**0.5,\n linear_end**0.5,\n n_timestep,\n dtype=torch.float64)**2)\n\n elif schedule == 'cosine':\n timesteps = (\n torch.arange(n_timestep + 1, dtype=torch.float64) / n_timestep\n + cosine_s)\n alphas = timesteps / (1 + cosine_s) * np.pi / 2\n alphas = torch.cos(alphas).pow(2)\n alphas = alphas / alphas[0]\n betas = 1 - alphas[1:] / alphas[:-1]\n betas = np.clip(betas, a_min=0, a_max=0.999)\n\n elif schedule == 'sqrt_linear':\n betas = torch.linspace(\n linear_start, linear_end, n_timestep, dtype=torch.float64)\n elif schedule == 'sqrt':\n betas = torch.linspace(\n linear_start, linear_end, n_timestep, dtype=torch.float64)**0.5\n else:\n raise ValueError(f\"schedule '{schedule}' unknown.\")\n return betas.numpy()"},{"identifier":"noise_like","path":"ldm/modules/diffusionmodules/util.py","snippet":"def noise_like(shape, device, repeat=False):\n repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repeat(\n shape[0], *((1, ) * (len(shape) - 1)))\n noise = lambda: torch.randn(shape, device=device)\n return repeat_noise() if repeat else noise()"},{"identifier":"DiagonalGaussianDistribution","path":"ldm/modules/distributions/distributions.py","snippet":"class DiagonalGaussianDistribution(object):\n\n def __init__(self, parameters, deterministic=False):\n self.parameters = parameters\n self.mean, self.logvar = torch.chunk(parameters, 2, dim=1)\n self.logvar = torch.clamp(self.logvar, -30.0, 20.0)\n self.deterministic = deterministic\n self.std = torch.exp(0.5 * self.logvar)\n self.var = torch.exp(self.logvar)\n if self.deterministic:\n self.var = self.std = torch.zeros_like(\n self.mean).to(device=self.parameters.device)\n\n def sample(self):\n x = self.mean + self.std * torch.randn(\n self.mean.shape).to(device=self.parameters.device)\n return x\n\n def kl(self, other=None):\n if self.deterministic:\n return torch.Tensor([0.])\n else:\n if other is None:\n return 0.5 * torch.sum(\n torch.pow(self.mean, 2) + self.var - 1.0 - self.logvar,\n dim=[1, 2, 3])\n else:\n return 0.5 * torch.sum(\n torch.pow(self.mean - other.mean, 2) / other.var\n + self.var / other.var - 1.0 - self.logvar + other.logvar,\n dim=[1, 2, 3])\n\n def nll(self, sample, dims=[1, 2, 3]):\n if self.deterministic:\n return torch.Tensor([0.])\n logtwopi = np.log(2.0 * np.pi)\n return 0.5 * torch.sum(\n logtwopi + self.logvar\n + torch.pow(sample - self.mean, 2) / self.var,\n dim=dims)\n\n def mode(self):\n return self.mean"},{"identifier":"normal_kl","path":"ldm/modules/distributions/distributions.py","snippet":"def normal_kl(mean1, logvar1, mean2, logvar2):\n \"\"\"\n source: https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/losses.py#L12\n Compute the KL divergence between two gaussians.\n Shapes are automatically broadcasted, so batches can be compared to\n scalars, among other use cases.\n \"\"\"\n tensor = None\n for obj in (mean1, logvar1, mean2, logvar2):\n if isinstance(obj, torch.Tensor):\n tensor = obj\n break\n assert tensor is not None, 'at least one argument must be a Tensor'\n\n # Force variances to be Tensors. Broadcasting helps convert scalars to\n # Tensors, but it does not work for torch.exp().\n logvar1, logvar2 = [\n x if isinstance(x, torch.Tensor) else torch.tensor(x).to(tensor)\n for x in (logvar1, logvar2)\n ]\n\n return 0.5 * (-1.0 + logvar2 - logvar1 + torch.exp(logvar1 - logvar2) +\n ((mean1 - mean2)**2) * torch.exp(-logvar2))"},{"identifier":"LitEma","path":"ldm/modules/ema.py","snippet":"class LitEma(nn.Module):\n\n def __init__(self, model, decay=0.9999, use_num_upates=True):\n super().__init__()\n if decay < 0.0 or decay > 1.0:\n raise ValueError('Decay must be between 0 and 1')\n\n self.m_name2s_name = {}\n self.register_buffer('decay', torch.tensor(decay, dtype=torch.float32))\n self.register_buffer(\n 'num_updates',\n torch.tensor(0, dtype=torch.int)\n if use_num_upates else torch.tensor(-1, dtype=torch.int))\n\n for name, p in model.named_parameters():\n if p.requires_grad:\n #remove as '.'-character is not allowed in buffers\n s_name = name.replace('.', '')\n self.m_name2s_name.update({name: s_name})\n self.register_buffer(s_name, p.clone().detach().data)\n\n self.collected_params = []\n\n def forward(self, model):\n decay = self.decay\n\n if self.num_updates >= 0:\n self.num_updates += 1\n decay = min(self.decay, (1 + self.num_updates) /\n (10 + self.num_updates))\n\n one_minus_decay = 1.0 - decay\n\n with torch.no_grad():\n m_param = dict(model.named_parameters())\n shadow_params = dict(self.named_buffers())\n\n for key in m_param:\n if m_param[key].requires_grad:\n sname = self.m_name2s_name[key]\n shadow_params[sname] = shadow_params[sname].type_as(\n m_param[key])\n shadow_params[sname].sub_(\n one_minus_decay *\n (shadow_params[sname] - m_param[key]))\n else:\n assert not key in self.m_name2s_name\n\n def copy_to(self, model):\n m_param = dict(model.named_parameters())\n shadow_params = dict(self.named_buffers())\n for key in m_param:\n if m_param[key].requires_grad:\n m_param[key].data.copy_(\n shadow_params[self.m_name2s_name[key]].data)\n else:\n assert not key in self.m_name2s_name\n\n def store(self, parameters):\n \"\"\"\n Save the current parameters for restoring later.\n Args:\n parameters: Iterable of `torch.nn.Parameter`; the parameters to be\n temporarily stored.\n \"\"\"\n self.collected_params = [param.clone() for param in parameters]\n\n def restore(self, parameters):\n \"\"\"\n Restore the parameters stored with the `store` method.\n Useful to validate the model with EMA parameters without affecting the\n original optimization process. Store the parameters before the\n `copy_to` method. After validation (or model saving), use this to\n restore the former parameters.\n Args:\n parameters: Iterable of `torch.nn.Parameter`; the parameters to be\n updated with the stored parameters.\n \"\"\"\n for c_param, param in zip(self.collected_params, parameters):\n param.data.copy_(c_param.data)"},{"identifier":"count_params","path":"ldm/util.py","snippet":"def count_params(model, verbose=False):\n total_params = sum(p.numel() for p in model.parameters())\n if verbose:\n print(\n f'{model.__class__.__name__} has {total_params * 1.e-6:.2f} M params.'\n )\n return total_params"},{"identifier":"default","path":"ldm/util.py","snippet":"def default(val, d):\n if exists(val):\n return val\n return d() if isfunction(d) else d"},{"identifier":"exists","path":"ldm/util.py","snippet":"def exists(x):\n return x is not None"},{"identifier":"filter_nan_loss","path":"ldm/util.py","snippet":"def filter_nan_loss(loss):\n fake_loss = torch.isnan(loss)\n loss = loss[torch.logical_not(fake_loss)]\n\n if loss.shape[0] == 0:\n return loss.sum()\n else:\n return loss"},{"identifier":"instantiate_from_config","path":"ldm/util.py","snippet":"def instantiate_from_config(config):\n if not 'target' in config:\n\n print(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":"isimage","path":"ldm/util.py","snippet":"def isimage(x):\n if not isinstance(x, torch.Tensor):\n return False\n return (len(x.shape) == 4) and (x.shape[1] == 3 or x.shape[1] == 1)"},{"identifier":"ismap","path":"ldm/util.py","snippet":"def ismap(x):\n if not isinstance(x, torch.Tensor):\n return False\n return (len(x.shape) == 4) and (x.shape[1] > 3)"},{"identifier":"log_txt_as_img","path":"ldm/util.py","snippet":"def log_txt_as_img(wh, xc, size=20):\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('data/DejaVuSans.ttf', size=size)\n nc = int(10 * (wh[0] / 256))\n lines = '\\n'.join(xc[bi][start:start + nc]\n 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":"mean_flat","path":"ldm/util.py","snippet":"def mean_flat(tensor):\n \"\"\"\n https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/nn.py#L86\n Take the mean over all non-batch dimensions.\n \"\"\"\n return tensor.mean(dim=list(range(1, len(tensor.shape))))"}],"string":"[\n {\n \"identifier\": \"AutoencoderKL\",\n \"path\": \"ldm/models/autoencoder.py\",\n \"snippet\": \"class AutoencoderKL(pl.LightningModule):\\n\\n def __init__(self,\\n ddconfig,\\n lossconfig,\\n embed_dim,\\n ckpt_path=None,\\n ignore_keys=[],\\n image_key='image',\\n colorize_nlabels=None,\\n monitor=None,\\n prior_model=None,\\n prior_normal=None,\\n using_rgb=True):\\n super().__init__()\\n self.image_key = image_key\\n self.encoder = Encoder(**ddconfig)\\n self.decoder = Decoder(**ddconfig)\\n self.loss = instantiate_from_config(lossconfig)\\n self.prior_model = prior_model\\n self.using_rgb = using_rgb\\n\\n assert ddconfig['double_z']\\n self.quant_conv = torch.nn.Conv2d(2 * ddconfig['z_channels'],\\n 2 * embed_dim, 1)\\n self.post_quant_conv = torch.nn.Conv2d(embed_dim,\\n ddconfig['z_channels'], 1)\\n self.embed_dim = embed_dim\\n if colorize_nlabels is not None:\\n assert type(colorize_nlabels) == int\\n self.register_buffer('colorize',\\n torch.randn(3, colorize_nlabels, 1, 1))\\n if monitor is not None:\\n self.monitor = monitor\\n\\n if prior_model is not None:\\n self.prior_model = instantiate_from_config(prior_model)\\n if prior_normal is not None:\\n self.prior_normal = instantiate_from_config(prior_normal)\\n\\n if ckpt_path is not None:\\n self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)\\n\\n def init_from_ckpt(self, path, ignore_keys=list()):\\n try:\\n sd = torch.load(path, map_location='cpu')['state_dict']\\n except:\\n sd = torch.load(path, map_location='cpu')\\n\\n keys = list(sd.keys())\\n for k in keys:\\n for ik in ignore_keys:\\n if k.startswith(ik):\\n print('Deleting key {} from state_dict.'.format(k))\\n del sd[k]\\n m, u = self.load_state_dict(sd, strict=False)\\n if len(m) > 0:\\n print('missing keys:')\\n print(m)\\n if len(u) > 0:\\n print('unexpected keys:')\\n print(u)\\n\\n print(f'Restored from {path}')\\n\\n def encode(self, x):\\n h = self.encoder(x)\\n moments = self.quant_conv(h)\\n posterior = DiagonalGaussianDistribution(moments)\\n return posterior\\n\\n def decode(self, z):\\n z = self.post_quant_conv(z)\\n dec = self.decoder(z)\\n return dec\\n\\n def prior_to_eval(self):\\n\\n if self.prior_model is not None:\\n self.prior_model.eval()\\n\\n if self.prior_normal is not None:\\n self.prior_normal.eval()\\n\\n @torch.no_grad()\\n def prior_inference(self, inputs, prior_inputs):\\n # depth prior model\\n # midas or zoe is 384 model\\n prior_results = {}\\n\\n self.prior_to_eval()\\n\\n model_prior_results = self.prior_model(prior_inputs)\\n prior_results.update(model_prior_results)\\n\\n # using normal map\\n if not self.using_rgb:\\n normal_prior = self.prior_normal(prior_inputs)\\n prior_results.update(normal_prior)\\n\\n resize_prior_results = {}\\n _, __, h, w = inputs.shape\\n\\n for key in prior_results.keys():\\n resize_prior_results[key] = F.interpolate(\\n prior_results[key], (w, h), mode='bilinear')\\n\\n if self.using_rgb:\\n return torch.cat([inputs, resize_prior_results['depth']], dim=1)\\n else:\\n return torch.cat([\\n resize_prior_results['normal'], resize_prior_results['depth']\\n ],\\n dim=1)\\n\\n def forward(self, input, sample_posterior=True):\\n\\n posterior = self.encode(input)\\n if sample_posterior:\\n z = posterior.sample()\\n else:\\n z = posterior.mode()\\n dec = self.decode(z)\\n return dec, posterior\\n\\n def get_input(self, batch, k):\\n x = batch[k]\\n if len(x.shape) == 3:\\n x = x[..., None]\\n x = x.permute(0, 3, 1,\\n 2).to(memory_format=torch.contiguous_format).float()\\n return x\\n\\n def training_step(self, batch, batch_idx, optimizer_idx):\\n\\n inputs = self.get_input(batch, self.image_key)\\n if self.prior_model is not None:\\n inputs = self.prior_inference(inputs, batch['prior'])\\n\\n reconstructions, posterior = self(inputs)\\n\\n if optimizer_idx == 0:\\n # train encoder+decoder+logvar\\n aeloss, log_dict_ae = self.loss(\\n inputs,\\n reconstructions,\\n posterior,\\n optimizer_idx,\\n self.global_step,\\n last_layer=self.get_last_layer(),\\n split='train')\\n\\n self.log(\\n 'rec_loss',\\n log_dict_ae['train/rec_loss'],\\n prog_bar=True,\\n logger=True,\\n on_step=True,\\n on_epoch=True)\\n self.log(\\n 'aeloss',\\n aeloss,\\n prog_bar=True,\\n logger=True,\\n on_step=True,\\n on_epoch=True)\\n self.log_dict(\\n log_dict_ae,\\n prog_bar=False,\\n logger=True,\\n on_step=True,\\n on_epoch=False)\\n return aeloss\\n\\n if optimizer_idx == 1:\\n # train the discriminator\\n discloss, log_dict_disc = self.loss(\\n inputs,\\n reconstructions,\\n posterior,\\n optimizer_idx,\\n self.global_step,\\n last_layer=self.get_last_layer(),\\n split='train')\\n\\n self.log(\\n 'discloss',\\n discloss,\\n prog_bar=True,\\n logger=True,\\n on_step=True,\\n on_epoch=True)\\n self.log_dict(\\n log_dict_disc,\\n prog_bar=False,\\n logger=True,\\n on_step=True,\\n on_epoch=False)\\n return discloss\\n\\n def validation_step(self, batch, batch_idx):\\n inputs = self.get_input(batch, self.image_key)\\n reconstructions, posterior = self(inputs)\\n aeloss, log_dict_ae = self.loss(\\n inputs,\\n reconstructions,\\n posterior,\\n 0,\\n self.global_step,\\n last_layer=self.get_last_layer(),\\n split='val')\\n\\n discloss, log_dict_disc = self.loss(\\n inputs,\\n reconstructions,\\n posterior,\\n 1,\\n self.global_step,\\n last_layer=self.get_last_layer(),\\n split='val')\\n\\n self.log('val/rec_loss', log_dict_ae['val/rec_loss'])\\n self.log_dict(log_dict_ae)\\n self.log_dict(log_dict_disc)\\n return self.log_dict\\n\\n @torch.no_grad()\\n def test_step(self, batch, batch_idx):\\n pass\\n\\n @torch.no_grad()\\n def sample_imgs(self, batch):\\n '''using to test for sampling image\\n\\n '''\\n inputs = self.get_input(batch, self.image_key)\\n reconstructions, posterior = self(inputs)\\n\\n return {'samples': reconstructions}\\n\\n def configure_optimizers(self):\\n lr = self.learning_rate\\n opt_ae = torch.optim.Adam(\\n list(self.encoder.parameters()) + list(self.decoder.parameters())\\n + list(self.quant_conv.parameters())\\n + list(self.post_quant_conv.parameters()),\\n lr=lr,\\n betas=(0.5, 0.9))\\n opt_disc = torch.optim.Adam(\\n self.loss.discriminator.parameters(), lr=lr, betas=(0.5, 0.9))\\n\\n return [opt_ae, opt_disc], []\\n\\n def get_last_layer(self):\\n return self.decoder.conv_out.weight\\n\\n @torch.no_grad()\\n def log_images(self, batch, only_inputs=False, **kwargs):\\n log = dict()\\n x = self.get_input(batch, self.image_key)\\n x = x.to(self.device)\\n if not only_inputs:\\n xrec, posterior = self(x)\\n xrec = repeat(xrec[:, 0, ...], 'b h w -> b c h w', c=3)\\n\\n if x.shape[1] > 3:\\n # colorize with random projection\\n assert xrec.shape[1] > 3\\n x = self.to_rgb(x)\\n xrec = self.to_rgb(xrec)\\n samples = self.decode(torch.randn_like(posterior.sample()))\\n samples = repeat(samples[:, 0, ...], 'b h w -> b c h w', c=3)\\n log['samples'] = samples\\n\\n log['reconstructions'] = xrec\\n log['inputs'] = x\\n return log\\n\\n @torch.no_grad()\\n def log_rgbd(self, batch, only_inputs=False, **kwargs):\\n log = dict()\\n x = self.get_input(batch, self.image_key)\\n\\n if x.shape[1] == 3:\\n if self.prior_model is not None:\\n x = self.prior_inference(x, batch['prior'])\\n\\n x = x.to(self.device)\\n if not only_inputs:\\n xrec, posterior = self(x)\\n samples = self.decode(torch.randn_like(posterior.sample()))\\n log['samples'] = samples\\n log['reconstructions'] = xrec\\n log['inputs'] = x\\n return log\\n\\n def to_rgb(self, x):\\n assert self.image_key == 'segmentation'\\n if not hasattr(self, 'colorize'):\\n self.register_buffer('colorize',\\n torch.randn(3, x.shape[1], 1, 1).to(x))\\n x = F.conv2d(x, weight=self.colorize)\\n x = 2. * (x - x.min()) / (x.max() - x.min()) - 1.\\n return x\"\n },\n {\n \"identifier\": \"IdentityFirstStage\",\n \"path\": \"ldm/models/autoencoder.py\",\n \"snippet\": \"class IdentityFirstStage(torch.nn.Module):\\n\\n def __init__(self, *args, vq_interface=False, **kwargs):\\n self.vq_interface = vq_interface # TODO: Should be true by default but check to not break older stuff\\n super().__init__()\\n\\n def encode(self, x, *args, **kwargs):\\n return x\\n\\n def decode(self, x, *args, **kwargs):\\n return x\\n\\n def quantize(self, x, *args, **kwargs):\\n if self.vq_interface:\\n return x, None, [None, None, None]\\n return x\\n\\n def forward(self, x, *args, **kwargs):\\n return x\"\n },\n {\n \"identifier\": \"VQModelInterface\",\n \"path\": \"ldm/models/autoencoder.py\",\n \"snippet\": \"class VQModelInterface(VQModel):\\n\\n def __init__(self, embed_dim, *args, **kwargs):\\n super().__init__(embed_dim=embed_dim, *args, **kwargs)\\n self.embed_dim = embed_dim\\n\\n def encode(self, x):\\n h = self.encoder(x)\\n h = self.quant_conv(h)\\n return h\\n\\n def decode(self, h, force_not_quantize=False):\\n # also go through quantization layer\\n if not force_not_quantize:\\n quant, emb_loss, info = self.quantize(h)\\n else:\\n quant = h\\n quant = self.post_quant_conv(quant)\\n dec = self.decoder(quant)\\n return dec\"\n },\n {\n \"identifier\": \"DDIMSampler\",\n \"path\": \"ldm/models/diffusion/ddim.py\",\n \"snippet\": \"class DDIMSampler(object):\\n\\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,\\n ddim_num_steps,\\n ddim_discretize='uniform',\\n ddim_eta=0.,\\n verbose=True):\\n self.ddim_timesteps = make_ddim_timesteps(\\n ddim_discr_method=ddim_discretize,\\n num_ddim_timesteps=ddim_num_steps,\\n num_ddpm_timesteps=self.ddpm_num_timesteps,\\n verbose=verbose)\\n alphas_cumprod = self.model.alphas_cumprod\\n assert alphas_cumprod.shape[\\n 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\\n .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',\\n 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',\\n to_torch(np.sqrt(alphas_cumprod.cpu())))\\n self.register_buffer('sqrt_one_minus_alphas_cumprod',\\n to_torch(np.sqrt(1. - alphas_cumprod.cpu())))\\n self.register_buffer('log_one_minus_alphas_cumprod',\\n to_torch(np.log(1. - alphas_cumprod.cpu())))\\n self.register_buffer('sqrt_recip_alphas_cumprod',\\n to_torch(np.sqrt(1. / alphas_cumprod.cpu())))\\n self.register_buffer('sqrt_recipm1_alphas_cumprod',\\n 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(\\n alphacums=alphas_cumprod.cpu(),\\n ddim_timesteps=self.ddim_timesteps,\\n eta=ddim_eta,\\n 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',\\n 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',\\n sigmas_for_original_sampling_steps)\\n\\n @torch.no_grad()\\n def sample(\\n 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,\\n # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...\\n **kwargs):\\n if conditioning is not None:\\n if isinstance(conditioning, dict):\\n cbs = conditioning[list(conditioning.keys())[0]].shape[0]\\n if cbs != batch_size:\\n print(\\n f'Warning: Got {cbs} conditionings but batch-size is {batch_size}'\\n )\\n else:\\n if conditioning.shape[0] != batch_size:\\n print(\\n f'Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}'\\n )\\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\\n samples, intermediates = self.ddim_sampling(\\n conditioning,\\n size,\\n callback=callback,\\n img_callback=img_callback,\\n quantize_denoised=quantize_x0,\\n mask=mask,\\n 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 **kwargs)\\n return samples, intermediates\\n\\n @torch.no_grad()\\n def ddim_sampling(self,\\n cond,\\n shape,\\n x_T=None,\\n ddim_use_original_steps=False,\\n callback=None,\\n timesteps=None,\\n quantize_denoised=False,\\n mask=None,\\n x0=None,\\n img_callback=None,\\n log_every_t=100,\\n temperature=1.,\\n noise_dropout=0.,\\n score_corrector=None,\\n corrector_kwargs=None,\\n unconditional_guidance_scale=1.,\\n unconditional_conditioning=None,\\n **kwargs):\\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(\\n min(timesteps / self.ddim_timesteps.shape[0], 1)\\n * 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(\\n 0, timesteps)) if ddim_use_original_steps else np.flip(timesteps)\\n total_steps = timesteps if ddim_use_original_steps else timesteps.shape[\\n 0]\\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(\\n x0, ts) # TODO: deterministic forward pass?\\n img = img_orig * mask + (1. - mask) * img\\n\\n outs = self.p_sample_ddim(\\n img,\\n cond,\\n ts,\\n index=index,\\n use_original_steps=ddim_use_original_steps,\\n quantize_denoised=quantize_denoised,\\n temperature=temperature,\\n noise_dropout=noise_dropout,\\n score_corrector=score_corrector,\\n corrector_kwargs=corrector_kwargs,\\n unconditional_guidance_scale=unconditional_guidance_scale,\\n unconditional_conditioning=unconditional_conditioning,\\n **kwargs)\\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,\\n x,\\n c,\\n t,\\n index,\\n repeat_noise=False,\\n use_original_steps=False,\\n quantize_denoised=False,\\n temperature=1.,\\n noise_dropout=0.,\\n score_corrector=None,\\n corrector_kwargs=None,\\n unconditional_guidance_scale=1.,\\n unconditional_conditioning=None,\\n dynamic_threshold=None,\\n **kwargs):\\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] = [\\n torch.cat(\\n [unconditional_conditioning[k][i], c[k][i]])\\n for i in range(len(c[k]))\\n ]\\n elif isinstance(c[k], torch.Tensor):\\n c_in[k] = torch.cat(\\n [unconditional_conditioning[k], c[k]])\\n else:\\n assert c[k] == unconditional_conditioning[k]\\n c_in[k] = 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(\\n 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,\\n c_in).chunk(2)\\n # model_t = self.model.apply_model(x, t, c, **kwargs)\\n # model_uncond = self.model.apply_model(x, t, unconditional_conditioning, **kwargs)\\n model_output = model_uncond + unconditional_guidance_scale * (\\n model_t - model_uncond)\\n\\n if self.model.parameterization == 'v':\\n print('using 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,\\n **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),\\n sqrt_one_minus_alphas[index],\\n 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,\\n 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 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 (\\n extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0\\n + extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape)\\n * noise)\\n\\n @torch.no_grad()\\n def decode(self,\\n x_latent,\\n cond,\\n t_start,\\n unconditional_guidance_scale=1.0,\\n unconditional_conditioning=None,\\n use_original_steps=False,\\n **kwargs):\\n\\n timesteps = np.arange(self.ddpm_num_timesteps\\n ) 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\\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], ),\\n step,\\n device=x_latent.device,\\n dtype=torch.long)\\n x_dec, _ = self.p_sample_ddim(\\n x_dec,\\n cond,\\n ts,\\n index=index,\\n use_original_steps=use_original_steps,\\n unconditional_guidance_scale=unconditional_guidance_scale,\\n unconditional_conditioning=unconditional_conditioning,\\n **kwargs)\\n return x_dec\"\n },\n {\n \"identifier\": \"DPMSolverSampler\",\n \"path\": \"ldm/models/diffusion/dpm_solver/sampler.py\",\n \"snippet\": \"class DPMSolverSampler(object):\\n\\n def __init__(self, model, **kwargs):\\n super().__init__()\\n self.model = model\\n to_torch = lambda x: x.clone().detach().to(torch.float32).to(model.\\n device)\\n self.register_buffer('alphas_cumprod', to_torch(model.alphas_cumprod))\\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 @torch.no_grad()\\n def sample(\\n 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,\\n # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...\\n **kwargs):\\n if conditioning is not None:\\n if isinstance(conditioning, dict):\\n cbs = conditioning[list(conditioning.keys())[0]].shape[0]\\n if cbs != batch_size:\\n print(\\n f'Warning: Got {cbs} conditionings but batch-size is {batch_size}'\\n )\\n else:\\n if conditioning.shape[0] != batch_size:\\n print(\\n f'Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}'\\n )\\n\\n # sampling\\n C, H, W = shape\\n size = (batch_size, C, H, W)\\n\\n # print(f'Data shape for DPM-Solver sampling is {size}, sampling steps {S}')\\n\\n device = self.model.betas.device\\n if x_T is None:\\n img = torch.randn(size, device=device)\\n else:\\n img = x_T\\n\\n ns = NoiseScheduleVP('discrete', alphas_cumprod=self.alphas_cumprod)\\n\\n model_fn = model_wrapper(\\n lambda x, t, c: self.model.apply_model(x, t, c),\\n ns,\\n model_type='noise',\\n guidance_type='classifier-free',\\n condition=conditioning,\\n unconditional_condition=unconditional_conditioning,\\n guidance_scale=unconditional_guidance_scale,\\n )\\n\\n dpm_solver = DPM_Solver(\\n model_fn, ns, predict_x0=True, thresholding=False)\\n x = dpm_solver.sample(\\n img,\\n steps=S,\\n skip_type='time_uniform',\\n method='multistep',\\n order=2,\\n lower_order_final=True)\\n\\n return x.to(device), None\"\n },\n {\n \"identifier\": \"PLMSSampler\",\n \"path\": \"ldm/models/diffusion/plms.py\",\n \"snippet\": \"class PLMSSampler(object):\\n\\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,\\n ddim_num_steps,\\n ddim_discretize='uniform',\\n ddim_eta=0.,\\n verbose=True):\\n if ddim_eta != 0:\\n raise ValueError('ddim_eta must be 0 for PLMS')\\n self.ddim_timesteps = make_ddim_timesteps(\\n ddim_discr_method=ddim_discretize,\\n num_ddim_timesteps=ddim_num_steps,\\n num_ddpm_timesteps=self.ddpm_num_timesteps,\\n verbose=verbose)\\n alphas_cumprod = self.model.alphas_cumprod\\n assert alphas_cumprod.shape[\\n 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\\n .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',\\n 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',\\n to_torch(np.sqrt(alphas_cumprod.cpu())))\\n self.register_buffer('sqrt_one_minus_alphas_cumprod',\\n to_torch(np.sqrt(1. - alphas_cumprod.cpu())))\\n self.register_buffer('log_one_minus_alphas_cumprod',\\n to_torch(np.log(1. - alphas_cumprod.cpu())))\\n self.register_buffer('sqrt_recip_alphas_cumprod',\\n to_torch(np.sqrt(1. / alphas_cumprod.cpu())))\\n self.register_buffer('sqrt_recipm1_alphas_cumprod',\\n 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(\\n alphacums=alphas_cumprod.cpu(),\\n ddim_timesteps=self.ddim_timesteps,\\n eta=ddim_eta,\\n 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',\\n 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',\\n sigmas_for_original_sampling_steps)\\n\\n @torch.no_grad()\\n def sample(\\n 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,\\n # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...\\n **kwargs):\\n if conditioning is not None:\\n if isinstance(conditioning, dict):\\n cbs = conditioning[list(conditioning.keys())[0]].shape[0]\\n if cbs != batch_size:\\n print(\\n f'Warning: Got {cbs} conditionings but batch-size is {batch_size}'\\n )\\n else:\\n if conditioning.shape[0] != batch_size:\\n print(\\n f'Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}'\\n )\\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 PLMS sampling is {size}')\\n\\n samples, intermediates = self.plms_sampling(\\n conditioning,\\n size,\\n callback=callback,\\n img_callback=img_callback,\\n quantize_denoised=quantize_x0,\\n mask=mask,\\n 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 )\\n return samples, intermediates\\n\\n @torch.no_grad()\\n def plms_sampling(\\n self,\\n cond,\\n shape,\\n x_T=None,\\n ddim_use_original_steps=False,\\n callback=None,\\n timesteps=None,\\n quantize_denoised=False,\\n mask=None,\\n x0=None,\\n img_callback=None,\\n log_every_t=100,\\n temperature=1.,\\n noise_dropout=0.,\\n score_corrector=None,\\n corrector_kwargs=None,\\n unconditional_guidance_scale=1.,\\n unconditional_conditioning=None,\\n ):\\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(\\n min(timesteps / self.ddim_timesteps.shape[0], 1)\\n * 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 = list(reversed(range(\\n 0, timesteps))) if ddim_use_original_steps else np.flip(timesteps)\\n total_steps = timesteps if ddim_use_original_steps else timesteps.shape[\\n 0]\\n print(f'Running PLMS Sampling with {total_steps} timesteps')\\n\\n iterator = tqdm(time_range, desc='PLMS Sampler', total=total_steps)\\n old_eps = []\\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 ts_next = torch.full((b, ),\\n time_range[min(i + 1,\\n len(time_range) - 1)],\\n device=device,\\n dtype=torch.long)\\n\\n if mask is not None:\\n assert x0 is not None\\n img_orig = self.model.q_sample(\\n x0, ts) # TODO: deterministic forward pass?\\n img = img_orig * mask + (1. - mask) * img\\n\\n outs = self.p_sample_plms(\\n img,\\n cond,\\n ts,\\n index=index,\\n use_original_steps=ddim_use_original_steps,\\n quantize_denoised=quantize_denoised,\\n temperature=temperature,\\n noise_dropout=noise_dropout,\\n score_corrector=score_corrector,\\n corrector_kwargs=corrector_kwargs,\\n unconditional_guidance_scale=unconditional_guidance_scale,\\n unconditional_conditioning=unconditional_conditioning,\\n old_eps=old_eps,\\n t_next=ts_next)\\n img, pred_x0, e_t = outs\\n old_eps.append(e_t)\\n if len(old_eps) >= 4:\\n old_eps.pop(0)\\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_plms(self,\\n x,\\n c,\\n t,\\n index,\\n repeat_noise=False,\\n use_original_steps=False,\\n quantize_denoised=False,\\n temperature=1.,\\n noise_dropout=0.,\\n score_corrector=None,\\n corrector_kwargs=None,\\n unconditional_guidance_scale=1.,\\n unconditional_conditioning=None,\\n old_eps=None,\\n t_next=None):\\n b, *_, device = *x.shape, x.device\\n\\n def get_model_output(x, t):\\n if unconditional_conditioning is None or unconditional_guidance_scale == 1.:\\n e_t = self.model.apply_model(x, t, c)\\n else:\\n x_in = torch.cat([x] * 2)\\n t_in = torch.cat([t] * 2)\\n c_in = torch.cat([unconditional_conditioning, c])\\n e_t_uncond, e_t = self.model.apply_model(x_in, t_in,\\n c_in).chunk(2)\\n e_t = e_t_uncond + unconditional_guidance_scale * (\\n e_t - e_t_uncond)\\n\\n if score_corrector is not None:\\n assert self.model.parameterization == 'eps'\\n e_t = score_corrector.modify_score(self.model, e_t, x, t, c,\\n **corrector_kwargs)\\n\\n return e_t\\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\\n def get_x_prev_and_pred_x0(e_t, index):\\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),\\n alphas_prev[index],\\n 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),\\n sqrt_one_minus_alphas[index],\\n device=device)\\n\\n # current prediction for x_0\\n pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()\\n if quantize_denoised:\\n pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)\\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,\\n 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 e_t = get_model_output(x, t)\\n if len(old_eps) == 0:\\n # Pseudo Improved Euler (2nd order)\\n x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t, index)\\n e_t_next = get_model_output(x_prev, t_next)\\n e_t_prime = (e_t + e_t_next) / 2\\n elif len(old_eps) == 1:\\n # 2nd order Pseudo Linear Multistep (Adams-Bashforth)\\n e_t_prime = (3 * e_t - old_eps[-1]) / 2\\n elif len(old_eps) == 2:\\n # 3nd order Pseudo Linear Multistep (Adams-Bashforth)\\n e_t_prime = (23 * e_t - 16 * old_eps[-1] + 5 * old_eps[-2]) / 12\\n elif len(old_eps) >= 3:\\n # 4nd order Pseudo Linear Multistep (Adams-Bashforth)\\n e_t_prime = (55 * e_t - 59 * old_eps[-1] + 37 * old_eps[-2]\\n - 9 * old_eps[-3]) / 24\\n\\n x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t_prime, index)\\n\\n return x_prev, pred_x0, e_t\"\n },\n {\n \"identifier\": \"CrossAttention\",\n \"path\": \"ldm/modules/attention.py\",\n \"snippet\": \"class CrossAttention(nn.Module):\\n\\n def __init__(self,\\n query_dim,\\n context_dim=None,\\n heads=8,\\n dim_head=64,\\n dropout=0.):\\n super().__init__()\\n inner_dim = dim_head * heads\\n context_dim = default(context_dim, query_dim)\\n\\n self.scale = dim_head**-0.5\\n self.heads = heads\\n\\n self.to_q = nn.Linear(query_dim, inner_dim, bias=False)\\n self.to_k = nn.Linear(context_dim, inner_dim, bias=False)\\n self.to_v = nn.Linear(context_dim, inner_dim, bias=False)\\n\\n self.to_out = nn.Sequential(\\n nn.Linear(inner_dim, query_dim), nn.Dropout(dropout))\\n\\n def forward(self, x, context=None, mask=None):\\n h = self.heads\\n\\n q = self.to_q(x)\\n context = default(context, x)\\n k = self.to_k(context)\\n v = self.to_v(context)\\n\\n q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h),\\n (q, k, v))\\n\\n sim = einsum('b i d, b j d -> b i j', q, k) * self.scale\\n\\n if exists(mask):\\n mask = rearrange(mask, 'b ... -> b (...)')\\n max_neg_value = -torch.finfo(sim.dtype).max\\n mask = repeat(mask, 'b j -> (b h) () j', h=h)\\n sim.masked_fill_(~mask, max_neg_value)\\n\\n # attention, what we cannot get enough of\\n attn = sim.softmax(dim=-1)\\n\\n out = einsum('b i j, b j d -> b i d', attn, v)\\n out = rearrange(out, '(b h) n d -> b n (h d)', h=h)\\n return self.to_out(out)\"\n },\n {\n \"identifier\": \"extract_into_tensor\",\n \"path\": \"ldm/modules/diffusionmodules/util.py\",\n \"snippet\": \"def 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 {\n \"identifier\": \"make_beta_schedule\",\n \"path\": \"ldm/modules/diffusionmodules/util.py\",\n \"snippet\": \"def make_beta_schedule(schedule,\\n n_timestep,\\n linear_start=1e-4,\\n linear_end=2e-2,\\n cosine_s=8e-3):\\n if schedule == 'linear':\\n betas = (\\n torch.linspace(\\n linear_start**0.5,\\n linear_end**0.5,\\n n_timestep,\\n dtype=torch.float64)**2)\\n\\n elif schedule == 'cosine':\\n timesteps = (\\n torch.arange(n_timestep + 1, dtype=torch.float64) / n_timestep\\n + cosine_s)\\n alphas = timesteps / (1 + cosine_s) * np.pi / 2\\n alphas = torch.cos(alphas).pow(2)\\n alphas = alphas / alphas[0]\\n betas = 1 - alphas[1:] / alphas[:-1]\\n betas = np.clip(betas, a_min=0, a_max=0.999)\\n\\n elif schedule == 'sqrt_linear':\\n betas = torch.linspace(\\n linear_start, linear_end, n_timestep, dtype=torch.float64)\\n elif schedule == 'sqrt':\\n betas = torch.linspace(\\n linear_start, linear_end, n_timestep, dtype=torch.float64)**0.5\\n else:\\n raise ValueError(f\\\"schedule '{schedule}' unknown.\\\")\\n return betas.numpy()\"\n },\n {\n \"identifier\": \"noise_like\",\n \"path\": \"ldm/modules/diffusionmodules/util.py\",\n \"snippet\": \"def noise_like(shape, device, repeat=False):\\n repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repeat(\\n shape[0], *((1, ) * (len(shape) - 1)))\\n noise = lambda: torch.randn(shape, device=device)\\n return repeat_noise() if repeat else noise()\"\n },\n {\n \"identifier\": \"DiagonalGaussianDistribution\",\n \"path\": \"ldm/modules/distributions/distributions.py\",\n \"snippet\": \"class DiagonalGaussianDistribution(object):\\n\\n def __init__(self, parameters, deterministic=False):\\n self.parameters = parameters\\n self.mean, self.logvar = torch.chunk(parameters, 2, dim=1)\\n self.logvar = torch.clamp(self.logvar, -30.0, 20.0)\\n self.deterministic = deterministic\\n self.std = torch.exp(0.5 * self.logvar)\\n self.var = torch.exp(self.logvar)\\n if self.deterministic:\\n self.var = self.std = torch.zeros_like(\\n self.mean).to(device=self.parameters.device)\\n\\n def sample(self):\\n x = self.mean + self.std * torch.randn(\\n self.mean.shape).to(device=self.parameters.device)\\n return x\\n\\n def kl(self, other=None):\\n if self.deterministic:\\n return torch.Tensor([0.])\\n else:\\n if other is None:\\n return 0.5 * torch.sum(\\n torch.pow(self.mean, 2) + self.var - 1.0 - self.logvar,\\n dim=[1, 2, 3])\\n else:\\n return 0.5 * torch.sum(\\n torch.pow(self.mean - other.mean, 2) / other.var\\n + self.var / other.var - 1.0 - self.logvar + other.logvar,\\n dim=[1, 2, 3])\\n\\n def nll(self, sample, dims=[1, 2, 3]):\\n if self.deterministic:\\n return torch.Tensor([0.])\\n logtwopi = np.log(2.0 * np.pi)\\n return 0.5 * torch.sum(\\n logtwopi + self.logvar\\n + torch.pow(sample - self.mean, 2) / self.var,\\n dim=dims)\\n\\n def mode(self):\\n return self.mean\"\n },\n {\n \"identifier\": \"normal_kl\",\n \"path\": \"ldm/modules/distributions/distributions.py\",\n \"snippet\": \"def normal_kl(mean1, logvar1, mean2, logvar2):\\n \\\"\\\"\\\"\\n source: https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/losses.py#L12\\n Compute the KL divergence between two gaussians.\\n Shapes are automatically broadcasted, so batches can be compared to\\n scalars, among other use cases.\\n \\\"\\\"\\\"\\n tensor = None\\n for obj in (mean1, logvar1, mean2, logvar2):\\n if isinstance(obj, torch.Tensor):\\n tensor = obj\\n break\\n assert tensor is not None, 'at least one argument must be a Tensor'\\n\\n # Force variances to be Tensors. Broadcasting helps convert scalars to\\n # Tensors, but it does not work for torch.exp().\\n logvar1, logvar2 = [\\n x if isinstance(x, torch.Tensor) else torch.tensor(x).to(tensor)\\n for x in (logvar1, logvar2)\\n ]\\n\\n return 0.5 * (-1.0 + logvar2 - logvar1 + torch.exp(logvar1 - logvar2) +\\n ((mean1 - mean2)**2) * torch.exp(-logvar2))\"\n },\n {\n \"identifier\": \"LitEma\",\n \"path\": \"ldm/modules/ema.py\",\n \"snippet\": \"class LitEma(nn.Module):\\n\\n def __init__(self, model, decay=0.9999, use_num_upates=True):\\n super().__init__()\\n if decay < 0.0 or decay > 1.0:\\n raise ValueError('Decay must be between 0 and 1')\\n\\n self.m_name2s_name = {}\\n self.register_buffer('decay', torch.tensor(decay, dtype=torch.float32))\\n self.register_buffer(\\n 'num_updates',\\n torch.tensor(0, dtype=torch.int)\\n if use_num_upates else torch.tensor(-1, dtype=torch.int))\\n\\n for name, p in model.named_parameters():\\n if p.requires_grad:\\n #remove as '.'-character is not allowed in buffers\\n s_name = name.replace('.', '')\\n self.m_name2s_name.update({name: s_name})\\n self.register_buffer(s_name, p.clone().detach().data)\\n\\n self.collected_params = []\\n\\n def forward(self, model):\\n decay = self.decay\\n\\n if self.num_updates >= 0:\\n self.num_updates += 1\\n decay = min(self.decay, (1 + self.num_updates) /\\n (10 + self.num_updates))\\n\\n one_minus_decay = 1.0 - decay\\n\\n with torch.no_grad():\\n m_param = dict(model.named_parameters())\\n shadow_params = dict(self.named_buffers())\\n\\n for key in m_param:\\n if m_param[key].requires_grad:\\n sname = self.m_name2s_name[key]\\n shadow_params[sname] = shadow_params[sname].type_as(\\n m_param[key])\\n shadow_params[sname].sub_(\\n one_minus_decay *\\n (shadow_params[sname] - m_param[key]))\\n else:\\n assert not key in self.m_name2s_name\\n\\n def copy_to(self, model):\\n m_param = dict(model.named_parameters())\\n shadow_params = dict(self.named_buffers())\\n for key in m_param:\\n if m_param[key].requires_grad:\\n m_param[key].data.copy_(\\n shadow_params[self.m_name2s_name[key]].data)\\n else:\\n assert not key in self.m_name2s_name\\n\\n def store(self, parameters):\\n \\\"\\\"\\\"\\n Save the current parameters for restoring later.\\n Args:\\n parameters: Iterable of `torch.nn.Parameter`; the parameters to be\\n temporarily stored.\\n \\\"\\\"\\\"\\n self.collected_params = [param.clone() for param in parameters]\\n\\n def restore(self, parameters):\\n \\\"\\\"\\\"\\n Restore the parameters stored with the `store` method.\\n Useful to validate the model with EMA parameters without affecting the\\n original optimization process. Store the parameters before the\\n `copy_to` method. After validation (or model saving), use this to\\n restore the former parameters.\\n Args:\\n parameters: Iterable of `torch.nn.Parameter`; the parameters to be\\n updated with the stored parameters.\\n \\\"\\\"\\\"\\n for c_param, param in zip(self.collected_params, parameters):\\n param.data.copy_(c_param.data)\"\n },\n {\n \"identifier\": \"count_params\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def count_params(model, verbose=False):\\n total_params = sum(p.numel() for p in model.parameters())\\n if verbose:\\n print(\\n f'{model.__class__.__name__} has {total_params * 1.e-6:.2f} M params.'\\n )\\n return total_params\"\n },\n {\n \"identifier\": \"default\",\n \"path\": \"ldm/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 {\n \"identifier\": \"exists\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def exists(x):\\n return x is not None\"\n },\n {\n \"identifier\": \"filter_nan_loss\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def filter_nan_loss(loss):\\n fake_loss = torch.isnan(loss)\\n loss = loss[torch.logical_not(fake_loss)]\\n\\n if loss.shape[0] == 0:\\n return loss.sum()\\n else:\\n return loss\"\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\\n print(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\": \"isimage\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def isimage(x):\\n if not isinstance(x, torch.Tensor):\\n return False\\n return (len(x.shape) == 4) and (x.shape[1] == 3 or x.shape[1] == 1)\"\n },\n {\n \"identifier\": \"ismap\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def ismap(x):\\n if not isinstance(x, torch.Tensor):\\n return False\\n return (len(x.shape) == 4) and (x.shape[1] > 3)\"\n },\n {\n \"identifier\": \"log_txt_as_img\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def log_txt_as_img(wh, xc, size=20):\\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('data/DejaVuSans.ttf', size=size)\\n nc = int(10 * (wh[0] / 256))\\n lines = '\\\\n'.join(xc[bi][start:start + nc]\\n 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\": \"mean_flat\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def mean_flat(tensor):\\n \\\"\\\"\\\"\\n https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/nn.py#L86\\n Take the mean over all non-batch dimensions.\\n \\\"\\\"\\\"\\n return tensor.mean(dim=list(range(1, len(tensor.shape))))\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import pdb\nimport numpy as np\nimport pytorch_lightning as pl\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom contextlib import contextmanager\nfrom functools import partial\nfrom einops import rearrange, repeat\nfrom ldm.models.autoencoder import (AutoencoderKL, IdentityFirstStage,\n VQModelInterface)\nfrom ldm.models.diffusion.ddim import DDIMSampler\nfrom ldm.models.diffusion.dpm_solver import DPMSolverSampler\nfrom ldm.models.diffusion.plms import PLMSSampler\nfrom ldm.modules.attention import CrossAttention\nfrom ldm.modules.diffusionmodules.util import (extract_into_tensor,\n make_beta_schedule, noise_like)\nfrom ldm.modules.distributions.distributions import (\n DiagonalGaussianDistribution, normal_kl)\nfrom ldm.modules.ema import LitEma\nfrom ldm.util import (count_params, default, exists, filter_nan_loss,\n instantiate_from_config, isimage, ismap, log_txt_as_img,\n mean_flat)\nfrom torch.optim.lr_scheduler import LambdaLR\nfrom torchvision.utils import make_grid\nfrom tqdm import tqdm\n from pytorch_lightning.utilities.distributed import rank_zero_only\n from pytorch_lightning.utilities.rank_zero import rank_zero_only"},"token_num":{"kind":"number","value":14901,"string":"14,901"},"cropped_code":{"kind":"string","value":"\n\nclass anneal_identity():\n\n def __call__(self, x, global_step):\n return x\n\n\ndef upper_bound(arr, key):\n left = 0\n right = len(arr)\n while left < right:\n mid = (left + right) >> 1\n if arr[mid] < key:\n left = mid + 1\n else:\n right = mid\n\n return left\n\n\nclass DDPM(pl.LightningModule):\n # classic DDPM with Gaussian diffusion, in image space\n def __init__(\n self,\n unet_config,\n timesteps=1000,\n beta_schedule='linear',\n loss_type='l2',\n ckpt_path=None,\n ignore_keys=[],\n load_only_unet=False,\n monitor='val/loss',\n use_ema=True,\n first_stage_key='image',\n image_size=256,\n channels=3,\n log_every_t=100,\n clip_denoised=True,\n linear_start=1e-4,\n linear_end=2e-2,\n cosine_s=8e-3,\n given_betas=None,\n original_elbo_weight=0.,\n v_posterior=0., # weight for choosing posterior variance as sigma = (1-v) * beta_tilde + v * beta\n l_simple_weight=1.,\n conditioning_key=None,\n parameterization='eps', # all assuming fixed variance schedules\n scheduler_config=None,\n use_positional_encodings=False,\n learn_logvar=False,\n logvar_init=0.,\n anneal_t=False, # we find at the begining, smaller t, larger denoise mse loss.\n anneal_global_step=[],\n anneal_ratio=0.9,\n prior_model=None,\n prior_normal=None,\n input_keys=['rgb'],\n ):\n super().__init__()\n assert parameterization in [\n 'eps', 'x0'\n ], 'currently only supporting \"eps\" and \"x0\"'\n self.parameterization = parameterization\n print(\n f'{self.__class__.__name__}: Running in {self.parameterization}-prediction mode'\n )\n self.cond_stage_model = None\n self.clip_denoised = clip_denoised\n self.log_every_t = log_every_t\n self.first_stage_key = first_stage_key\n self.image_size = image_size # try conv?\n self.channels = channels\n self.use_positional_encodings = use_positional_encodings\n self.model = DiffusionWrapper(unet_config, conditioning_key)\n count_params(self.model, verbose=True)\n self.use_ema = use_ema\n if self.use_ema:\n self.model_ema = LitEma(self.model)\n print(f'Keeping EMAs of {len(list(self.model_ema.buffers()))}.')\n\n self.use_scheduler = scheduler_config is not None\n if self.use_scheduler:\n self.scheduler_config = scheduler_config\n\n self.v_posterior = v_posterior\n self.original_elbo_weight = original_elbo_weight\n self.l_simple_weight = l_simple_weight\n self.input_keys = input_keys\n\n if monitor is not None:\n self.monitor = monitor\n if ckpt_path is not None:\n self.init_from_ckpt(\n ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet)\n\n self.register_schedule(\n given_betas=given_betas,\n beta_schedule=beta_schedule,\n timesteps=timesteps,\n linear_start=linear_start,\n linear_end=linear_end,\n cosine_s=cosine_s)\n\n self.loss_type = loss_type\n\n self.learn_logvar = learn_logvar\n self.logvar = torch.full(\n fill_value=logvar_init, size=(self.num_timesteps, ))\n if self.learn_logvar:\n self.logvar = nn.Parameter(self.logvar, requires_grad=True)\n\n ### anneal t function\n if not anneal_t:\n self.anneal_func = anneal_identity()\n else:\n self.anneal_func = anneal_warmup(anneal_ratio, anneal_global_step,\n self.num_timesteps)\n\n if prior_model is not None:\n"},"all_code":{"kind":"string","value":"\"\"\"\nwild mixture of\nhttps://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py\nhttps://github.com/openai/improved-diffusion/blob/e94489283bb876ac1477d5dd7709bbbd2d9902ce/improved_diffusion/gaussian_diffusion.py\nhttps://github.com/CompVis/taming-transformers\n-- merci\n\"\"\"\n\n\ntry:\nexcept:\n\n__conditioning_keys__ = {\n 'concat': 'c_concat',\n 'crossattn': 'c_crossattn',\n 'adm': 'y'\n}\n\n\ndef disabled_train(self, mode=True):\n \"\"\"Overwrite model.train with this function to make sure train/eval mode\n does not change anymore.\"\"\"\n return self\n\n\ndef uniform_on_device(r1, r2, shape, device):\n return (r1 - r2) * torch.rand(*shape, device=device) + r2\n\n\nclass anneal_identity():\n\n def __call__(self, x, global_step):\n return x\n\n\ndef upper_bound(arr, key):\n left = 0\n right = len(arr)\n while left < right:\n mid = (left + right) >> 1\n if arr[mid] < key:\n left = mid + 1\n else:\n right = mid\n\n return left\n\n\nclass DDPM(pl.LightningModule):\n # classic DDPM with Gaussian diffusion, in image space\n def __init__(\n self,\n unet_config,\n timesteps=1000,\n beta_schedule='linear',\n loss_type='l2',\n ckpt_path=None,\n ignore_keys=[],\n load_only_unet=False,\n monitor='val/loss',\n use_ema=True,\n first_stage_key='image',\n image_size=256,\n channels=3,\n log_every_t=100,\n clip_denoised=True,\n linear_start=1e-4,\n linear_end=2e-2,\n cosine_s=8e-3,\n given_betas=None,\n original_elbo_weight=0.,\n v_posterior=0., # weight for choosing posterior variance as sigma = (1-v) * beta_tilde + v * beta\n l_simple_weight=1.,\n conditioning_key=None,\n parameterization='eps', # all assuming fixed variance schedules\n scheduler_config=None,\n use_positional_encodings=False,\n learn_logvar=False,\n logvar_init=0.,\n anneal_t=False, # we find at the begining, smaller t, larger denoise mse loss.\n anneal_global_step=[],\n anneal_ratio=0.9,\n prior_model=None,\n prior_normal=None,\n input_keys=['rgb'],\n ):\n super().__init__()\n assert parameterization in [\n 'eps', 'x0'\n ], 'currently only supporting \"eps\" and \"x0\"'\n self.parameterization = parameterization\n print(\n f'{self.__class__.__name__}: Running in {self.parameterization}-prediction mode'\n )\n self.cond_stage_model = None\n self.clip_denoised = clip_denoised\n self.log_every_t = log_every_t\n self.first_stage_key = first_stage_key\n self.image_size = image_size # try conv?\n self.channels = channels\n self.use_positional_encodings = use_positional_encodings\n self.model = DiffusionWrapper(unet_config, conditioning_key)\n count_params(self.model, verbose=True)\n self.use_ema = use_ema\n if self.use_ema:\n self.model_ema = LitEma(self.model)\n print(f'Keeping EMAs of {len(list(self.model_ema.buffers()))}.')\n\n self.use_scheduler = scheduler_config is not None\n if self.use_scheduler:\n self.scheduler_config = scheduler_config\n\n self.v_posterior = v_posterior\n self.original_elbo_weight = original_elbo_weight\n self.l_simple_weight = l_simple_weight\n self.input_keys = input_keys\n\n if monitor is not None:\n self.monitor = monitor\n if ckpt_path is not None:\n self.init_from_ckpt(\n ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet)\n\n self.register_schedule(\n given_betas=given_betas,\n beta_schedule=beta_schedule,\n timesteps=timesteps,\n linear_start=linear_start,\n linear_end=linear_end,\n cosine_s=cosine_s)\n\n self.loss_type = loss_type\n\n self.learn_logvar = learn_logvar\n self.logvar = torch.full(\n fill_value=logvar_init, size=(self.num_timesteps, ))\n if self.learn_logvar:\n self.logvar = nn.Parameter(self.logvar, requires_grad=True)\n\n ### anneal t function\n if not anneal_t:\n self.anneal_func = anneal_identity()\n else:\n self.anneal_func = anneal_warmup(anneal_ratio, anneal_global_step,\n self.num_timesteps)\n\n if prior_model is not None:"},"next_line":{"kind":"string","value":" self.prior_model = instantiate_from_config(prior_model)"},"gold_snippet_index":{"kind":"number","value":17,"string":"17"},"created_at":{"kind":"string","value":"2023-12-06 07:29:34+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5970,"cells":{"repo_name":{"kind":"string","value":"RobertCsordas/moe_attention"},"file_path":{"kind":"string","value":"tasks/simple/language_model/transformer_lm_mixin.py"},"context":{"kind":"list like","value":[{"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: bool, layers: List[torch.nn.Module], n_prev_states: int,\n n_prev_states_test: Optional[int] = None, adaptive_cutoffs: List[int] = [],\n same_length_eval: bool = True, norm_before_output: bool = False,\n p_drop_layer: float = 0.0, use_last_state: bool = False, same_length: bool = False):\n\n super().__init__()\n\n self.embedding = torch.nn.Embedding(voc_size, embedding_size or state_size)\n torch.nn.init.kaiming_normal_(self.embedding.weight, mode=\"fan_in\", nonlinearity=\"linear\")\n\n self.shared_layers = all([la is layers[0] for la in layers])\n\n if embedding_size is None:\n self.embedding_adapter = lambda x: x\n else:\n self.embedding_adapter = torch.nn.Linear(embedding_size, state_size)\n\n self.dropout = torch.nn.Dropout(dropout)\n self.layers = layers\n self.unique_layers = torch.nn.ModuleList(unique_obejcts(layers))\n self.output_adapter = lambda x: x\n self.n_prev_states = n_prev_states\n self.n_prev_states_test = n_prev_states_test or n_prev_states\n self.same_length_eval = same_length_eval\n self.embedding_scale = math.sqrt(state_size)\n self.p_drop_layer = p_drop_layer\n self.use_last_state = use_last_state\n self.same_length = same_length\n self.iter = 0\n\n self.adaptive = bool(adaptive_cutoffs)\n\n out_proj_size = (embedding_size or state_size) if tied_embedding else state_size\n if self.adaptive:\n self.output = framework.layers.CustomAdaptiveLogSoftmaxWithLoss(\n out_proj_size, voc_size, adaptive_cutoffs, div_value=1,\n tied_to=self.embedding if tied_embedding else None)\n else:\n self.output = torch.nn.Linear(out_proj_size, voc_size)\n\n if norm_before_output:\n self.out_norm = torch.nn.LayerNorm(state_size)\n else:\n self.out_norm = lambda x: x\n\n if tied_embedding:\n if not self.adaptive:\n self.output.weight = self.embedding.weight\n if embedding_size is not None:\n self.output_adapter = torch.nn.Linear(state_size, embedding_size)\n\n @staticmethod\n def generate_history_mask(sz: int, device: torch.device) -> torch.Tensor:\n return torch.tril(torch.ones(sz, sz, dtype=torch.bool, device=device), diagonal=-1)\n\n def gen_output(self, x: torch.Tensor, target: Optional[torch.Tensor]) -> torch.Tensor:\n net = self.out_norm(x)\n net = self.output_adapter(net)\n net = self.dropout(net)\n\n if self.adaptive:\n net = self.output(net.transpose(0, 1), target)\n else:\n net = self.output(net.transpose(0, 1))\n\n return net\n\n def forward(self, x: torch.Tensor, target: Optional[torch.Tensor], state) -> Tuple[torch.Tensor, Any]:\n causality_mask = Transformer.generate_square_subsequent_mask(x.shape[0], x.device)\n\n net = self.dropout(self.embedding(x.T.long()))\n net = self.embedding_adapter(net)\n net = net * self.embedding_scale\n\n new_state = []\n features = [net]\n\n n_prev_states = self.n_prev_states if self.training else self.n_prev_states_test\n\n same_length = self.same_length or ((not self.training) and self.same_length_eval)\n if same_length and state is not None:\n causality_mask = [self.generate_history_mask(x.shape[0], x.device)] + \\\n [torch.zeros_like(causality_mask)] * (len(state[0]) - 1) + [causality_mask]\n causality_mask = torch.cat(causality_mask, -1)\n\n\n plot_cossim = (self.iter % 100 == 0 and self.training)\n for li, l in enumerate(self.layers):\n if n_prev_states > 0:\n if li == 0:\n # Pos offset should be constant for all layers\n pos_offset = sum(s.shape[1] for s in state[0]) if state is not None else 0\n\n # Concatenate the new state with the previous states\n li_r = -1 if self.use_last_state else li\n s = (state[li_r] + [net]) if state is not None else [net]\n attend_to = torch.cat(s, 1)\n\n if not self.use_last_state:\n s[-1] = s[-1].detach()\n new_state.append(s[-n_prev_states:])\n else:\n pos_offset = None\n attend_to = None\n\n net_o = l(net, mask=AttentionMask(None, causality_mask), attend_to=attend_to,\n pos_offset=pos_offset)\n\n if plot_cossim:\n features.append(net_o)\n\n with torch.no_grad():\n ndiff = torch.norm(net_o - net, p=2, dim=-1)\n n_in = torch.norm(net, p=2, dim=-1)\n self.log(f\"activation_norm/abs_update_layer_{li}\", ndiff.mean())\n self.log(f\"activation_norm/in_layer_{li}\", n_in.mean())\n self.log(f\"activation_norm/rel_update_layer_{li}\", (ndiff/n_in.clamp(min=torch.finfo(n_in.dtype).eps)).mean())\n\n if self.training and self.p_drop_layer > 0.0:\n net = torch.where(torch.rand_like(net_o[..., 0:1]) < self.p_drop_layer, net, net_o)\n else:\n net = net_o\n\n if self.use_last_state and n_prev_states > 0:\n # If we carry over the last state, save it here\n new_state = [((state[0] if state is not None else []) + [net.detach()])[-n_prev_states:]]\n\n if plot_cossim:\n with torch.no_grad():\n f_sample = [f.view(-1, f.shape[-1])[:1024] for f in features]\n f_sample_all = torch.stack(f_sample, -2)\n scores = framework.utils.cossim(f_sample_all, f_sample_all).mean(0)\n self.log(\"feature_cossim\", framework.visualize.plot.Heatmap(scores, range=(0, 1), textval=False))\n\n outs = F.softmax(self.gen_output(f_sample_all, target).transpose(0, 1), -1)\n scores = framework.utils.cossim(outs, outs).mean(0)\n self.log(\"out_dist_cossim\", framework.visualize.plot.Heatmap(scores, range=(0, 1), textval=False))\n\n real_out = outs[:, -1]\n for i in range(outs.shape[-2] - 1):\n self.log(f\"out_diff_{i}\", (outs[:, i] - real_out).norm(dim=-1, p=1).mean())\n\n del outs\n\n\n del features\n\n net = self.gen_output(net, target)\n self.iter += 1\n\n return net, new_state"},{"identifier":"task","path":"tasks/task_db.py","snippet":"def task(name: Optional[str] = None):\n def wrapper(cls):\n n = TASK_PREFIX + (name or camel_to_snake(cls.__name__))\n assert n not in TASKS, f\"Task {n} already exists\"\n TASKS[n] = cls\n return cls\n return wrapper"},{"identifier":"args","path":"tasks/task_db.py","snippet":"def args(fn):\n global ARGS_REGISTERS\n ARGS_REGISTERS.append(fn)\n return fn"},{"identifier":"RelativeTransformerEncoderLayer","path":"layers/transformer/relative_transformer.py","snippet":"class RelativeTransformerEncoderLayer(torch.nn.Module):\n def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation: ActivationFunction = F.relu,\n attention_dropout=0, test_pos_clamp: Optional[int] = None, drop_expand: bool = True,\n head_projection_size: Optional[int] = None, ln_after_attention: bool = True):\n super().__init__()\n self.ln_after_attention = ln_after_attention\n self.self_attn = FixedRelativeMultiheadAttention(\n d_model, nhead, dropout=attention_dropout, test_pos_clamp=test_pos_clamp,\n projection_size=head_projection_size)\n self.linear1 = torch.nn.Linear(d_model, dim_feedforward)\n self.dropout = torch.nn.Dropout(dropout) if drop_expand else lambda x: x\n self.linear2 = torch.nn.Linear(dim_feedforward, d_model)\n\n if ln_after_attention:\n self.norm1 = torch.nn.LayerNorm(d_model)\n self.norm2 = torch.nn.LayerNorm(d_model)\n self.dropout1 = torch.nn.Dropout(dropout)\n self.dropout2 = torch.nn.Dropout(dropout)\n\n self.activation = activation\n self.reset_parameters()\n\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\n pos_offset: Optional[int] = None) -> torch.Tensor:\n src2 = self.self_attn(src, attend_to if attend_to is not None else src, mask, pos_offset=pos_offset)\n src = src + self.dropout1(src2)\n src = self.norm1(src) if self.ln_after_attention else src\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))\n src = src + self.dropout2(src2)\n src = self.norm2(src)\n return src\n\n def reset_parameters(self):\n torch.nn.init.xavier_normal_(self.linear1.weight, gain=torch.nn.init.calculate_gain('relu')\n if self.activation is F.relu else 1.0)\n torch.nn.init.xavier_uniform_(self.linear2.weight)"},{"identifier":"PrelnRelativeTransformerEncoderLayer","path":"layers/transformer/relative_preln_transformer.py","snippet":"class PrelnRelativeTransformerEncoderLayer(RelativeTransformerEncoderLayer):\n is_preln = True\n\n def __init__(self, d_model, nhead, n_layers: int, dim_feedforward=2048, dropout=0.1,\n activation: ActivationFunction = F.relu, attention_dropout=0, test_pos_clamp: Optional[int] = None,\n drop_expand: bool = True, head_projection_size: Optional[int] = None):\n super().__init__(\n d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, dropout=dropout,\n activation=activation, attention_dropout=attention_dropout, test_pos_clamp=test_pos_clamp,\n drop_expand=drop_expand, head_projection_size=head_projection_size)\n\n reset_prenorm_params(self, n_layers)\n\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\n pos_offset: Optional[int] = None) -> torch.Tensor:\n src2 = self.norm1(src)\n src2 = self.self_attn(src2, self.norm1(attend_to) if attend_to is not None else src2, mask,\n pos_offset=pos_offset)\n src = src + self.dropout1(src2)\n src2 = self.norm2(src)\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))\n src = src + self.dropout2(src2)\n return src"},{"identifier":"RelativeMoeTransformerEncoderLayer","path":"layers/transformer/relative_moe_transformer.py","snippet":"class RelativeMoeTransformerEncoderLayer(LoggingLayer, torch.nn.Module):\n def __init__(self, d_model, nhead, n_experts: int, expert_size: int, n_layers: int,\n dropout=0.1, activation: ActivationFunction = F.relu, attention_dropout=0,\n test_pos_clamp: Optional[int] = None,\n dropout_mode: str = \"none\", selection_mode: str = \"add\",\n perplexity_reg: float = 0.0,\n n_heads: int = 1, norm_keys: bool = False, perplexity_reg_mode: str=\"step\",\n n_random: int = 0, reg_type: str = \"normal\",\n topk_mode: str = \"full\", head_projection_size: Optional[int] = None,\n activation_after_topk: bool = False,\n drop_parallel: bool = True,\n normalize_expert_sel_init: bool = False, norm_key_init: bool = False, norm_value_init: bool = False,\n identical_init: bool = False,\n sel_norm: str = \"none\",\n preln: bool = True, ln_affine: bool = True,\n moe_dropout_factor: float = 1.0,\n drop_expert: float = 0.0, sync_distributed: bool = True,\n modulation_amplitude: float = 0.5, moe_init_scale: float = 1.0,\n moe_att_n_experts: int = 4, moe_att_expert_dropout: Optional[float] = None,\n moe_att_selection_mode: str = \"sigmoid\",\n moe_att_k: Optional[int] = None, moe_att_ppl_reg: Optional[float] = None,\n q_expert: bool = True, k_expert: bool = True, v_expert: bool = True,\n o_expert: bool = True,\n v_projection_size: Optional[int] = None,\n qside_n_experts: Optional[int] = None,\n moe_attention: bool = False, moe_att_variant: str = \"full\",\n moe_att_shared_experts: bool = False,\n moe_att_kq_n_experts: Optional[int] = None, moe_att_separate_kq_sel: bool = False,\n moe_att_norm_init: bool = False, moe_att_same_sel: bool = False, moe_att_norm_retrieval: bool = False,\n rotate_fraction: float = 0.5, rope_base: float = 10000):\n super().__init__()\n self.preln = preln\n self.i = 0\n\n if moe_attention:\n if moe_att_variant == \"full\":\n self.self_attn = FullMoeRelativeAttention(\n d_model, nhead, dropout=attention_dropout,\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\n n_experts=moe_att_n_experts,\n perplexity_reg=perplexity_reg if moe_att_ppl_reg is None else moe_att_ppl_reg,\n expert_dropout=drop_expert if moe_att_expert_dropout is None else moe_att_expert_dropout,\n selection_mode=moe_att_selection_mode, q_expert=q_expert, k_expert=k_expert, v_expert=v_expert,\n moe_k=n_heads if moe_att_k is None else moe_att_k, o_expert=o_expert, qside_n_experts=qside_n_experts,\n v_projection_size=v_projection_size, shared_experts=moe_att_shared_experts,\n kq_n_experts=moe_att_kq_n_experts, separate_kq_sel=moe_att_separate_kq_sel,\n normalize_init=moe_att_norm_init,\n same_sel=moe_att_same_sel, normalize_retrieval=moe_att_norm_retrieval,\n )\n elif moe_att_variant == \"full_rope\":\n self.self_attn = FullMoeRopeAttention(\n d_model, nhead, dropout=attention_dropout,\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\n n_experts=moe_att_n_experts,\n perplexity_reg=perplexity_reg if moe_att_ppl_reg is None else moe_att_ppl_reg,\n expert_dropout=drop_expert if moe_att_expert_dropout is None else moe_att_expert_dropout,\n selection_mode=moe_att_selection_mode, q_expert=q_expert, k_expert=k_expert, v_expert=v_expert,\n moe_k=n_heads if moe_att_k is None else moe_att_k, o_expert=o_expert, qside_n_experts=qside_n_experts,\n v_projection_size=v_projection_size, shared_experts=moe_att_shared_experts,\n kq_n_experts=moe_att_kq_n_experts, separate_kq_sel=moe_att_separate_kq_sel,\n normalize_init=moe_att_norm_init, normalize_retrieval=moe_att_norm_retrieval,\n rotate_fraction=rotate_fraction, rope_base=rope_base,\n )\n else:\n raise ValueError(f\"Unknown attention variant {moe_att_variant}\")\n else:\n self.self_attn = FixedRelativeMultiheadAttention(\n d_model, nhead, dropout=attention_dropout, test_pos_clamp=test_pos_clamp,\n projection_size=head_projection_size)\n\n std_scale = math.sqrt(2.0 / n_layers) if preln else 1.0\n std_scale *= math.sqrt(moe_init_scale)\n\n self.pkm = MoE(\n d_model, n_experts, expert_size, dropout=dropout * moe_dropout_factor, dropout_mode=dropout_mode,\n weight_scale=std_scale, selection_mode=selection_mode,\n perplexity_reg=perplexity_reg, n_heads=n_heads,\n norm_keys=norm_keys, perplexity_reg_mode=perplexity_reg_mode, n_random=n_random,\n reg_type=reg_type, topk_mode=topk_mode,\n activation_after_topk=activation_after_topk,\n activation=activation,\n normalize_expert_sel_init=normalize_expert_sel_init, norm_key_init=norm_key_init,\n norm_value_init=norm_value_init, identical_init=identical_init,\n sel_norm=sel_norm,\n expert_dropout=drop_expert,\n sync_distributed=sync_distributed,\n modulation_amplitude=modulation_amplitude)\n\n self.norm1 = torch.nn.LayerNorm(d_model, elementwise_affine=ln_affine)\n self.norm2 = torch.nn.LayerNorm(d_model, elementwise_affine=ln_affine)\n self.dropout = torch.nn.Dropout(dropout)\n\n self.activation = activation\n self.drop_parallel = drop_parallel\n\n if preln:\n reset_prenorm_params(self, n_layers)\n\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\n pos_offset: Optional[int] = None) -> torch.Tensor:\n\n src2 = self.norm1(src) if self.preln else src\n src2 = self.self_attn(src2, self.norm1(attend_to) if attend_to is not None else src2, mask,\n pos_offset=pos_offset)\n src = src + self.dropout(src2)\n\n if self.preln:\n src2 = self.norm2(src)\n else:\n src = src2 = self.norm1(src)\n\n src3 = self.pkm(src2)\n\n src = src + self.dropout(src3)\n if not self.preln:\n src = self.norm2(src)\n return src"},{"identifier":"FastRopeTransformerEncoderLayer","path":"layers/transformer/fast_rope_transformer.py","snippet":"class FastRopeTransformerEncoderLayer(torch.nn.Module):\n def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation: ActivationFunction = F.relu,\n attention_dropout=0, drop_expand: bool = True,\n head_projection_size: Optional[int] = None, preln: bool = False, n_layers: Optional[int] = None,\n rotate_fraction: float = 0.5, rope_base: float = 10000):\n super().__init__()\n self.preln = preln\n self.self_attn = FastRopeAttention(\n d_model, nhead, dropout=attention_dropout,\n projection_size=head_projection_size, rotate_fraction=rotate_fraction,\n rope_base=rope_base)\n self.linear1 = torch.nn.Linear(d_model, dim_feedforward)\n self.dropout = torch.nn.Dropout(dropout) if drop_expand else lambda x: x\n self.linear2 = torch.nn.Linear(dim_feedforward, d_model)\n\n self.norm1 = torch.nn.LayerNorm(d_model)\n self.norm2 = torch.nn.LayerNorm(d_model)\n self.dropout1 = torch.nn.Dropout(dropout)\n self.dropout2 = torch.nn.Dropout(dropout)\n\n self.activation = activation\n\n if preln:\n if n_layers is None:\n raise ValueError(\"n_layers must be specified when using preln\")\n reset_prenorm_params(self, n_layers)\n else:\n self.reset_parameters()\n\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\n pos_offset: Optional[int] = None) -> torch.Tensor:\n src2 = self.norm1(src) if self.preln else src\n src2 = self.self_attn(src2, self.norm1(attend_to) if attend_to is not None else src2, mask, pos_offset=pos_offset)\n src = src + self.dropout1(src2)\n\n if self.preln:\n src2 = self.norm2(src)\n else:\n src2 = src = self.norm1(src)\n\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))\n src = src + self.dropout2(src2)\n\n if not self.preln:\n src = self.norm2(src)\n return src\n\n def reset_parameters(self):\n torch.nn.init.xavier_normal_(self.linear1.weight, gain=torch.nn.init.calculate_gain('relu')\n if self.activation is F.relu else 1.0)\n torch.nn.init.xavier_uniform_(self.linear2.weight)"},{"identifier":"MoeAttentionRelativeTransformerEncoderLayer","path":"layers/transformer/moe_attention_relative_transformer.py","snippet":"class MoeAttentionRelativeTransformerEncoderLayer(torch.nn.Module):\n def __init__(self, d_model, nhead, moe_att_n_experts, dim_feedforward=2048, dropout=0.1, activation: ActivationFunction = F.relu,\n attention_dropout=0, drop_expand: bool = True,\n head_projection_size: Optional[int] = None, preln: bool = False, n_layers: Optional[int] = None,\n att_perplexity_reg: float = 0.0, expert_dropout: float = 0.0, att_selection_mode=\"sigmoid\",\n attention_variant=\"moa\", q_expert: bool = True, k_expert: bool = True, v_expert: bool = True,\n o_expert: bool = True, moe_k: int = 2,\n norm_qk_score: bool = False, v_projection_size: Optional[int] = None, same_sel: bool = False,\n qside_n_experts: Optional[int] = None, shared_experts: bool = False,\n kq_n_experts: Optional[int] = None, separate_kq_sel: bool = False,\n cvloss: float = 0.0, switchloss: float = 0.0, zloss: float = 0.0,\n moa_mode: str = \"my\", rotate_fraction: float = 0.5, rope_base: float = 10000,\n moeatt_norm_init: bool = False):\n super().__init__()\n self.is_preln = preln\n if attention_variant not in {\"full\", \"full_rope\"} and (not q_expert):\n raise ValueError(\"q_expert can be disabled only when using qside attention\")\n\n if attention_variant == \"moa\":\n self.self_attn = MoA(\n d_model, nhead, dropout=attention_dropout,\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\n n_experts=moe_att_n_experts, perplexity_reg=att_perplexity_reg, expert_dropout=expert_dropout,\n selection_mode=att_selection_mode, mode=moa_mode, cvloss=cvloss, switchloss=switchloss, zloss=zloss\n )\n elif attention_variant == \"full\":\n self.self_attn = FullMoeRelativeAttention(\n d_model, nhead, dropout=attention_dropout,\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\n n_experts=moe_att_n_experts, perplexity_reg=att_perplexity_reg, expert_dropout=expert_dropout,\n selection_mode=att_selection_mode, q_expert=q_expert, k_expert=k_expert, v_expert=v_expert,\n norm_qk_score=norm_qk_score, v_projection_size=v_projection_size, same_sel=same_sel,\n o_expert=o_expert, moe_k=moe_k, qside_n_experts=qside_n_experts,\n shared_experts=shared_experts, kq_n_experts=kq_n_experts, separate_kq_sel=separate_kq_sel,\n normalize_init=moeatt_norm_init\n )\n elif attention_variant == \"full_rope\":\n self.self_attn = FullMoeRopeAttention(\n d_model, nhead, dropout=attention_dropout,\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\n n_experts=moe_att_n_experts, perplexity_reg=att_perplexity_reg, expert_dropout=expert_dropout,\n selection_mode=att_selection_mode, q_expert=q_expert, k_expert=k_expert, v_expert=v_expert,\n norm_qk_score=norm_qk_score, v_projection_size=v_projection_size, same_sel=same_sel,\n o_expert=o_expert, moe_k=moe_k, qside_n_experts=qside_n_experts,\n shared_experts=shared_experts, kq_n_experts=kq_n_experts, separate_kq_sel=separate_kq_sel,\n rotate_fraction=rotate_fraction, rope_base=rope_base,\n normalize_init=moeatt_norm_init\n )\n else:\n raise ValueError(f\"Unknown attention variant: {attention_variant}\")\n\n self.linear1 = torch.nn.Linear(d_model, dim_feedforward)\n self.dropout = torch.nn.Dropout(dropout) if drop_expand else lambda x: x\n self.linear2 = torch.nn.Linear(dim_feedforward, d_model)\n\n self.norm1 = torch.nn.LayerNorm(d_model)\n self.norm2 = torch.nn.LayerNorm(d_model)\n self.dropout1 = torch.nn.Dropout(dropout)\n self.dropout2 = torch.nn.Dropout(dropout)\n\n self.activation = activation\n\n if preln:\n if n_layers is None:\n raise ValueError(\"n_layers must be specified when using preln\")\n reset_prenorm_params(self, n_layers)\n else:\n self.reset_parameters()\n\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\n pos_offset: Optional[int] = None) -> torch.Tensor:\n src2 = self.norm1(src) if self.is_preln else src\n src2 = self.self_attn(src2, self.norm1(attend_to) if attend_to is not None else src2, mask, pos_offset=pos_offset)\n src = src + self.dropout1(src2)\n\n if self.is_preln:\n src2 = self.norm2(src)\n else:\n src2 = src = self.norm1(src)\n\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))\n src = src + self.dropout2(src2)\n\n if not self.is_preln:\n src = self.norm2(src)\n return src\n\n def reset_parameters(self):\n torch.nn.init.xavier_normal_(self.linear1.weight, gain=torch.nn.init.calculate_gain('relu')\n if self.activation is F.relu else 1.0)\n torch.nn.init.xavier_uniform_(self.linear2.weight)"},{"identifier":"MoE","path":"layers/moe_layer.py","snippet":"class MoE(LoggingLayer, RegularizedLayer, OncePerIterLayer, torch.nn.Module):\n def __init__(self, dmodel: int, n_experts: int, expert_size: int, n_heads: int,\n dropout: float = 0, weight_scale: float = 1.0,\n dropout_mode: str = \"none\", selection_mode: str = \"sigmoid\", perplexity_reg: float = 0.0,\n norm_keys: bool = False,\n perplexity_reg_mode: str=\"step\", n_random: int = 0, reg_type: str = \"entropy\",\n topk_mode: str = \"full\", activation_after_topk: bool = False,\n activation = lambda x: F.relu(x, inplace=True),\n normalize_expert_sel_init: bool = False, norm_key_init: bool = False, norm_value_init: bool = False,\n identical_init: bool = False,\n rescale_normed: bool = False, sel_norm: str = \"none\",\n v_dim: Optional[int] = None,\n expert_dropout: float = 0.0,\n sync_distributed: bool = False,\n modulation_amplitude: float = 0.5,\n ppl_past_blocks: int = 0):\n\n super().__init__()\n self.k_dim = dmodel\n self.v_dim = v_dim if v_dim is not None else dmodel\n self.n_experts = n_experts\n self.expert_size = expert_size\n self.size = self.n_experts * self.expert_size\n self.dropout = dropout\n self.dropout_mode = dropout_mode\n self.selection_mode = selection_mode\n self.perplexity_reg = perplexity_reg\n self.k_vec_dim = self.k_dim\n self.n_heads = n_heads\n self.norm_keys = norm_keys\n self.perplexity_reg_mode = perplexity_reg_mode\n self.n_random = n_random\n self.reg_type = reg_type\n self.topk_mode = topk_mode\n self.activation_after_topk = activation_after_topk\n self.activation = activation\n self.weight_scale = weight_scale\n self.normalize_expert_sel_init = normalize_expert_sel_init\n self.norm_key_init = norm_key_init\n self.norm_value_init = norm_value_init\n self.identical_init = identical_init\n self.layer = 0\n self.initalized = False\n self.rescale_normed = rescale_normed\n self.sel_norm = sel_norm\n self.was_training = True\n self.expert_dropout = expert_dropout\n self.reg_counts = 0\n self.sync_distributed = sync_distributed and torch.distributed.is_initialized()\n self.modulation_amplitude = modulation_amplitude\n self.record_all_expert_sel_counts = False\n self.ppl_past_blocks = ppl_past_blocks\n self.blocks_for_ppl = []\n self.recorded_inputs = []\n\n self.coocurence = None\n\n assert self.selection_mode in {\"gate\", \"sigmoid\", \"sinkhorn\", \"sinkhorn2\", \"sinkmoid\", \"sinkmax\", \"sinkhorn_local\", \"mul\", \"sinkmoid2\", \"sinkmax2\"}\n assert self.perplexity_reg_mode in {\"step\", \"global\", \"time\", \"global_time\"}\n assert self.dropout_mode in {\"none\", \"score\"}\n assert self.reg_type in {\"perplexity\", \"variance\", \"entropy\", \"l2\", \"switch\"}\n assert self.topk_mode in {\"full\", \"l1_approx\", \"approx\"}\n assert self.sel_norm in {\"none\", \"cos\", \"input\", \"weights\"}\n\n self.register_buffer(\"iter\", torch.tensor(0, dtype=torch.int64), persistent=False)\n\n if selection_mode in {\"mul\"} and activation_after_topk:\n raise ValueError(\"Activation after topk is not supported with mul selection\")\n\n self.keys = torch.nn.Parameter(torch.empty(self.n_experts, self.k_vec_dim, self.expert_size))\n\n self.values = torch.nn.Parameter(torch.empty(self.n_experts, self.expert_size, self.v_dim))\n\n self.expert_sel = torch.nn.Parameter(torch.empty(self.n_experts, self.k_vec_dim))\n self.sel = lambda x: F.linear(x, self.expert_sel)\n\n torch.nn.init.normal_(self.expert_sel, std=self.k_vec_dim ** -0.5 * weight_scale)\n torch.nn.init.normal_(self.keys, std=dmodel ** -0.5 * weight_scale)\n torch.nn.init.normal_(self.values, std=self.size ** -0.5 * weight_scale)\n self.sel_hist = []\n self.index_sel_counts = 0\n self.index_sel_norm = 0\n\n self.index_sel_counts_100 = 0\n self.index_sel_norm_100 = 0\n\n self.sel_count_log = None\n\n self.all_expert_sel_counts = []\n self.all_expert_sel_soft = []\n\n self.register_buffer(\"kv_sel_counts\", torch.zeros(self.n_experts, self.expert_size), persistent=False)\n self.register_buffer(\"kv_sel_counts_100\", torch.zeros_like(self.kv_sel_counts))\n\n if self.rescale_normed and self.sel_norm != \"none\":\n self.sel_scale = torch.nn.Parameter(torch.ones([1]))\n else:\n self.sel_scale = 1.0\n\n self.register_buffer(\"seq\", torch.arange(max(self.n_heads, self.n_experts, self.k_dim, self.v_dim), dtype=torch.long), persistent=False)\n self.regroup_weights()\n\n if self.ppl_past_blocks > 0 and self.reg_type not in {\"perplexity\", \"entropy\"}:\n print(f\"Warning: ppl_past_blocks>0 (currently {self.ppl_past_blocks}) is only supported with perplexity and entropy regularization\")\n\n def keys_to_logical_order(self, keys: torch.Tensor) -> torch.Tensor:\n k = keys.view(self.n_experts, self.k_vec_dim, self.expert_size)\n return k.permute(0, 2, 1).contiguous().view(-1, self.k_vec_dim)\n\n def keys_from_logical_order(self, keys: torch.Tensor) -> torch.Tensor:\n return keys.view(self.n_experts, self.expert_size, self.k_vec_dim).permute(0, 2, 1).contiguous().view(self.n_experts * self.k_vec_dim, self.expert_size)\n\n def renorm_keep_std(self, weight: torch.Tensor, dim: int = 0):\n with torch.no_grad():\n std = weight.std()\n weight.div_(weight.norm(dim=dim, keepdim=True))\n weight.mul_(std / weight.std())\n\n def regroup_weights(self) -> Optional[torch.Tensor]:\n with torch.no_grad():\n if self.norm_key_init:\n self.renorm_keep_std(self.keys.view(self.n_experts, self.k_vec_dim, self.expert_size), dim=1)\n\n if self.norm_value_init:\n self.renorm_keep_std(self.values, dim=1)\n\n if self.identical_init:\n k = self.keys.view(self.n_experts, self.k_vec_dim, self.expert_size)\n self.keys.set_(k[:1].expand_as(k).reshape_as(self.keys))\n\n v = self.values.view(self.n_experts, self.expert_size, self.v_dim)\n self.values.set_(v[:1].expand_as(v).reshape_as(self.values))\n\n if self.normalize_expert_sel_init:\n self.renorm_keep_std(self.expert_sel, dim=1)\n\n def ani(self, x: torch.Tensor) -> torch.Tensor:\n assert x.ndim == 2\n chunk_size = 32\n\n xnorm = F.normalize(x, 2, dim=-1)\n\n accu = 0\n for i in range(0, x.shape[0], chunk_size):\n a = xnorm[i: i + chunk_size]\n sims = xnorm @ a.T\n sims[i : i + chunk_size].fill_diagonal_(0)\n accu += sims.sum()\n\n return accu / (x.shape[0] * (x.shape[0] - 1))\n\n def log_expert_sel_usage(self, prefix: str, channel_sel_counts: torch.Tensor):\n sel_nonzero = (channel_sel_counts != 0).type(torch.float).sum(axis=-1) / self.expert_size\n self.log(f\"{prefix}/mean\", sel_nonzero.mean())\n self.log(f\"{prefix}/min\", sel_nonzero.min())\n self.log(f\"{prefix}/max\", sel_nonzero.max())\n\n\n def pre_train_forward(self):\n if self.norm_keys:\n with torch.no_grad():\n self.keys.div_(self.keys.norm(dim=-1, keepdim=True))\n\n if self.training and not self.was_training:\n sorted_counts = self.index_sel_counts.sort(descending=True).values\n self.log(\"test_exert_channel_usage\", framework.visualize.plot.Barplot(sorted_counts, xlabel=\"expert\", ylabel=\"usage count\"), drop_old=True)\n\n self.layer = 0\n if self.sel_hist:\n self.sel_hist = []\n self.index_sel_counts = 0\n self.index_sel_norm = 0\n self.reg_counts = 0\n\n def before_loss(self):\n if self.sel_hist:\n # Concatenate against time dimension. Important for the within-batch regularization\n sel = torch.cat(self.sel_hist, -2)\n self.add_perplexity_reg(sel)\n\n self.sel_hist = []\n\n if self.index_sel_norm > 0:\n if self.training:\n with torch.no_grad():\n self.log(\"usag_rel_perplexity_all_layers\", utils.relative_perplexity(self.index_sel_counts / self.index_sel_norm))\n self.log(\"dead_expert_proportion_all_layers\", (self.index_sel_counts == 0).float().sum() / self.n_experts)\n\n self.log_expert_sel_usage(\"exert_channel_usage\", self.kv_sel_counts)\n\n self.kv_sel_counts_100.add_(self.kv_sel_counts)\n self.kv_sel_counts.zero_()\n\n self.index_sel_counts_100 = self.index_sel_counts_100 + self.index_sel_counts\n self.index_sel_norm_100 = self.index_sel_norm_100 + self.index_sel_norm\n\n if self.training and self.iter % 100 == 0:\n norm_cnt = self.index_sel_counts_100 / self.index_sel_norm_100\n self.log(\"usag_rel_perplexity_100\", utils.relative_perplexity(norm_cnt))\n self.log(\"dead_expert_proportion_100\", (self.index_sel_counts_100 == 0).float().sum() / self.n_experts)\n\n sorted_counts = self.index_sel_counts_100.sort(descending=True).values\n self.log(\"usage_counts_100\", framework.visualize.plot.Barplot(sorted_counts, xlabel=\"expert\", ylabel=\"usage count\"), drop_old=True)\n\n\n self.log_expert_sel_usage(\"exert_channel_usage_100\", self.kv_sel_counts_100)\n self.kv_sel_counts_100.zero_()\n\n self.index_sel_counts_100 = 0\n self.index_sel_norm_100 = 0\n\n self.log(\"ani/keys\", self.ani(self.keys_to_logical_order(self.keys)))\n self.log(\"ani/values\", self.ani(self.values.flatten(0, -2)))\n self.log(\"ani/expert_sel\", self.ani(self.expert_sel.T))\n\n if self.training:\n self.iter += 1\n\n def topk(self, x: torch.Tensor, k: int, approx: bool) -> Tuple[torch.Tensor, torch.Tensor]:\n if approx:\n x = x.view(*x.shape[:-1], k, -1)\n scores, ind = x.max(-1)\n return scores, self.seq[:k] * x.shape[-1] + ind\n else:\n return x.topk(k, dim=-1, sorted=False)\n\n def rolling_logsumexp(self, x: torch.Tensor) -> torch.Tensor:\n # Simulate calculating logsumexp over a bigger batch than the current one. Will have stale values, but that\n # should not matter much later in training.\n if self.ppl_past_blocks == 0 or not self.training:\n return F.log_softmax(x, dim=-1)\n else:\n if len(self.blocks_for_ppl) == self.ppl_past_blocks:\n self.blocks_for_ppl.pop(0)\n\n self.blocks_for_ppl.append(x)\n res = F.log_softmax(torch.cat(self.blocks_for_ppl, dim=0), dim=-1)\n self.blocks_for_ppl[-1] = self.blocks_for_ppl[-1].detach()\n return res\n\n def add_perplexity_reg(self, sel: torch.Tensor):\n sync_distributed = self.sync_distributed and (self.perplexity_reg_mode not in {\"time\", \"global_time\"})\n\n if self.perplexity_reg_mode in {\"time\", \"global_time\"}:\n sel = sel.flatten(0, -3)\n else:\n sel = sel.flatten(0, -2)\n\n # Note: sel are raw logits, no matter what activation is used\n if self.perplexity_reg > 0:\n if self.reg_type == \"perplexity\":\n sel_d = self.rolling_logsumexp(sel)\n sel_d = framework.utils.distributed_ops.log_mean(sel_d, -2, self.sync_distributed)\n loss = lambda: self.perplexity_reg * ( - utils.relative_perplexity_l(sel_d).mean())\n elif self.reg_type == \"entropy\":\n sel_d = self.rolling_logsumexp(sel)\n sel_d = framework.utils.distributed_ops.log_mean(sel_d, -2, self.sync_distributed)\n loss = lambda: self.perplexity_reg * ( - utils.entropy_l(sel_d).mean())\n elif self.reg_type == \"variance\":\n if sync_distributed:\n raise NotImplementedError(\"Variance regularization is not supported in distributed mode\")\n avg_sel = sel.mean(-2)\n loss = lambda: self.perplexity_reg * avg_sel.var(-1).mean()\n elif self.reg_type == \"l2\":\n loss = lambda: self.perplexity_reg * sel.pow(2).mean()\n elif self.reg_type == \"switch\":\n if sync_distributed:\n torch.distributed.all_reduce(self.reg_counts, op=torch.distributed.ReduceOp.SUM)\n\n p_sel_real = self.reg_counts / self.reg_counts.sum(-1, keepdims=True)\n if self.perplexity_reg_mode in {\"time\", \"global_time\"}:\n p_sel_real = p_sel_real.unsqueeze(-2)\n\n loss = lambda: self.perplexity_reg * (F.softmax(sel, dim=-1) * p_sel_real).mean()\n self.reg_counts = 0\n else:\n assert False\n\n self.add_reg(loss, \"moe\")\n\n def compute_scores(self, input: torch.Tensor, index: CVMMSel, expert_scores: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n scores = cvmm(input, index, self.keys)\n\n if self.selection_mode in {\"mul\"}:\n scores = scores * expert_scores[..., None]\n elif self.selection_mode in {\"gate\", \"sigmoid\", \"sinkhorn\", \"sinkhorn2\", \"sinkmoid\", \"sinkmax\", \"sinkmoid2\"}:\n # Handle it later\n pass\n\n scores = self.activation(scores)\n\n plot_training = self.train and self.iter % 10 == 0\n if plot_training:\n with torch.no_grad():\n gt0 = (scores > 0).float()\n gt0_s = gt0.sum()\n\n if plot_training:\n self.log(\"relu_pass_rate\", gt0_s / scores.numel())\n\n self.kv_sel_counts.index_add_(0, index.raw_sel.flatten(), gt0.flatten(end_dim=-2))\n\n if self.dropout > 0 and self.dropout_mode != \"none\":\n scores = F.dropout(scores, self.dropout, training=self.training)\n\n return scores\n\n def sel_activation(self, sel: torch.Tensor, seq_len: int) -> Tuple[torch.Tensor, torch.Tensor]:\n reg_sel = sel\n if self.selection_mode in {\"sigmoid\"}:\n sel = torch.sigmoid(sel)\n elif self.selection_mode in {\"mul\"}:\n sel = sel.abs()\n reg_sel = sel\n elif self.selection_mode in {\"gate\"}:\n sel = F.softmax(sel, dim=-1)\n with torch.no_grad():\n self.log(\"expert_rel_perplexity_per_selection\", utils.relative_perplexity(sel).mean())\n else:\n assert False\n\n return sel, reg_sel\n\n def forward(self, input: torch.Tensor) -> torch.Tensor:\n out = 0\n\n in1 = in2 = input\n\n sel = self.sel(in1)\n # sel=sel.float()\n\n if self.sel_norm == \"cos\":\n sel = sel / (in1.norm(dim=-1, keepdim=True) * self.expert_sel.norm(dim=-1)[None]) * self.sel_scale\n elif self.sel_norm == \"weights\":\n sel = sel * (self.sel_scale / self.expert_sel.norm(dim=-1)[None])\n elif self.sel_norm == \"input\":\n sel = sel * (self.sel_scale / in1.norm(dim=-1, keepdim=True))\n\n sel_raw = reg_sel = sel\n\n inv_val = float(\"-inf\")\n\n if not self.activation_after_topk:\n # Sinkhorn should be always applied before top-k\n sel, reg_sel = self.sel_activation(sel, input.shape[-2])\n inv_val = 0\n\n if self.training and self.expert_dropout > 0:\n if self.selection_mode not in {\"sigmoid\", \"gate\"}:\n raise ValueError(\"Expert dropout not supported in this mode\")\n\n mask = torch.rand_like(sel) < self.expert_dropout\n sel2 = sel.masked_fill(mask, inv_val)\n else:\n sel2 = sel\n\n sel_val, sel_index = self.topk(sel2, self.n_heads, self.topk_mode in {\"l1_approx\", \"approx\"})\n\n if self.activation_after_topk or (self.selection_mode in {\"mul\"}):\n sel_val = torch.gather(sel_raw, -1, sel_index)\n sel_val, reg_sel = self.sel_activation(sel_val, input.shape[-2])\n\n\n record_counts_now = (self.training and self.iter % 10 == 0) or (not self.training) or (self.record_all_expert_sel_counts)\n\n if not self.training:\n sel_index_flat = sel_index.flatten(end_dim=-2)\n if self.coocurence is None:\n self.coocurence = torch.zeros([self.n_experts, self.n_experts], device=sel_index_flat.device, dtype=torch.long)\n\n for h1 in range(self.n_heads):\n for h2 in range(self.n_heads):\n ind_flat = sel_index_flat[..., h1] * self.n_experts + sel_index_flat[..., h2]\n values = torch.tensor([1], device=self.coocurence.device, dtype=self.coocurence.dtype).expand_as(ind_flat)\n # values = sel_val[..., h2].flatten()\n self.coocurence.flatten().put_(ind_flat, values, accumulate=True)\n # self.coocurence[sel_index_flat[..., h1], sel_index_flat[..., h2]] += 1\n\n if record_counts_now or self.reg_type == \"switch\":\n reg_counts = F.one_hot(sel_index, self.n_experts).type_as(input)\n\n if self.reg_type == \"switch\":\n reg_counts2 = reg_counts.view(*input.shape[:-2], input.shape[-2] * self.n_heads, self.n_experts)\n if self.perplexity_reg_mode == \"time\":\n reg_counts2 = reg_counts2.sum(-2)\n else:\n reg_counts2 = reg_counts2.flatten(end_dim=-2).sum(0)\n\n self.reg_counts = self.reg_counts + reg_counts2\n\n if record_counts_now:\n with torch.no_grad():\n sel_counts = reg_counts.flatten(end_dim=-2).sum(0)\n cnt = sel_index.nelement()\n\n p_expert_sel = sel_counts / cnt\n\n self.index_sel_counts = self.index_sel_counts + sel_counts\n self.index_sel_norm = self.index_sel_norm + cnt\n\n if self.record_all_expert_sel_counts:\n softcnt = torch.zeros_like(sel_counts, dtype=sel_val.dtype)\n softcnt.index_add_(0, sel_index.flatten(), sel_val.flatten())\n\n self.all_expert_sel_soft.append(softcnt)\n self.all_expert_sel_counts.append(sel_counts)\n\n if self.training:\n self.log(\"min_sel_score\", sel_val.min(dim=-1).values.mean())\n self.log(\"max_sel_score\", sel_val.max(dim=-1).values.mean())\n\n sel_oh = F.one_hot(sel_index, self.n_experts).sum(-2).bool()\n if self.layer >= 1 and self.training:\n self.log(f\"layer_sel_overlap_{self.layer}\", ((self.prev_sel_oh & sel_oh).sum(-1).float() / self.n_heads).mean())\n\n self.prev_sel_oh = sel_oh\n\n ppl = utils.relative_perplexity(p_expert_sel)\n self.log(\"usage_rel_perplexity\", ppl)\n self.log(\"dead_expert_proportion\", (p_expert_sel == 0).float().sum() / self.n_experts)\n\n if self.perplexity_reg_mode in {\"step\", \"time\"}:\n self.add_perplexity_reg(reg_sel)\n elif self.perplexity_reg > 0 and self.training:\n self.sel_hist.append(reg_sel)\n\n sel_indices = cvmm_prepare_sel2(sel_index.int())\n\n scores = self.compute_scores(in2, sel_indices, sel_val)\n\n sel_indices = sel_indices.clone()\n sel_indices.reduction_weight = sel_val\n sel_indices.sel_index = sel_indices.out_index\n sel_indices.out_index = None\n\n if self.selection_mode not in {\"gate\", \"sigmoid\"}:\n sel_indices.reduction_weight = torch.ones_like(sel_indices.reduction_weight)\n\n out = cvmm(scores, sel_indices, self.values)\n\n self.layer += 1\n\n self.was_training = self.training\n res = out.view(*input.shape[:-1], self.v_dim)\n return res\n\n def dump_logs(self, save_dir: str):\n if self.coocurence is not None:\n os.makedirs(save_dir, exist_ok=True)\n torch.save(self.coocurence, os.path.join(save_dir, \"coocurence.pt\"))\n\n def get_logs(self) -> Dict[str, Any]:\n res = super().get_logs()\n\n if self.coocurence is not None:\n coo = self.coocurence / self.coocurence.diagonal().clamp(min=1)[:, None]\n res[\"expert_coocurence\"] = framework.visualize.plot.Heatmap(coo, xlabel=\"expert\", ylabel=\"expert\", textval=False)\n self.coocurence = None\n return res"},{"identifier":"Result","path":"interfaces/result.py","snippet":"class Result:\n outputs: torch.Tensor\n loss: torch.Tensor\n\n batch_dim = 0\n\n def plot(self) -> Dict[str, Any]:\n return {}\n\n @property\n def batch_size(self) -> int:\n return self.outputs.shape[self.batch_dim]\n\n @staticmethod\n def merge(l: List, batch_weights: Optional[List[float]] = None):\n if len(l) == 1:\n return l[0]\n batch_weights = batch_weights if batch_weights is not None else [1] * len(l)\n loss = sum([r.loss * w for r, w in zip(l, batch_weights)]) / sum(batch_weights)\n out = torch.cat([r.outputs for r in l], l[0].batch_dim)\n return l[0].__class__(out, loss)"},{"identifier":"LayerVisualizer","path":"layers/layer_with_visualization.py","snippet":"class LayerVisualizer:\n def __init__(self, module: torch.nn.Module, options: Dict[str, Any] = {}):\n self.modules = []\n self.options = options\n self.curr_options = None\n for n, m in module.named_modules():\n if isinstance(m, LayerWithVisualization):\n self.modules.append((n, m))\n\n def plot(self) -> Dict[str, Any]:\n res = {}\n for n, m in self.modules:\n res.update({f\"{n}/{k}\": v for k, v in m.plot(self.curr_options).items()})\n m.visualization_enabled = False\n\n self.curr_options = None\n return res\n\n def prepare(self, options: Dict[str, Any] = {}):\n self.curr_options = self.options.copy()\n self.curr_options.update(options)\n\n for _, m in self.modules:\n m.prepare()\n m.visualization_enabled = True"},{"identifier":"FullMoeRelativeAttentionCore","path":"layers/transformer/full_moe_relative_attention.py","snippet":"class FullMoeRelativeAttentionCore(LayerWithVisualization, LoggingLayer, RegularizedLayer, OncePerIterLayer, torch.nn.Module):\n def __init__(self, state_size: int, n_heads: int, n_experts: int, dropout: float = 0.0, input_size: Optional[int] = None,\n projection_size: Optional[int] = None, output_size: Optional[int] = None, init_std_scale: float = 1.0,\n perplexity_reg: float = 0, share_pk: bool = True, expert_dropout: float = 0.0,\n selection_mode: str = \"sigmoid\", moe_k: int = 2, q_expert: bool = True,\n k_expert: bool = True, v_expert: bool = True, o_expert: bool = True, norm_qk_score: bool = False,\n v_projection_size: Optional[int] = None, same_sel: bool = False,\n qside_n_experts: Optional[int] = None, shared_experts: bool = False,\n kq_n_experts: Optional[int] = None, separate_kq_sel: bool = False,\n normalize_init: bool = False, normalize_retrieval: bool = False):\n\n super().__init__()\n\n self.input_size = input_size or state_size\n self.output_size = output_size or state_size\n self.pe_size = self.input_size\n self.perplexity_reg = perplexity_reg\n self.share_pk = share_pk\n self.expert_dropout = expert_dropout\n self.selection_mode = selection_mode\n self.iter = 0\n self.moe_k = moe_k\n self.norm_qk_score = norm_qk_score\n self.same_sel = same_sel\n self.shared_experts = shared_experts\n self.init_std_scale = init_std_scale\n self.normalize_init = normalize_init\n self.attention_to_visualize = []\n self.selections_to_visualize = {}\n\n self.is_expert = {\n \"k\": k_expert,\n \"q\": q_expert,\n \"v\": v_expert,\n \"o\": o_expert\n }\n self.n_experts = {\n \"k\": kq_n_experts or n_experts,\n \"q\": kq_n_experts or qside_n_experts or n_experts,\n \"v\": n_experts,\n \"o\": qside_n_experts or n_experts\n }\n\n self.separate_k_sel = separate_kq_sel or (self.n_experts[\"k\"] != self.n_experts[\"v\"])\n self.separate_q_sel = separate_kq_sel or (self.n_experts[\"q\"] != self.n_experts[\"o\"])\n\n self.sel_hist = {}\n self.sel_counts_100 = {}\n\n self.n_heads = n_heads\n self.dropout = torch.nn.Dropout(dropout) if dropout > 0 else lambda x: x\n self.projection_size = projection_size or (state_size // n_heads)\n self.v_projection_size = v_projection_size or self.projection_size\n\n self.std_in = init_std_scale * math.sqrt(1 / self.input_size)\n std_out = init_std_scale * math.sqrt(1 / (n_heads * self.v_projection_size))\n\n self.create_selection_logic()\n\n self.src_side_maps = {\"k\", \"v\"}\n\n self.projections = torch.nn.ParameterDict({\n \"q\": self.create_param_block(\"q\", self.input_size, self.projection_size, self.std_in),\n \"k\": self.create_param_block(\"k\", self.input_size, self.projection_size, self.std_in),\n \"v\": self.create_param_block(\"v\", self.input_size, self.v_projection_size, self.std_in),\n \"o\": self.create_param_block(\"o\", self.v_projection_size, self.output_size, std_out),\n })\n\n if normalize_retrieval:\n self.norm_ret = torch.nn.LayerNorm(self.projection_size)\n else:\n self.norm_ret = lambda x: x\n\n self.sel_correlation = 0\n\n self.register_buffer(\"scale\", torch.full([1], 1.0 / math.sqrt(self.projection_size)), persistent=False)\n\n def renorm_keep_std(self, weight: torch.Tensor, dim: int = 0):\n with torch.no_grad():\n std = weight.std()\n weight.div_(weight.norm(dim=dim, keepdim=True))\n weight.mul_(std / weight.std())\n\n def get_n_copies(self, name: str):\n return self.n_heads\n\n def create_param_block(self, name: str, in_size: int, out_size: int, std: float):\n n_copies = self.get_n_copies(name)\n\n if self.is_expert[name]:\n exp_mul = 1 if self.shared_experts else n_copies\n p = torch.nn.Parameter(torch.randn(exp_mul * self.n_experts[name], in_size, out_size) * std)\n if self.normalize_init:\n self.renorm_keep_std(p, dim=0)\n return p\n else:\n if name == \"o\":\n in_size = n_copies * in_size\n else:\n out_size = n_copies * out_size\n return torch.nn.Parameter(torch.randn(out_size, in_size) * std)\n\n def create_selection_logic(self):\n sels_params = {}\n self.sel_map = {}\n\n def register_remap(dest: str, src: str) -> bool:\n if not (src in sels_params or src in self.sel_map):\n # src is not defined\n return False\n\n assert self.n_experts[src] == self.n_experts[dest]\n self.sel_map[dest] = self.sel_map.get(src, src)\n return True\n\n if self.is_expert[\"o\"]:\n sels_params[\"o\"] = self.init_sel(\"o\", self.std_in)\n\n if self.is_expert[\"q\"] and (self.separate_q_sel or not register_remap(\"q\", \"o\")):\n sels_params[\"q\"] = self.init_sel(\"q\", self.std_in)\n\n if self.is_expert[\"v\"] and ((not self.same_sel) or not register_remap(\"v\", \"o\")):\n sels_params[\"v\"] = self.init_sel(\"v\", self.std_in)\n\n if self.is_expert[\"k\"]:\n if (not (self.same_sel and self.separate_k_sel and register_remap(\"k\", \"q\"))) and (self.separate_k_sel or not register_remap(\"k\", \"v\")):\n sels_params[\"k\"] = self.init_sel(\"k\", self.std_in)\n\n self.selections = torch.nn.ParameterDict(sels_params)\n\n def init_sel(self, name: str, std: float) -> torch.nn.Parameter:\n n_copies = self.get_n_copies(name)\n n_experts = self.n_experts[name]\n sel = torch.nn.Parameter(torch.randn(n_experts*n_copies, self.input_size) * std)\n self.renorm_rows(sel)\n return sel\n\n def renorm_rows(self, x: torch.Tensor):\n with torch.no_grad():\n std_t = x.std(dim=-1, keepdim=True)\n x.div_(x.norm(dim=-1, keepdim=True))\n x.mul_(std_t / x.std())\n\n\n def project_to_torch_order(self, x: torch.Tensor):\n return x.view(*x.shape[:-1], self.get_n_copies(\"k\"), -1).transpose(-2, -3)\n\n def get_mask_tensor(self, src_len: int, mask: Optional[AttentionMask]) -> Optional[torch.Tensor]:\n if mask is None or (mask.position_mask is None and mask.src_length_mask is None):\n return None\n\n # mask.position_mask: [..., N_out, N_in]\n # mask.src_length_mask: [B, ...., N_in]\n # True where it has to be masked\n\n if mask.position_mask is not None:\n n_pad = src_len - mask.position_mask.shape[-1]\n if n_pad > 0:\n pm = F.pad(mask.position_mask, (n_pad, 0), 'constant', value=False)\n else:\n pm = mask.position_mask\n\n if mask.position_mask is None:\n m = mask.src_length_mask.unsqueeze(-2).unsqueeze(-2)\n elif mask.src_length_mask is None:\n m = pm\n else:\n m = mask.src_length_mask.unsqueeze(-2).unsqueeze(-2) | pm\n\n return m\n\n def train(self, mode: bool = True):\n self.sel_hist = {}\n return super().train(mode)\n\n def get_lost_on_hist(self, l: List[torch.Tensor]) -> torch.Tensor:\n assert l[0].ndim == 4\n l = [t.flatten(1,2) for t in l]\n sel = torch.cat(l, -2)\n sel_d = F.log_softmax(sel, dim=-1)\n sel_d = framework.utils.distributed_ops.log_mean(sel_d, -2, sync_distributed=False)\n return self.perplexity_reg * ( - utils.entropy_l(sel_d).mean())\n\n def get_reg_loss(self) -> Dict[str, torch.Tensor]:\n l = super().get_reg_loss()\n for k, v in self.sel_hist.items():\n l[f\"moe_att_entropy/{k}\"] = self.get_lost_on_hist(v)\n\n self.sel_hist = {}\n return l\n\n def get_sel(self, t: torch.Tensor, w: torch.Tensor, name: str) -> Selection:\n n_experts = self.n_experts[name]\n n_copies = self.get_n_copies(name)\n\n sel = F.linear(t, w).float()\n sel = sel.view(*sel.shape[:-1], n_copies, -1)\n with torch.no_grad():\n if self.expert_dropout > 0 and self.training:\n mask = torch.rand_like(sel) < self.expert_dropout\n sel2 = sel.masked_fill(mask, float('-inf'))\n else:\n sel2 = sel\n _, sel_index = sel2.topk(self.moe_k, dim=-1, sorted=False)\n sel_val = torch.gather(sel, -1, sel_index)\n\n if self.selection_mode == \"softmax\":\n sel_val = sel_val.softmax(-1)\n elif self.selection_mode == \"sigmoid\":\n sel_val = sel_val.sigmoid()\n else:\n raise ValueError(\"Unknown selection mode: \" + self.selection_mode)\n\n exp_shift = 0 if self.shared_experts else n_experts\n\n sel_index_shifted = (torch.arange(n_copies, device=sel_index.device, dtype=sel_index.dtype) * exp_shift).unsqueeze(-1) + sel_index\n sel_index_pp = cvmm_prepare_sel2(sel_index_shifted.flatten(-2,-1), sel_val)\n\n return Selection(sel, sel_val, sel_index, sel_index_pp)\n\n def before_loss(self):\n self.iter += 1\n if self.iter % 100 == 0:\n for k, v in self.sel_counts_100.items():\n sorted_counts = v.sort(descending=True).values\n self.log(f\"sel_counts/{k}\", framework.visualize.plot.Barplot(sorted_counts, xlabel=\"expert\", ylabel=\"usage count\"), drop_old=True)\n\n self.sel_counts_100 = {}\n\n def exp_proj(self, x: torch.Tensor, w: torch.Tensor, sel: Selection) -> torch.Tensor:\n return cvmm(x, sel.sel_index, w)\n\n def compute_sel(self, curr_state: torch.Tensor, attend_to: torch.Tensor) -> Dict[str, Selection]:\n self.selection_mode\n outs = {}\n done = {}\n cross_atten = curr_state is not attend_to\n\n for name in (set(self.selections.keys()) | set(self.sel_map.keys())):\n name_actual = self.sel_map.get(name, name)\n\n # There coukd be 2 versions of everything: source side and destination side. Check if they are different,\n # and if not, use the cached version, my_id is the unique identifier for this transformation\n is_src_side = (name in self.src_side_maps) or not cross_atten\n my_id = (name_actual, is_src_side)\n\n cached = done.get(my_id)\n if cached is not None:\n outs[name] = cached\n continue\n\n # No cache, actually compute\n inp = attend_to if is_src_side else curr_state\n v = self.selections[name_actual]\n outs[name] = self.get_sel(inp, v, name)\n\n # Save history for regularization\n if self.perplexity_reg > 0 and self.training:\n if name not in self.sel_hist:\n self.sel_hist[name] = []\n self.sel_hist[name].append(outs[name].raw_sel)\n\n # Visualize statistics\n if self.training and self.iter % 10 == 0:\n self.sel_counts_100[name] = self.sel_counts_100.get(name, 0) + \\\n F.one_hot(outs[name].raw_sel_index.flatten(), self.n_experts[name]).sum(0)\n\n done[my_id] = outs[name]\n\n return outs\n\n def project(self, name: str, src: torch.Tensor, sel: Dict[str, Selection]) -> torch.Tensor:\n if name in sel:\n sv = sel[name]\n if self.norm_qk_score and name in {\"q\", \"k\"}:\n sv.sel_index.reduction_weight = F.normalize(sv.sel_index.reduction_weight, p=1, dim=-1)\n return self.exp_proj(src, self.projections[name], sv)\n else:\n return F.linear(src, self.projections[name])\n\n def attend(self, curr_state: torch.Tensor, attend_to: torch.Tensor, pos_offset: int, v: torch.Tensor,\n k: torch.Tensor, q: torch.Tensor, mask: Optional[torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:\n raise NotImplementedError()\n\n def attention_proj(self, att: torch.Tensor, v: torch.Tensor,\n mask: Optional[torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:\n if mask is not None:\n att.masked_fill_(mask, float('-inf'))\n\n att = F.softmax(att, dim=-1)\n\n res = att @ v\n return res, att\n\n def forward(self, curr_state: torch.Tensor, attend_to: torch.Tensor, mask: Optional[AttentionMask],\n pos_offset: Optional[int] = None, need_weights: bool = False):\n # curr_state: [batch_size, out_len, c]\n # attend_to: [batch_size, in_len, c]\n\n if pos_offset is None:\n assert curr_state.shape[1] == attend_to.shape[1], \"If attend_to has different shape than curr_state, pos_offset should be provided\"\n pos_offset = 0\n\n sel = self.compute_sel(curr_state, attend_to)\n\n # scale q and k with sqrt(scale) before the attention. This should save memory, be faster, and\n # keep the range of k and v better. It should make attention NaNs better with float16.\n scale = self.scale.sqrt()\n\n q = self.project(\"q\", curr_state, sel)\n q = q * scale.type_as(q)\n k = self.project(\"k\", attend_to, sel)\n k = k * scale.type_as(k)\n v = self.project(\"v\", attend_to, sel)\n\n q = self.project_to_torch_order(q) if \"q\" not in sel else q.transpose(-2,-3)\n k = self.project_to_torch_order(k) if \"k\" not in sel else k.transpose(-2,-3)\n v = self.project_to_torch_order(v) if \"v\" not in sel else v.transpose(-2,-3)\n\n k = self.dropout(k)\n\n res, att = self.attend(curr_state, attend_to, pos_offset, v, k, q, self.get_mask_tensor(attend_to.shape[-2], mask))\n res = self.norm_ret(res)\n\n if self.visualization_enabled:\n self.attention_to_visualize.append(att[0].detach())\n for k, s in sel.items():\n if k not in self.selections_to_visualize:\n self.selections_to_visualize[k] = []\n\n with torch.no_grad():\n m = torch.zeros([*s.sel_val[0].shape[:-1], self.n_experts[k]], device=s.sel_val.device, dtype=s.sel_val.dtype)\n m.scatter_(-1, s.raw_sel_index[0], s.sel_val[0])\n\n self.selections_to_visualize[k].append(m)\n\n if self.get_n_copies(\"k\") != self.get_n_copies(\"v\"):\n res = res.view(\n *res.shape[:-1], self.get_n_copies(\"v\") // self.get_n_copies(\"k\"), -1).transpose(2,3).flatten(1,2).contiguous()\n\n if self.is_expert[\"o\"]:\n res = res.transpose(-2, -3)\n # The output selection indices are calculated from the current state and are also used for projecting \"q\".\n # But that projection needs to create multiple copies for the different heads. Here we already have the\n # heads, but we have to create copies for the top-k elements. We can calculate that from the reduction\n # weight. We also want to compute not only the weighted average between the top-k elements, but also\n # of the different heads. So reshape the reduction weight accordingly.\n o_sel = sel[\"o\"].sel_index.clone()\n o_sel.sel_index = o_sel.out_index // o_sel.reduction_weight.shape[-1]\n o_sel.reduction_weight = o_sel.reduction_weight.flatten(-2)\n out = cvmm(res, o_sel, self.projections[\"o\"])\n else:\n res = res.transpose(-2, -3)\n out = F.linear(res.contiguous().view(*curr_state.shape[:-1], -1), self.projections[\"o\"])\n\n return out\n\n def plot(self, options: Dict[str, Any]) -> Dict[str, Any]:\n r = {}\n marks = options.get(\"steplabel\")\n n_steps = options.get(\"n_steps\") or 9999999\n y_marks = options.get(\"target_labels\", marks)\n\n ns1 = (self.attention_to_visualize[0].shape[-2] + n_steps) if n_steps < 0 else 0\n ns1_e = self.attention_to_visualize[0].shape[-2] if n_steps < 0 else n_steps\n ns2 = (self.attention_to_visualize[0].shape[-1] + n_steps) if n_steps < 0 else 0\n ns2_e = self.attention_to_visualize[0].shape[-1] if n_steps < 0 else n_steps\n\n if marks is not None:\n assert len(marks) == self.attention_to_visualize[0].shape[-1]\n marks = marks[ns2:ns2_e]\n\n if y_marks is not None:\n assert len(y_marks) == self.attention_to_visualize[0].shape[-2]\n y_marks = y_marks[ns1:ns1_e]\n\n if options.get(\"mha.plot_head_details\") and self.attention_to_visualize[0].shape[0] > 1:\n for head in range(self.attention_to_visualize[0].shape[0]):\n sel_map = {k: [e[:, head][ns1:ns1_e] if k in {'q', 'o'} else e[:, head][ns2:ns2_e] for e in v] for k, v in self.selections_to_visualize.items()}\n selections = {k: torch.stack(v, 0).cpu() for k, v in sel_map.items()}\n\n x_selections = {k: v for k, v in selections.items() if k in {'k', 'v'}}\n y_selections = {k: v for k, v in selections.items() if k in {'q', 'o'}}\n\n r[f\"head_{head}\"] = MoEAttentionPlot(\n torch.stack([layer[head][ns1:ns1_e, ns2:ns2_e] for _, layer in enumerate(self.attention_to_visualize)], 0),\n x_selections, y_selections,\n ylabel=\"dest\", xlabel=\"src\", x_marks=marks, y_marks=y_marks)\n\n r[\"attention_max\"] = framework.visualize.plot.AnimatedHeatmap(\n torch.stack([layer.max(0)[0][ns1:ns1_e, ns2:ns2_e] for _, layer in enumerate(self.attention_to_visualize)], 0),\n ylabel=\"dest\", xlabel=\"src\", textval=False, x_marks=marks, y_marks=y_marks, ignore_wrong_marks=True)\n\n self.attention_to_visualize = []\n self.selections_to_visualize = {}\n return r\n\n def dump_logs(self, save_dir: str):\n if torch.is_tensor(self.sel_correlation):\n os.makedirs(save_dir, exist_ok=True)\n torch.save(self.sel_correlation, os.path.join(save_dir, \"sel_correlation.pt\"))\n\n def get_logs(self) -> Dict[str, Any]:\n res = super().get_logs()\n\n if torch.is_tensor(self.sel_correlation):\n coo = self.sel_correlation / self.sel_correlation.flatten(1).sum(-1).clamp(min=1)[:, None, None]\n for h in range(self.n_heads):\n res[f\"expert_coocurence_{h}\"] = framework.visualize.plot.Heatmap(coo[h], xlabel=\"o expert\", ylabel=\"v expert\", textval=False)\n self.sel_correlation = 0\n return res"}],"string":"[\n {\n \"identifier\": \"TransformerLanguageModel\",\n \"path\": \"models/transformer_language_model.py\",\n \"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: bool, layers: List[torch.nn.Module], n_prev_states: int,\\n n_prev_states_test: Optional[int] = None, adaptive_cutoffs: List[int] = [],\\n same_length_eval: bool = True, norm_before_output: bool = False,\\n p_drop_layer: float = 0.0, use_last_state: bool = False, same_length: bool = False):\\n\\n super().__init__()\\n\\n self.embedding = torch.nn.Embedding(voc_size, embedding_size or state_size)\\n torch.nn.init.kaiming_normal_(self.embedding.weight, mode=\\\"fan_in\\\", nonlinearity=\\\"linear\\\")\\n\\n self.shared_layers = all([la is layers[0] for la in layers])\\n\\n if embedding_size is None:\\n self.embedding_adapter = lambda x: x\\n else:\\n self.embedding_adapter = torch.nn.Linear(embedding_size, state_size)\\n\\n self.dropout = torch.nn.Dropout(dropout)\\n self.layers = layers\\n self.unique_layers = torch.nn.ModuleList(unique_obejcts(layers))\\n self.output_adapter = lambda x: x\\n self.n_prev_states = n_prev_states\\n self.n_prev_states_test = n_prev_states_test or n_prev_states\\n self.same_length_eval = same_length_eval\\n self.embedding_scale = math.sqrt(state_size)\\n self.p_drop_layer = p_drop_layer\\n self.use_last_state = use_last_state\\n self.same_length = same_length\\n self.iter = 0\\n\\n self.adaptive = bool(adaptive_cutoffs)\\n\\n out_proj_size = (embedding_size or state_size) if tied_embedding else state_size\\n if self.adaptive:\\n self.output = framework.layers.CustomAdaptiveLogSoftmaxWithLoss(\\n out_proj_size, voc_size, adaptive_cutoffs, div_value=1,\\n tied_to=self.embedding if tied_embedding else None)\\n else:\\n self.output = torch.nn.Linear(out_proj_size, voc_size)\\n\\n if norm_before_output:\\n self.out_norm = torch.nn.LayerNorm(state_size)\\n else:\\n self.out_norm = lambda x: x\\n\\n if tied_embedding:\\n if not self.adaptive:\\n self.output.weight = self.embedding.weight\\n if embedding_size is not None:\\n self.output_adapter = torch.nn.Linear(state_size, embedding_size)\\n\\n @staticmethod\\n def generate_history_mask(sz: int, device: torch.device) -> torch.Tensor:\\n return torch.tril(torch.ones(sz, sz, dtype=torch.bool, device=device), diagonal=-1)\\n\\n def gen_output(self, x: torch.Tensor, target: Optional[torch.Tensor]) -> torch.Tensor:\\n net = self.out_norm(x)\\n net = self.output_adapter(net)\\n net = self.dropout(net)\\n\\n if self.adaptive:\\n net = self.output(net.transpose(0, 1), target)\\n else:\\n net = self.output(net.transpose(0, 1))\\n\\n return net\\n\\n def forward(self, x: torch.Tensor, target: Optional[torch.Tensor], state) -> Tuple[torch.Tensor, Any]:\\n causality_mask = Transformer.generate_square_subsequent_mask(x.shape[0], x.device)\\n\\n net = self.dropout(self.embedding(x.T.long()))\\n net = self.embedding_adapter(net)\\n net = net * self.embedding_scale\\n\\n new_state = []\\n features = [net]\\n\\n n_prev_states = self.n_prev_states if self.training else self.n_prev_states_test\\n\\n same_length = self.same_length or ((not self.training) and self.same_length_eval)\\n if same_length and state is not None:\\n causality_mask = [self.generate_history_mask(x.shape[0], x.device)] + \\\\\\n [torch.zeros_like(causality_mask)] * (len(state[0]) - 1) + [causality_mask]\\n causality_mask = torch.cat(causality_mask, -1)\\n\\n\\n plot_cossim = (self.iter % 100 == 0 and self.training)\\n for li, l in enumerate(self.layers):\\n if n_prev_states > 0:\\n if li == 0:\\n # Pos offset should be constant for all layers\\n pos_offset = sum(s.shape[1] for s in state[0]) if state is not None else 0\\n\\n # Concatenate the new state with the previous states\\n li_r = -1 if self.use_last_state else li\\n s = (state[li_r] + [net]) if state is not None else [net]\\n attend_to = torch.cat(s, 1)\\n\\n if not self.use_last_state:\\n s[-1] = s[-1].detach()\\n new_state.append(s[-n_prev_states:])\\n else:\\n pos_offset = None\\n attend_to = None\\n\\n net_o = l(net, mask=AttentionMask(None, causality_mask), attend_to=attend_to,\\n pos_offset=pos_offset)\\n\\n if plot_cossim:\\n features.append(net_o)\\n\\n with torch.no_grad():\\n ndiff = torch.norm(net_o - net, p=2, dim=-1)\\n n_in = torch.norm(net, p=2, dim=-1)\\n self.log(f\\\"activation_norm/abs_update_layer_{li}\\\", ndiff.mean())\\n self.log(f\\\"activation_norm/in_layer_{li}\\\", n_in.mean())\\n self.log(f\\\"activation_norm/rel_update_layer_{li}\\\", (ndiff/n_in.clamp(min=torch.finfo(n_in.dtype).eps)).mean())\\n\\n if self.training and self.p_drop_layer > 0.0:\\n net = torch.where(torch.rand_like(net_o[..., 0:1]) < self.p_drop_layer, net, net_o)\\n else:\\n net = net_o\\n\\n if self.use_last_state and n_prev_states > 0:\\n # If we carry over the last state, save it here\\n new_state = [((state[0] if state is not None else []) + [net.detach()])[-n_prev_states:]]\\n\\n if plot_cossim:\\n with torch.no_grad():\\n f_sample = [f.view(-1, f.shape[-1])[:1024] for f in features]\\n f_sample_all = torch.stack(f_sample, -2)\\n scores = framework.utils.cossim(f_sample_all, f_sample_all).mean(0)\\n self.log(\\\"feature_cossim\\\", framework.visualize.plot.Heatmap(scores, range=(0, 1), textval=False))\\n\\n outs = F.softmax(self.gen_output(f_sample_all, target).transpose(0, 1), -1)\\n scores = framework.utils.cossim(outs, outs).mean(0)\\n self.log(\\\"out_dist_cossim\\\", framework.visualize.plot.Heatmap(scores, range=(0, 1), textval=False))\\n\\n real_out = outs[:, -1]\\n for i in range(outs.shape[-2] - 1):\\n self.log(f\\\"out_diff_{i}\\\", (outs[:, i] - real_out).norm(dim=-1, p=1).mean())\\n\\n del outs\\n\\n\\n del features\\n\\n net = self.gen_output(net, target)\\n self.iter += 1\\n\\n return net, new_state\"\n },\n {\n \"identifier\": \"task\",\n \"path\": \"tasks/task_db.py\",\n \"snippet\": \"def task(name: Optional[str] = None):\\n def wrapper(cls):\\n n = TASK_PREFIX + (name or camel_to_snake(cls.__name__))\\n assert n not in TASKS, f\\\"Task {n} already exists\\\"\\n TASKS[n] = cls\\n return cls\\n return wrapper\"\n },\n {\n \"identifier\": \"args\",\n \"path\": \"tasks/task_db.py\",\n \"snippet\": \"def args(fn):\\n global ARGS_REGISTERS\\n ARGS_REGISTERS.append(fn)\\n return fn\"\n },\n {\n \"identifier\": \"RelativeTransformerEncoderLayer\",\n \"path\": \"layers/transformer/relative_transformer.py\",\n \"snippet\": \"class RelativeTransformerEncoderLayer(torch.nn.Module):\\n def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation: ActivationFunction = F.relu,\\n attention_dropout=0, test_pos_clamp: Optional[int] = None, drop_expand: bool = True,\\n head_projection_size: Optional[int] = None, ln_after_attention: bool = True):\\n super().__init__()\\n self.ln_after_attention = ln_after_attention\\n self.self_attn = FixedRelativeMultiheadAttention(\\n d_model, nhead, dropout=attention_dropout, test_pos_clamp=test_pos_clamp,\\n projection_size=head_projection_size)\\n self.linear1 = torch.nn.Linear(d_model, dim_feedforward)\\n self.dropout = torch.nn.Dropout(dropout) if drop_expand else lambda x: x\\n self.linear2 = torch.nn.Linear(dim_feedforward, d_model)\\n\\n if ln_after_attention:\\n self.norm1 = torch.nn.LayerNorm(d_model)\\n self.norm2 = torch.nn.LayerNorm(d_model)\\n self.dropout1 = torch.nn.Dropout(dropout)\\n self.dropout2 = torch.nn.Dropout(dropout)\\n\\n self.activation = activation\\n self.reset_parameters()\\n\\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\\n pos_offset: Optional[int] = None) -> torch.Tensor:\\n src2 = self.self_attn(src, attend_to if attend_to is not None else src, mask, pos_offset=pos_offset)\\n src = src + self.dropout1(src2)\\n src = self.norm1(src) if self.ln_after_attention else src\\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))\\n src = src + self.dropout2(src2)\\n src = self.norm2(src)\\n return src\\n\\n def reset_parameters(self):\\n torch.nn.init.xavier_normal_(self.linear1.weight, gain=torch.nn.init.calculate_gain('relu')\\n if self.activation is F.relu else 1.0)\\n torch.nn.init.xavier_uniform_(self.linear2.weight)\"\n },\n {\n \"identifier\": \"PrelnRelativeTransformerEncoderLayer\",\n \"path\": \"layers/transformer/relative_preln_transformer.py\",\n \"snippet\": \"class PrelnRelativeTransformerEncoderLayer(RelativeTransformerEncoderLayer):\\n is_preln = True\\n\\n def __init__(self, d_model, nhead, n_layers: int, dim_feedforward=2048, dropout=0.1,\\n activation: ActivationFunction = F.relu, attention_dropout=0, test_pos_clamp: Optional[int] = None,\\n drop_expand: bool = True, head_projection_size: Optional[int] = None):\\n super().__init__(\\n d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, dropout=dropout,\\n activation=activation, attention_dropout=attention_dropout, test_pos_clamp=test_pos_clamp,\\n drop_expand=drop_expand, head_projection_size=head_projection_size)\\n\\n reset_prenorm_params(self, n_layers)\\n\\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\\n pos_offset: Optional[int] = None) -> torch.Tensor:\\n src2 = self.norm1(src)\\n src2 = self.self_attn(src2, self.norm1(attend_to) if attend_to is not None else src2, mask,\\n pos_offset=pos_offset)\\n src = src + self.dropout1(src2)\\n src2 = self.norm2(src)\\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))\\n src = src + self.dropout2(src2)\\n return src\"\n },\n {\n \"identifier\": \"RelativeMoeTransformerEncoderLayer\",\n \"path\": \"layers/transformer/relative_moe_transformer.py\",\n \"snippet\": \"class RelativeMoeTransformerEncoderLayer(LoggingLayer, torch.nn.Module):\\n def __init__(self, d_model, nhead, n_experts: int, expert_size: int, n_layers: int,\\n dropout=0.1, activation: ActivationFunction = F.relu, attention_dropout=0,\\n test_pos_clamp: Optional[int] = None,\\n dropout_mode: str = \\\"none\\\", selection_mode: str = \\\"add\\\",\\n perplexity_reg: float = 0.0,\\n n_heads: int = 1, norm_keys: bool = False, perplexity_reg_mode: str=\\\"step\\\",\\n n_random: int = 0, reg_type: str = \\\"normal\\\",\\n topk_mode: str = \\\"full\\\", head_projection_size: Optional[int] = None,\\n activation_after_topk: bool = False,\\n drop_parallel: bool = True,\\n normalize_expert_sel_init: bool = False, norm_key_init: bool = False, norm_value_init: bool = False,\\n identical_init: bool = False,\\n sel_norm: str = \\\"none\\\",\\n preln: bool = True, ln_affine: bool = True,\\n moe_dropout_factor: float = 1.0,\\n drop_expert: float = 0.0, sync_distributed: bool = True,\\n modulation_amplitude: float = 0.5, moe_init_scale: float = 1.0,\\n moe_att_n_experts: int = 4, moe_att_expert_dropout: Optional[float] = None,\\n moe_att_selection_mode: str = \\\"sigmoid\\\",\\n moe_att_k: Optional[int] = None, moe_att_ppl_reg: Optional[float] = None,\\n q_expert: bool = True, k_expert: bool = True, v_expert: bool = True,\\n o_expert: bool = True,\\n v_projection_size: Optional[int] = None,\\n qside_n_experts: Optional[int] = None,\\n moe_attention: bool = False, moe_att_variant: str = \\\"full\\\",\\n moe_att_shared_experts: bool = False,\\n moe_att_kq_n_experts: Optional[int] = None, moe_att_separate_kq_sel: bool = False,\\n moe_att_norm_init: bool = False, moe_att_same_sel: bool = False, moe_att_norm_retrieval: bool = False,\\n rotate_fraction: float = 0.5, rope_base: float = 10000):\\n super().__init__()\\n self.preln = preln\\n self.i = 0\\n\\n if moe_attention:\\n if moe_att_variant == \\\"full\\\":\\n self.self_attn = FullMoeRelativeAttention(\\n d_model, nhead, dropout=attention_dropout,\\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\\n n_experts=moe_att_n_experts,\\n perplexity_reg=perplexity_reg if moe_att_ppl_reg is None else moe_att_ppl_reg,\\n expert_dropout=drop_expert if moe_att_expert_dropout is None else moe_att_expert_dropout,\\n selection_mode=moe_att_selection_mode, q_expert=q_expert, k_expert=k_expert, v_expert=v_expert,\\n moe_k=n_heads if moe_att_k is None else moe_att_k, o_expert=o_expert, qside_n_experts=qside_n_experts,\\n v_projection_size=v_projection_size, shared_experts=moe_att_shared_experts,\\n kq_n_experts=moe_att_kq_n_experts, separate_kq_sel=moe_att_separate_kq_sel,\\n normalize_init=moe_att_norm_init,\\n same_sel=moe_att_same_sel, normalize_retrieval=moe_att_norm_retrieval,\\n )\\n elif moe_att_variant == \\\"full_rope\\\":\\n self.self_attn = FullMoeRopeAttention(\\n d_model, nhead, dropout=attention_dropout,\\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\\n n_experts=moe_att_n_experts,\\n perplexity_reg=perplexity_reg if moe_att_ppl_reg is None else moe_att_ppl_reg,\\n expert_dropout=drop_expert if moe_att_expert_dropout is None else moe_att_expert_dropout,\\n selection_mode=moe_att_selection_mode, q_expert=q_expert, k_expert=k_expert, v_expert=v_expert,\\n moe_k=n_heads if moe_att_k is None else moe_att_k, o_expert=o_expert, qside_n_experts=qside_n_experts,\\n v_projection_size=v_projection_size, shared_experts=moe_att_shared_experts,\\n kq_n_experts=moe_att_kq_n_experts, separate_kq_sel=moe_att_separate_kq_sel,\\n normalize_init=moe_att_norm_init, normalize_retrieval=moe_att_norm_retrieval,\\n rotate_fraction=rotate_fraction, rope_base=rope_base,\\n )\\n else:\\n raise ValueError(f\\\"Unknown attention variant {moe_att_variant}\\\")\\n else:\\n self.self_attn = FixedRelativeMultiheadAttention(\\n d_model, nhead, dropout=attention_dropout, test_pos_clamp=test_pos_clamp,\\n projection_size=head_projection_size)\\n\\n std_scale = math.sqrt(2.0 / n_layers) if preln else 1.0\\n std_scale *= math.sqrt(moe_init_scale)\\n\\n self.pkm = MoE(\\n d_model, n_experts, expert_size, dropout=dropout * moe_dropout_factor, dropout_mode=dropout_mode,\\n weight_scale=std_scale, selection_mode=selection_mode,\\n perplexity_reg=perplexity_reg, n_heads=n_heads,\\n norm_keys=norm_keys, perplexity_reg_mode=perplexity_reg_mode, n_random=n_random,\\n reg_type=reg_type, topk_mode=topk_mode,\\n activation_after_topk=activation_after_topk,\\n activation=activation,\\n normalize_expert_sel_init=normalize_expert_sel_init, norm_key_init=norm_key_init,\\n norm_value_init=norm_value_init, identical_init=identical_init,\\n sel_norm=sel_norm,\\n expert_dropout=drop_expert,\\n sync_distributed=sync_distributed,\\n modulation_amplitude=modulation_amplitude)\\n\\n self.norm1 = torch.nn.LayerNorm(d_model, elementwise_affine=ln_affine)\\n self.norm2 = torch.nn.LayerNorm(d_model, elementwise_affine=ln_affine)\\n self.dropout = torch.nn.Dropout(dropout)\\n\\n self.activation = activation\\n self.drop_parallel = drop_parallel\\n\\n if preln:\\n reset_prenorm_params(self, n_layers)\\n\\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\\n pos_offset: Optional[int] = None) -> torch.Tensor:\\n\\n src2 = self.norm1(src) if self.preln else src\\n src2 = self.self_attn(src2, self.norm1(attend_to) if attend_to is not None else src2, mask,\\n pos_offset=pos_offset)\\n src = src + self.dropout(src2)\\n\\n if self.preln:\\n src2 = self.norm2(src)\\n else:\\n src = src2 = self.norm1(src)\\n\\n src3 = self.pkm(src2)\\n\\n src = src + self.dropout(src3)\\n if not self.preln:\\n src = self.norm2(src)\\n return src\"\n },\n {\n \"identifier\": \"FastRopeTransformerEncoderLayer\",\n \"path\": \"layers/transformer/fast_rope_transformer.py\",\n \"snippet\": \"class FastRopeTransformerEncoderLayer(torch.nn.Module):\\n def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation: ActivationFunction = F.relu,\\n attention_dropout=0, drop_expand: bool = True,\\n head_projection_size: Optional[int] = None, preln: bool = False, n_layers: Optional[int] = None,\\n rotate_fraction: float = 0.5, rope_base: float = 10000):\\n super().__init__()\\n self.preln = preln\\n self.self_attn = FastRopeAttention(\\n d_model, nhead, dropout=attention_dropout,\\n projection_size=head_projection_size, rotate_fraction=rotate_fraction,\\n rope_base=rope_base)\\n self.linear1 = torch.nn.Linear(d_model, dim_feedforward)\\n self.dropout = torch.nn.Dropout(dropout) if drop_expand else lambda x: x\\n self.linear2 = torch.nn.Linear(dim_feedforward, d_model)\\n\\n self.norm1 = torch.nn.LayerNorm(d_model)\\n self.norm2 = torch.nn.LayerNorm(d_model)\\n self.dropout1 = torch.nn.Dropout(dropout)\\n self.dropout2 = torch.nn.Dropout(dropout)\\n\\n self.activation = activation\\n\\n if preln:\\n if n_layers is None:\\n raise ValueError(\\\"n_layers must be specified when using preln\\\")\\n reset_prenorm_params(self, n_layers)\\n else:\\n self.reset_parameters()\\n\\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\\n pos_offset: Optional[int] = None) -> torch.Tensor:\\n src2 = self.norm1(src) if self.preln else src\\n src2 = self.self_attn(src2, self.norm1(attend_to) if attend_to is not None else src2, mask, pos_offset=pos_offset)\\n src = src + self.dropout1(src2)\\n\\n if self.preln:\\n src2 = self.norm2(src)\\n else:\\n src2 = src = self.norm1(src)\\n\\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))\\n src = src + self.dropout2(src2)\\n\\n if not self.preln:\\n src = self.norm2(src)\\n return src\\n\\n def reset_parameters(self):\\n torch.nn.init.xavier_normal_(self.linear1.weight, gain=torch.nn.init.calculate_gain('relu')\\n if self.activation is F.relu else 1.0)\\n torch.nn.init.xavier_uniform_(self.linear2.weight)\"\n },\n {\n \"identifier\": \"MoeAttentionRelativeTransformerEncoderLayer\",\n \"path\": \"layers/transformer/moe_attention_relative_transformer.py\",\n \"snippet\": \"class MoeAttentionRelativeTransformerEncoderLayer(torch.nn.Module):\\n def __init__(self, d_model, nhead, moe_att_n_experts, dim_feedforward=2048, dropout=0.1, activation: ActivationFunction = F.relu,\\n attention_dropout=0, drop_expand: bool = True,\\n head_projection_size: Optional[int] = None, preln: bool = False, n_layers: Optional[int] = None,\\n att_perplexity_reg: float = 0.0, expert_dropout: float = 0.0, att_selection_mode=\\\"sigmoid\\\",\\n attention_variant=\\\"moa\\\", q_expert: bool = True, k_expert: bool = True, v_expert: bool = True,\\n o_expert: bool = True, moe_k: int = 2,\\n norm_qk_score: bool = False, v_projection_size: Optional[int] = None, same_sel: bool = False,\\n qside_n_experts: Optional[int] = None, shared_experts: bool = False,\\n kq_n_experts: Optional[int] = None, separate_kq_sel: bool = False,\\n cvloss: float = 0.0, switchloss: float = 0.0, zloss: float = 0.0,\\n moa_mode: str = \\\"my\\\", rotate_fraction: float = 0.5, rope_base: float = 10000,\\n moeatt_norm_init: bool = False):\\n super().__init__()\\n self.is_preln = preln\\n if attention_variant not in {\\\"full\\\", \\\"full_rope\\\"} and (not q_expert):\\n raise ValueError(\\\"q_expert can be disabled only when using qside attention\\\")\\n\\n if attention_variant == \\\"moa\\\":\\n self.self_attn = MoA(\\n d_model, nhead, dropout=attention_dropout,\\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\\n n_experts=moe_att_n_experts, perplexity_reg=att_perplexity_reg, expert_dropout=expert_dropout,\\n selection_mode=att_selection_mode, mode=moa_mode, cvloss=cvloss, switchloss=switchloss, zloss=zloss\\n )\\n elif attention_variant == \\\"full\\\":\\n self.self_attn = FullMoeRelativeAttention(\\n d_model, nhead, dropout=attention_dropout,\\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\\n n_experts=moe_att_n_experts, perplexity_reg=att_perplexity_reg, expert_dropout=expert_dropout,\\n selection_mode=att_selection_mode, q_expert=q_expert, k_expert=k_expert, v_expert=v_expert,\\n norm_qk_score=norm_qk_score, v_projection_size=v_projection_size, same_sel=same_sel,\\n o_expert=o_expert, moe_k=moe_k, qside_n_experts=qside_n_experts,\\n shared_experts=shared_experts, kq_n_experts=kq_n_experts, separate_kq_sel=separate_kq_sel,\\n normalize_init=moeatt_norm_init\\n )\\n elif attention_variant == \\\"full_rope\\\":\\n self.self_attn = FullMoeRopeAttention(\\n d_model, nhead, dropout=attention_dropout,\\n projection_size=head_projection_size, init_std_scale=math.sqrt(2 / n_layers) if preln else 1.0,\\n n_experts=moe_att_n_experts, perplexity_reg=att_perplexity_reg, expert_dropout=expert_dropout,\\n selection_mode=att_selection_mode, q_expert=q_expert, k_expert=k_expert, v_expert=v_expert,\\n norm_qk_score=norm_qk_score, v_projection_size=v_projection_size, same_sel=same_sel,\\n o_expert=o_expert, moe_k=moe_k, qside_n_experts=qside_n_experts,\\n shared_experts=shared_experts, kq_n_experts=kq_n_experts, separate_kq_sel=separate_kq_sel,\\n rotate_fraction=rotate_fraction, rope_base=rope_base,\\n normalize_init=moeatt_norm_init\\n )\\n else:\\n raise ValueError(f\\\"Unknown attention variant: {attention_variant}\\\")\\n\\n self.linear1 = torch.nn.Linear(d_model, dim_feedforward)\\n self.dropout = torch.nn.Dropout(dropout) if drop_expand else lambda x: x\\n self.linear2 = torch.nn.Linear(dim_feedforward, d_model)\\n\\n self.norm1 = torch.nn.LayerNorm(d_model)\\n self.norm2 = torch.nn.LayerNorm(d_model)\\n self.dropout1 = torch.nn.Dropout(dropout)\\n self.dropout2 = torch.nn.Dropout(dropout)\\n\\n self.activation = activation\\n\\n if preln:\\n if n_layers is None:\\n raise ValueError(\\\"n_layers must be specified when using preln\\\")\\n reset_prenorm_params(self, n_layers)\\n else:\\n self.reset_parameters()\\n\\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None, attend_to: Optional[torch.Tensor] = None,\\n pos_offset: Optional[int] = None) -> torch.Tensor:\\n src2 = self.norm1(src) if self.is_preln else src\\n src2 = self.self_attn(src2, self.norm1(attend_to) if attend_to is not None else src2, mask, pos_offset=pos_offset)\\n src = src + self.dropout1(src2)\\n\\n if self.is_preln:\\n src2 = self.norm2(src)\\n else:\\n src2 = src = self.norm1(src)\\n\\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))\\n src = src + self.dropout2(src2)\\n\\n if not self.is_preln:\\n src = self.norm2(src)\\n return src\\n\\n def reset_parameters(self):\\n torch.nn.init.xavier_normal_(self.linear1.weight, gain=torch.nn.init.calculate_gain('relu')\\n if self.activation is F.relu else 1.0)\\n torch.nn.init.xavier_uniform_(self.linear2.weight)\"\n },\n {\n \"identifier\": \"MoE\",\n \"path\": \"layers/moe_layer.py\",\n \"snippet\": \"class MoE(LoggingLayer, RegularizedLayer, OncePerIterLayer, torch.nn.Module):\\n def __init__(self, dmodel: int, n_experts: int, expert_size: int, n_heads: int,\\n dropout: float = 0, weight_scale: float = 1.0,\\n dropout_mode: str = \\\"none\\\", selection_mode: str = \\\"sigmoid\\\", perplexity_reg: float = 0.0,\\n norm_keys: bool = False,\\n perplexity_reg_mode: str=\\\"step\\\", n_random: int = 0, reg_type: str = \\\"entropy\\\",\\n topk_mode: str = \\\"full\\\", activation_after_topk: bool = False,\\n activation = lambda x: F.relu(x, inplace=True),\\n normalize_expert_sel_init: bool = False, norm_key_init: bool = False, norm_value_init: bool = False,\\n identical_init: bool = False,\\n rescale_normed: bool = False, sel_norm: str = \\\"none\\\",\\n v_dim: Optional[int] = None,\\n expert_dropout: float = 0.0,\\n sync_distributed: bool = False,\\n modulation_amplitude: float = 0.5,\\n ppl_past_blocks: int = 0):\\n\\n super().__init__()\\n self.k_dim = dmodel\\n self.v_dim = v_dim if v_dim is not None else dmodel\\n self.n_experts = n_experts\\n self.expert_size = expert_size\\n self.size = self.n_experts * self.expert_size\\n self.dropout = dropout\\n self.dropout_mode = dropout_mode\\n self.selection_mode = selection_mode\\n self.perplexity_reg = perplexity_reg\\n self.k_vec_dim = self.k_dim\\n self.n_heads = n_heads\\n self.norm_keys = norm_keys\\n self.perplexity_reg_mode = perplexity_reg_mode\\n self.n_random = n_random\\n self.reg_type = reg_type\\n self.topk_mode = topk_mode\\n self.activation_after_topk = activation_after_topk\\n self.activation = activation\\n self.weight_scale = weight_scale\\n self.normalize_expert_sel_init = normalize_expert_sel_init\\n self.norm_key_init = norm_key_init\\n self.norm_value_init = norm_value_init\\n self.identical_init = identical_init\\n self.layer = 0\\n self.initalized = False\\n self.rescale_normed = rescale_normed\\n self.sel_norm = sel_norm\\n self.was_training = True\\n self.expert_dropout = expert_dropout\\n self.reg_counts = 0\\n self.sync_distributed = sync_distributed and torch.distributed.is_initialized()\\n self.modulation_amplitude = modulation_amplitude\\n self.record_all_expert_sel_counts = False\\n self.ppl_past_blocks = ppl_past_blocks\\n self.blocks_for_ppl = []\\n self.recorded_inputs = []\\n\\n self.coocurence = None\\n\\n assert self.selection_mode in {\\\"gate\\\", \\\"sigmoid\\\", \\\"sinkhorn\\\", \\\"sinkhorn2\\\", \\\"sinkmoid\\\", \\\"sinkmax\\\", \\\"sinkhorn_local\\\", \\\"mul\\\", \\\"sinkmoid2\\\", \\\"sinkmax2\\\"}\\n assert self.perplexity_reg_mode in {\\\"step\\\", \\\"global\\\", \\\"time\\\", \\\"global_time\\\"}\\n assert self.dropout_mode in {\\\"none\\\", \\\"score\\\"}\\n assert self.reg_type in {\\\"perplexity\\\", \\\"variance\\\", \\\"entropy\\\", \\\"l2\\\", \\\"switch\\\"}\\n assert self.topk_mode in {\\\"full\\\", \\\"l1_approx\\\", \\\"approx\\\"}\\n assert self.sel_norm in {\\\"none\\\", \\\"cos\\\", \\\"input\\\", \\\"weights\\\"}\\n\\n self.register_buffer(\\\"iter\\\", torch.tensor(0, dtype=torch.int64), persistent=False)\\n\\n if selection_mode in {\\\"mul\\\"} and activation_after_topk:\\n raise ValueError(\\\"Activation after topk is not supported with mul selection\\\")\\n\\n self.keys = torch.nn.Parameter(torch.empty(self.n_experts, self.k_vec_dim, self.expert_size))\\n\\n self.values = torch.nn.Parameter(torch.empty(self.n_experts, self.expert_size, self.v_dim))\\n\\n self.expert_sel = torch.nn.Parameter(torch.empty(self.n_experts, self.k_vec_dim))\\n self.sel = lambda x: F.linear(x, self.expert_sel)\\n\\n torch.nn.init.normal_(self.expert_sel, std=self.k_vec_dim ** -0.5 * weight_scale)\\n torch.nn.init.normal_(self.keys, std=dmodel ** -0.5 * weight_scale)\\n torch.nn.init.normal_(self.values, std=self.size ** -0.5 * weight_scale)\\n self.sel_hist = []\\n self.index_sel_counts = 0\\n self.index_sel_norm = 0\\n\\n self.index_sel_counts_100 = 0\\n self.index_sel_norm_100 = 0\\n\\n self.sel_count_log = None\\n\\n self.all_expert_sel_counts = []\\n self.all_expert_sel_soft = []\\n\\n self.register_buffer(\\\"kv_sel_counts\\\", torch.zeros(self.n_experts, self.expert_size), persistent=False)\\n self.register_buffer(\\\"kv_sel_counts_100\\\", torch.zeros_like(self.kv_sel_counts))\\n\\n if self.rescale_normed and self.sel_norm != \\\"none\\\":\\n self.sel_scale = torch.nn.Parameter(torch.ones([1]))\\n else:\\n self.sel_scale = 1.0\\n\\n self.register_buffer(\\\"seq\\\", torch.arange(max(self.n_heads, self.n_experts, self.k_dim, self.v_dim), dtype=torch.long), persistent=False)\\n self.regroup_weights()\\n\\n if self.ppl_past_blocks > 0 and self.reg_type not in {\\\"perplexity\\\", \\\"entropy\\\"}:\\n print(f\\\"Warning: ppl_past_blocks>0 (currently {self.ppl_past_blocks}) is only supported with perplexity and entropy regularization\\\")\\n\\n def keys_to_logical_order(self, keys: torch.Tensor) -> torch.Tensor:\\n k = keys.view(self.n_experts, self.k_vec_dim, self.expert_size)\\n return k.permute(0, 2, 1).contiguous().view(-1, self.k_vec_dim)\\n\\n def keys_from_logical_order(self, keys: torch.Tensor) -> torch.Tensor:\\n return keys.view(self.n_experts, self.expert_size, self.k_vec_dim).permute(0, 2, 1).contiguous().view(self.n_experts * self.k_vec_dim, self.expert_size)\\n\\n def renorm_keep_std(self, weight: torch.Tensor, dim: int = 0):\\n with torch.no_grad():\\n std = weight.std()\\n weight.div_(weight.norm(dim=dim, keepdim=True))\\n weight.mul_(std / weight.std())\\n\\n def regroup_weights(self) -> Optional[torch.Tensor]:\\n with torch.no_grad():\\n if self.norm_key_init:\\n self.renorm_keep_std(self.keys.view(self.n_experts, self.k_vec_dim, self.expert_size), dim=1)\\n\\n if self.norm_value_init:\\n self.renorm_keep_std(self.values, dim=1)\\n\\n if self.identical_init:\\n k = self.keys.view(self.n_experts, self.k_vec_dim, self.expert_size)\\n self.keys.set_(k[:1].expand_as(k).reshape_as(self.keys))\\n\\n v = self.values.view(self.n_experts, self.expert_size, self.v_dim)\\n self.values.set_(v[:1].expand_as(v).reshape_as(self.values))\\n\\n if self.normalize_expert_sel_init:\\n self.renorm_keep_std(self.expert_sel, dim=1)\\n\\n def ani(self, x: torch.Tensor) -> torch.Tensor:\\n assert x.ndim == 2\\n chunk_size = 32\\n\\n xnorm = F.normalize(x, 2, dim=-1)\\n\\n accu = 0\\n for i in range(0, x.shape[0], chunk_size):\\n a = xnorm[i: i + chunk_size]\\n sims = xnorm @ a.T\\n sims[i : i + chunk_size].fill_diagonal_(0)\\n accu += sims.sum()\\n\\n return accu / (x.shape[0] * (x.shape[0] - 1))\\n\\n def log_expert_sel_usage(self, prefix: str, channel_sel_counts: torch.Tensor):\\n sel_nonzero = (channel_sel_counts != 0).type(torch.float).sum(axis=-1) / self.expert_size\\n self.log(f\\\"{prefix}/mean\\\", sel_nonzero.mean())\\n self.log(f\\\"{prefix}/min\\\", sel_nonzero.min())\\n self.log(f\\\"{prefix}/max\\\", sel_nonzero.max())\\n\\n\\n def pre_train_forward(self):\\n if self.norm_keys:\\n with torch.no_grad():\\n self.keys.div_(self.keys.norm(dim=-1, keepdim=True))\\n\\n if self.training and not self.was_training:\\n sorted_counts = self.index_sel_counts.sort(descending=True).values\\n self.log(\\\"test_exert_channel_usage\\\", framework.visualize.plot.Barplot(sorted_counts, xlabel=\\\"expert\\\", ylabel=\\\"usage count\\\"), drop_old=True)\\n\\n self.layer = 0\\n if self.sel_hist:\\n self.sel_hist = []\\n self.index_sel_counts = 0\\n self.index_sel_norm = 0\\n self.reg_counts = 0\\n\\n def before_loss(self):\\n if self.sel_hist:\\n # Concatenate against time dimension. Important for the within-batch regularization\\n sel = torch.cat(self.sel_hist, -2)\\n self.add_perplexity_reg(sel)\\n\\n self.sel_hist = []\\n\\n if self.index_sel_norm > 0:\\n if self.training:\\n with torch.no_grad():\\n self.log(\\\"usag_rel_perplexity_all_layers\\\", utils.relative_perplexity(self.index_sel_counts / self.index_sel_norm))\\n self.log(\\\"dead_expert_proportion_all_layers\\\", (self.index_sel_counts == 0).float().sum() / self.n_experts)\\n\\n self.log_expert_sel_usage(\\\"exert_channel_usage\\\", self.kv_sel_counts)\\n\\n self.kv_sel_counts_100.add_(self.kv_sel_counts)\\n self.kv_sel_counts.zero_()\\n\\n self.index_sel_counts_100 = self.index_sel_counts_100 + self.index_sel_counts\\n self.index_sel_norm_100 = self.index_sel_norm_100 + self.index_sel_norm\\n\\n if self.training and self.iter % 100 == 0:\\n norm_cnt = self.index_sel_counts_100 / self.index_sel_norm_100\\n self.log(\\\"usag_rel_perplexity_100\\\", utils.relative_perplexity(norm_cnt))\\n self.log(\\\"dead_expert_proportion_100\\\", (self.index_sel_counts_100 == 0).float().sum() / self.n_experts)\\n\\n sorted_counts = self.index_sel_counts_100.sort(descending=True).values\\n self.log(\\\"usage_counts_100\\\", framework.visualize.plot.Barplot(sorted_counts, xlabel=\\\"expert\\\", ylabel=\\\"usage count\\\"), drop_old=True)\\n\\n\\n self.log_expert_sel_usage(\\\"exert_channel_usage_100\\\", self.kv_sel_counts_100)\\n self.kv_sel_counts_100.zero_()\\n\\n self.index_sel_counts_100 = 0\\n self.index_sel_norm_100 = 0\\n\\n self.log(\\\"ani/keys\\\", self.ani(self.keys_to_logical_order(self.keys)))\\n self.log(\\\"ani/values\\\", self.ani(self.values.flatten(0, -2)))\\n self.log(\\\"ani/expert_sel\\\", self.ani(self.expert_sel.T))\\n\\n if self.training:\\n self.iter += 1\\n\\n def topk(self, x: torch.Tensor, k: int, approx: bool) -> Tuple[torch.Tensor, torch.Tensor]:\\n if approx:\\n x = x.view(*x.shape[:-1], k, -1)\\n scores, ind = x.max(-1)\\n return scores, self.seq[:k] * x.shape[-1] + ind\\n else:\\n return x.topk(k, dim=-1, sorted=False)\\n\\n def rolling_logsumexp(self, x: torch.Tensor) -> torch.Tensor:\\n # Simulate calculating logsumexp over a bigger batch than the current one. Will have stale values, but that\\n # should not matter much later in training.\\n if self.ppl_past_blocks == 0 or not self.training:\\n return F.log_softmax(x, dim=-1)\\n else:\\n if len(self.blocks_for_ppl) == self.ppl_past_blocks:\\n self.blocks_for_ppl.pop(0)\\n\\n self.blocks_for_ppl.append(x)\\n res = F.log_softmax(torch.cat(self.blocks_for_ppl, dim=0), dim=-1)\\n self.blocks_for_ppl[-1] = self.blocks_for_ppl[-1].detach()\\n return res\\n\\n def add_perplexity_reg(self, sel: torch.Tensor):\\n sync_distributed = self.sync_distributed and (self.perplexity_reg_mode not in {\\\"time\\\", \\\"global_time\\\"})\\n\\n if self.perplexity_reg_mode in {\\\"time\\\", \\\"global_time\\\"}:\\n sel = sel.flatten(0, -3)\\n else:\\n sel = sel.flatten(0, -2)\\n\\n # Note: sel are raw logits, no matter what activation is used\\n if self.perplexity_reg > 0:\\n if self.reg_type == \\\"perplexity\\\":\\n sel_d = self.rolling_logsumexp(sel)\\n sel_d = framework.utils.distributed_ops.log_mean(sel_d, -2, self.sync_distributed)\\n loss = lambda: self.perplexity_reg * ( - utils.relative_perplexity_l(sel_d).mean())\\n elif self.reg_type == \\\"entropy\\\":\\n sel_d = self.rolling_logsumexp(sel)\\n sel_d = framework.utils.distributed_ops.log_mean(sel_d, -2, self.sync_distributed)\\n loss = lambda: self.perplexity_reg * ( - utils.entropy_l(sel_d).mean())\\n elif self.reg_type == \\\"variance\\\":\\n if sync_distributed:\\n raise NotImplementedError(\\\"Variance regularization is not supported in distributed mode\\\")\\n avg_sel = sel.mean(-2)\\n loss = lambda: self.perplexity_reg * avg_sel.var(-1).mean()\\n elif self.reg_type == \\\"l2\\\":\\n loss = lambda: self.perplexity_reg * sel.pow(2).mean()\\n elif self.reg_type == \\\"switch\\\":\\n if sync_distributed:\\n torch.distributed.all_reduce(self.reg_counts, op=torch.distributed.ReduceOp.SUM)\\n\\n p_sel_real = self.reg_counts / self.reg_counts.sum(-1, keepdims=True)\\n if self.perplexity_reg_mode in {\\\"time\\\", \\\"global_time\\\"}:\\n p_sel_real = p_sel_real.unsqueeze(-2)\\n\\n loss = lambda: self.perplexity_reg * (F.softmax(sel, dim=-1) * p_sel_real).mean()\\n self.reg_counts = 0\\n else:\\n assert False\\n\\n self.add_reg(loss, \\\"moe\\\")\\n\\n def compute_scores(self, input: torch.Tensor, index: CVMMSel, expert_scores: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\\n scores = cvmm(input, index, self.keys)\\n\\n if self.selection_mode in {\\\"mul\\\"}:\\n scores = scores * expert_scores[..., None]\\n elif self.selection_mode in {\\\"gate\\\", \\\"sigmoid\\\", \\\"sinkhorn\\\", \\\"sinkhorn2\\\", \\\"sinkmoid\\\", \\\"sinkmax\\\", \\\"sinkmoid2\\\"}:\\n # Handle it later\\n pass\\n\\n scores = self.activation(scores)\\n\\n plot_training = self.train and self.iter % 10 == 0\\n if plot_training:\\n with torch.no_grad():\\n gt0 = (scores > 0).float()\\n gt0_s = gt0.sum()\\n\\n if plot_training:\\n self.log(\\\"relu_pass_rate\\\", gt0_s / scores.numel())\\n\\n self.kv_sel_counts.index_add_(0, index.raw_sel.flatten(), gt0.flatten(end_dim=-2))\\n\\n if self.dropout > 0 and self.dropout_mode != \\\"none\\\":\\n scores = F.dropout(scores, self.dropout, training=self.training)\\n\\n return scores\\n\\n def sel_activation(self, sel: torch.Tensor, seq_len: int) -> Tuple[torch.Tensor, torch.Tensor]:\\n reg_sel = sel\\n if self.selection_mode in {\\\"sigmoid\\\"}:\\n sel = torch.sigmoid(sel)\\n elif self.selection_mode in {\\\"mul\\\"}:\\n sel = sel.abs()\\n reg_sel = sel\\n elif self.selection_mode in {\\\"gate\\\"}:\\n sel = F.softmax(sel, dim=-1)\\n with torch.no_grad():\\n self.log(\\\"expert_rel_perplexity_per_selection\\\", utils.relative_perplexity(sel).mean())\\n else:\\n assert False\\n\\n return sel, reg_sel\\n\\n def forward(self, input: torch.Tensor) -> torch.Tensor:\\n out = 0\\n\\n in1 = in2 = input\\n\\n sel = self.sel(in1)\\n # sel=sel.float()\\n\\n if self.sel_norm == \\\"cos\\\":\\n sel = sel / (in1.norm(dim=-1, keepdim=True) * self.expert_sel.norm(dim=-1)[None]) * self.sel_scale\\n elif self.sel_norm == \\\"weights\\\":\\n sel = sel * (self.sel_scale / self.expert_sel.norm(dim=-1)[None])\\n elif self.sel_norm == \\\"input\\\":\\n sel = sel * (self.sel_scale / in1.norm(dim=-1, keepdim=True))\\n\\n sel_raw = reg_sel = sel\\n\\n inv_val = float(\\\"-inf\\\")\\n\\n if not self.activation_after_topk:\\n # Sinkhorn should be always applied before top-k\\n sel, reg_sel = self.sel_activation(sel, input.shape[-2])\\n inv_val = 0\\n\\n if self.training and self.expert_dropout > 0:\\n if self.selection_mode not in {\\\"sigmoid\\\", \\\"gate\\\"}:\\n raise ValueError(\\\"Expert dropout not supported in this mode\\\")\\n\\n mask = torch.rand_like(sel) < self.expert_dropout\\n sel2 = sel.masked_fill(mask, inv_val)\\n else:\\n sel2 = sel\\n\\n sel_val, sel_index = self.topk(sel2, self.n_heads, self.topk_mode in {\\\"l1_approx\\\", \\\"approx\\\"})\\n\\n if self.activation_after_topk or (self.selection_mode in {\\\"mul\\\"}):\\n sel_val = torch.gather(sel_raw, -1, sel_index)\\n sel_val, reg_sel = self.sel_activation(sel_val, input.shape[-2])\\n\\n\\n record_counts_now = (self.training and self.iter % 10 == 0) or (not self.training) or (self.record_all_expert_sel_counts)\\n\\n if not self.training:\\n sel_index_flat = sel_index.flatten(end_dim=-2)\\n if self.coocurence is None:\\n self.coocurence = torch.zeros([self.n_experts, self.n_experts], device=sel_index_flat.device, dtype=torch.long)\\n\\n for h1 in range(self.n_heads):\\n for h2 in range(self.n_heads):\\n ind_flat = sel_index_flat[..., h1] * self.n_experts + sel_index_flat[..., h2]\\n values = torch.tensor([1], device=self.coocurence.device, dtype=self.coocurence.dtype).expand_as(ind_flat)\\n # values = sel_val[..., h2].flatten()\\n self.coocurence.flatten().put_(ind_flat, values, accumulate=True)\\n # self.coocurence[sel_index_flat[..., h1], sel_index_flat[..., h2]] += 1\\n\\n if record_counts_now or self.reg_type == \\\"switch\\\":\\n reg_counts = F.one_hot(sel_index, self.n_experts).type_as(input)\\n\\n if self.reg_type == \\\"switch\\\":\\n reg_counts2 = reg_counts.view(*input.shape[:-2], input.shape[-2] * self.n_heads, self.n_experts)\\n if self.perplexity_reg_mode == \\\"time\\\":\\n reg_counts2 = reg_counts2.sum(-2)\\n else:\\n reg_counts2 = reg_counts2.flatten(end_dim=-2).sum(0)\\n\\n self.reg_counts = self.reg_counts + reg_counts2\\n\\n if record_counts_now:\\n with torch.no_grad():\\n sel_counts = reg_counts.flatten(end_dim=-2).sum(0)\\n cnt = sel_index.nelement()\\n\\n p_expert_sel = sel_counts / cnt\\n\\n self.index_sel_counts = self.index_sel_counts + sel_counts\\n self.index_sel_norm = self.index_sel_norm + cnt\\n\\n if self.record_all_expert_sel_counts:\\n softcnt = torch.zeros_like(sel_counts, dtype=sel_val.dtype)\\n softcnt.index_add_(0, sel_index.flatten(), sel_val.flatten())\\n\\n self.all_expert_sel_soft.append(softcnt)\\n self.all_expert_sel_counts.append(sel_counts)\\n\\n if self.training:\\n self.log(\\\"min_sel_score\\\", sel_val.min(dim=-1).values.mean())\\n self.log(\\\"max_sel_score\\\", sel_val.max(dim=-1).values.mean())\\n\\n sel_oh = F.one_hot(sel_index, self.n_experts).sum(-2).bool()\\n if self.layer >= 1 and self.training:\\n self.log(f\\\"layer_sel_overlap_{self.layer}\\\", ((self.prev_sel_oh & sel_oh).sum(-1).float() / self.n_heads).mean())\\n\\n self.prev_sel_oh = sel_oh\\n\\n ppl = utils.relative_perplexity(p_expert_sel)\\n self.log(\\\"usage_rel_perplexity\\\", ppl)\\n self.log(\\\"dead_expert_proportion\\\", (p_expert_sel == 0).float().sum() / self.n_experts)\\n\\n if self.perplexity_reg_mode in {\\\"step\\\", \\\"time\\\"}:\\n self.add_perplexity_reg(reg_sel)\\n elif self.perplexity_reg > 0 and self.training:\\n self.sel_hist.append(reg_sel)\\n\\n sel_indices = cvmm_prepare_sel2(sel_index.int())\\n\\n scores = self.compute_scores(in2, sel_indices, sel_val)\\n\\n sel_indices = sel_indices.clone()\\n sel_indices.reduction_weight = sel_val\\n sel_indices.sel_index = sel_indices.out_index\\n sel_indices.out_index = None\\n\\n if self.selection_mode not in {\\\"gate\\\", \\\"sigmoid\\\"}:\\n sel_indices.reduction_weight = torch.ones_like(sel_indices.reduction_weight)\\n\\n out = cvmm(scores, sel_indices, self.values)\\n\\n self.layer += 1\\n\\n self.was_training = self.training\\n res = out.view(*input.shape[:-1], self.v_dim)\\n return res\\n\\n def dump_logs(self, save_dir: str):\\n if self.coocurence is not None:\\n os.makedirs(save_dir, exist_ok=True)\\n torch.save(self.coocurence, os.path.join(save_dir, \\\"coocurence.pt\\\"))\\n\\n def get_logs(self) -> Dict[str, Any]:\\n res = super().get_logs()\\n\\n if self.coocurence is not None:\\n coo = self.coocurence / self.coocurence.diagonal().clamp(min=1)[:, None]\\n res[\\\"expert_coocurence\\\"] = framework.visualize.plot.Heatmap(coo, xlabel=\\\"expert\\\", ylabel=\\\"expert\\\", textval=False)\\n self.coocurence = None\\n return res\"\n },\n {\n \"identifier\": \"Result\",\n \"path\": \"interfaces/result.py\",\n \"snippet\": \"class Result:\\n outputs: torch.Tensor\\n loss: torch.Tensor\\n\\n batch_dim = 0\\n\\n def plot(self) -> Dict[str, Any]:\\n return {}\\n\\n @property\\n def batch_size(self) -> int:\\n return self.outputs.shape[self.batch_dim]\\n\\n @staticmethod\\n def merge(l: List, batch_weights: Optional[List[float]] = None):\\n if len(l) == 1:\\n return l[0]\\n batch_weights = batch_weights if batch_weights is not None else [1] * len(l)\\n loss = sum([r.loss * w for r, w in zip(l, batch_weights)]) / sum(batch_weights)\\n out = torch.cat([r.outputs for r in l], l[0].batch_dim)\\n return l[0].__class__(out, loss)\"\n },\n {\n \"identifier\": \"LayerVisualizer\",\n \"path\": \"layers/layer_with_visualization.py\",\n \"snippet\": \"class LayerVisualizer:\\n def __init__(self, module: torch.nn.Module, options: Dict[str, Any] = {}):\\n self.modules = []\\n self.options = options\\n self.curr_options = None\\n for n, m in module.named_modules():\\n if isinstance(m, LayerWithVisualization):\\n self.modules.append((n, m))\\n\\n def plot(self) -> Dict[str, Any]:\\n res = {}\\n for n, m in self.modules:\\n res.update({f\\\"{n}/{k}\\\": v for k, v in m.plot(self.curr_options).items()})\\n m.visualization_enabled = False\\n\\n self.curr_options = None\\n return res\\n\\n def prepare(self, options: Dict[str, Any] = {}):\\n self.curr_options = self.options.copy()\\n self.curr_options.update(options)\\n\\n for _, m in self.modules:\\n m.prepare()\\n m.visualization_enabled = True\"\n },\n {\n \"identifier\": \"FullMoeRelativeAttentionCore\",\n \"path\": \"layers/transformer/full_moe_relative_attention.py\",\n \"snippet\": \"class FullMoeRelativeAttentionCore(LayerWithVisualization, LoggingLayer, RegularizedLayer, OncePerIterLayer, torch.nn.Module):\\n def __init__(self, state_size: int, n_heads: int, n_experts: int, dropout: float = 0.0, input_size: Optional[int] = None,\\n projection_size: Optional[int] = None, output_size: Optional[int] = None, init_std_scale: float = 1.0,\\n perplexity_reg: float = 0, share_pk: bool = True, expert_dropout: float = 0.0,\\n selection_mode: str = \\\"sigmoid\\\", moe_k: int = 2, q_expert: bool = True,\\n k_expert: bool = True, v_expert: bool = True, o_expert: bool = True, norm_qk_score: bool = False,\\n v_projection_size: Optional[int] = None, same_sel: bool = False,\\n qside_n_experts: Optional[int] = None, shared_experts: bool = False,\\n kq_n_experts: Optional[int] = None, separate_kq_sel: bool = False,\\n normalize_init: bool = False, normalize_retrieval: bool = False):\\n\\n super().__init__()\\n\\n self.input_size = input_size or state_size\\n self.output_size = output_size or state_size\\n self.pe_size = self.input_size\\n self.perplexity_reg = perplexity_reg\\n self.share_pk = share_pk\\n self.expert_dropout = expert_dropout\\n self.selection_mode = selection_mode\\n self.iter = 0\\n self.moe_k = moe_k\\n self.norm_qk_score = norm_qk_score\\n self.same_sel = same_sel\\n self.shared_experts = shared_experts\\n self.init_std_scale = init_std_scale\\n self.normalize_init = normalize_init\\n self.attention_to_visualize = []\\n self.selections_to_visualize = {}\\n\\n self.is_expert = {\\n \\\"k\\\": k_expert,\\n \\\"q\\\": q_expert,\\n \\\"v\\\": v_expert,\\n \\\"o\\\": o_expert\\n }\\n self.n_experts = {\\n \\\"k\\\": kq_n_experts or n_experts,\\n \\\"q\\\": kq_n_experts or qside_n_experts or n_experts,\\n \\\"v\\\": n_experts,\\n \\\"o\\\": qside_n_experts or n_experts\\n }\\n\\n self.separate_k_sel = separate_kq_sel or (self.n_experts[\\\"k\\\"] != self.n_experts[\\\"v\\\"])\\n self.separate_q_sel = separate_kq_sel or (self.n_experts[\\\"q\\\"] != self.n_experts[\\\"o\\\"])\\n\\n self.sel_hist = {}\\n self.sel_counts_100 = {}\\n\\n self.n_heads = n_heads\\n self.dropout = torch.nn.Dropout(dropout) if dropout > 0 else lambda x: x\\n self.projection_size = projection_size or (state_size // n_heads)\\n self.v_projection_size = v_projection_size or self.projection_size\\n\\n self.std_in = init_std_scale * math.sqrt(1 / self.input_size)\\n std_out = init_std_scale * math.sqrt(1 / (n_heads * self.v_projection_size))\\n\\n self.create_selection_logic()\\n\\n self.src_side_maps = {\\\"k\\\", \\\"v\\\"}\\n\\n self.projections = torch.nn.ParameterDict({\\n \\\"q\\\": self.create_param_block(\\\"q\\\", self.input_size, self.projection_size, self.std_in),\\n \\\"k\\\": self.create_param_block(\\\"k\\\", self.input_size, self.projection_size, self.std_in),\\n \\\"v\\\": self.create_param_block(\\\"v\\\", self.input_size, self.v_projection_size, self.std_in),\\n \\\"o\\\": self.create_param_block(\\\"o\\\", self.v_projection_size, self.output_size, std_out),\\n })\\n\\n if normalize_retrieval:\\n self.norm_ret = torch.nn.LayerNorm(self.projection_size)\\n else:\\n self.norm_ret = lambda x: x\\n\\n self.sel_correlation = 0\\n\\n self.register_buffer(\\\"scale\\\", torch.full([1], 1.0 / math.sqrt(self.projection_size)), persistent=False)\\n\\n def renorm_keep_std(self, weight: torch.Tensor, dim: int = 0):\\n with torch.no_grad():\\n std = weight.std()\\n weight.div_(weight.norm(dim=dim, keepdim=True))\\n weight.mul_(std / weight.std())\\n\\n def get_n_copies(self, name: str):\\n return self.n_heads\\n\\n def create_param_block(self, name: str, in_size: int, out_size: int, std: float):\\n n_copies = self.get_n_copies(name)\\n\\n if self.is_expert[name]:\\n exp_mul = 1 if self.shared_experts else n_copies\\n p = torch.nn.Parameter(torch.randn(exp_mul * self.n_experts[name], in_size, out_size) * std)\\n if self.normalize_init:\\n self.renorm_keep_std(p, dim=0)\\n return p\\n else:\\n if name == \\\"o\\\":\\n in_size = n_copies * in_size\\n else:\\n out_size = n_copies * out_size\\n return torch.nn.Parameter(torch.randn(out_size, in_size) * std)\\n\\n def create_selection_logic(self):\\n sels_params = {}\\n self.sel_map = {}\\n\\n def register_remap(dest: str, src: str) -> bool:\\n if not (src in sels_params or src in self.sel_map):\\n # src is not defined\\n return False\\n\\n assert self.n_experts[src] == self.n_experts[dest]\\n self.sel_map[dest] = self.sel_map.get(src, src)\\n return True\\n\\n if self.is_expert[\\\"o\\\"]:\\n sels_params[\\\"o\\\"] = self.init_sel(\\\"o\\\", self.std_in)\\n\\n if self.is_expert[\\\"q\\\"] and (self.separate_q_sel or not register_remap(\\\"q\\\", \\\"o\\\")):\\n sels_params[\\\"q\\\"] = self.init_sel(\\\"q\\\", self.std_in)\\n\\n if self.is_expert[\\\"v\\\"] and ((not self.same_sel) or not register_remap(\\\"v\\\", \\\"o\\\")):\\n sels_params[\\\"v\\\"] = self.init_sel(\\\"v\\\", self.std_in)\\n\\n if self.is_expert[\\\"k\\\"]:\\n if (not (self.same_sel and self.separate_k_sel and register_remap(\\\"k\\\", \\\"q\\\"))) and (self.separate_k_sel or not register_remap(\\\"k\\\", \\\"v\\\")):\\n sels_params[\\\"k\\\"] = self.init_sel(\\\"k\\\", self.std_in)\\n\\n self.selections = torch.nn.ParameterDict(sels_params)\\n\\n def init_sel(self, name: str, std: float) -> torch.nn.Parameter:\\n n_copies = self.get_n_copies(name)\\n n_experts = self.n_experts[name]\\n sel = torch.nn.Parameter(torch.randn(n_experts*n_copies, self.input_size) * std)\\n self.renorm_rows(sel)\\n return sel\\n\\n def renorm_rows(self, x: torch.Tensor):\\n with torch.no_grad():\\n std_t = x.std(dim=-1, keepdim=True)\\n x.div_(x.norm(dim=-1, keepdim=True))\\n x.mul_(std_t / x.std())\\n\\n\\n def project_to_torch_order(self, x: torch.Tensor):\\n return x.view(*x.shape[:-1], self.get_n_copies(\\\"k\\\"), -1).transpose(-2, -3)\\n\\n def get_mask_tensor(self, src_len: int, mask: Optional[AttentionMask]) -> Optional[torch.Tensor]:\\n if mask is None or (mask.position_mask is None and mask.src_length_mask is None):\\n return None\\n\\n # mask.position_mask: [..., N_out, N_in]\\n # mask.src_length_mask: [B, ...., N_in]\\n # True where it has to be masked\\n\\n if mask.position_mask is not None:\\n n_pad = src_len - mask.position_mask.shape[-1]\\n if n_pad > 0:\\n pm = F.pad(mask.position_mask, (n_pad, 0), 'constant', value=False)\\n else:\\n pm = mask.position_mask\\n\\n if mask.position_mask is None:\\n m = mask.src_length_mask.unsqueeze(-2).unsqueeze(-2)\\n elif mask.src_length_mask is None:\\n m = pm\\n else:\\n m = mask.src_length_mask.unsqueeze(-2).unsqueeze(-2) | pm\\n\\n return m\\n\\n def train(self, mode: bool = True):\\n self.sel_hist = {}\\n return super().train(mode)\\n\\n def get_lost_on_hist(self, l: List[torch.Tensor]) -> torch.Tensor:\\n assert l[0].ndim == 4\\n l = [t.flatten(1,2) for t in l]\\n sel = torch.cat(l, -2)\\n sel_d = F.log_softmax(sel, dim=-1)\\n sel_d = framework.utils.distributed_ops.log_mean(sel_d, -2, sync_distributed=False)\\n return self.perplexity_reg * ( - utils.entropy_l(sel_d).mean())\\n\\n def get_reg_loss(self) -> Dict[str, torch.Tensor]:\\n l = super().get_reg_loss()\\n for k, v in self.sel_hist.items():\\n l[f\\\"moe_att_entropy/{k}\\\"] = self.get_lost_on_hist(v)\\n\\n self.sel_hist = {}\\n return l\\n\\n def get_sel(self, t: torch.Tensor, w: torch.Tensor, name: str) -> Selection:\\n n_experts = self.n_experts[name]\\n n_copies = self.get_n_copies(name)\\n\\n sel = F.linear(t, w).float()\\n sel = sel.view(*sel.shape[:-1], n_copies, -1)\\n with torch.no_grad():\\n if self.expert_dropout > 0 and self.training:\\n mask = torch.rand_like(sel) < self.expert_dropout\\n sel2 = sel.masked_fill(mask, float('-inf'))\\n else:\\n sel2 = sel\\n _, sel_index = sel2.topk(self.moe_k, dim=-1, sorted=False)\\n sel_val = torch.gather(sel, -1, sel_index)\\n\\n if self.selection_mode == \\\"softmax\\\":\\n sel_val = sel_val.softmax(-1)\\n elif self.selection_mode == \\\"sigmoid\\\":\\n sel_val = sel_val.sigmoid()\\n else:\\n raise ValueError(\\\"Unknown selection mode: \\\" + self.selection_mode)\\n\\n exp_shift = 0 if self.shared_experts else n_experts\\n\\n sel_index_shifted = (torch.arange(n_copies, device=sel_index.device, dtype=sel_index.dtype) * exp_shift).unsqueeze(-1) + sel_index\\n sel_index_pp = cvmm_prepare_sel2(sel_index_shifted.flatten(-2,-1), sel_val)\\n\\n return Selection(sel, sel_val, sel_index, sel_index_pp)\\n\\n def before_loss(self):\\n self.iter += 1\\n if self.iter % 100 == 0:\\n for k, v in self.sel_counts_100.items():\\n sorted_counts = v.sort(descending=True).values\\n self.log(f\\\"sel_counts/{k}\\\", framework.visualize.plot.Barplot(sorted_counts, xlabel=\\\"expert\\\", ylabel=\\\"usage count\\\"), drop_old=True)\\n\\n self.sel_counts_100 = {}\\n\\n def exp_proj(self, x: torch.Tensor, w: torch.Tensor, sel: Selection) -> torch.Tensor:\\n return cvmm(x, sel.sel_index, w)\\n\\n def compute_sel(self, curr_state: torch.Tensor, attend_to: torch.Tensor) -> Dict[str, Selection]:\\n self.selection_mode\\n outs = {}\\n done = {}\\n cross_atten = curr_state is not attend_to\\n\\n for name in (set(self.selections.keys()) | set(self.sel_map.keys())):\\n name_actual = self.sel_map.get(name, name)\\n\\n # There coukd be 2 versions of everything: source side and destination side. Check if they are different,\\n # and if not, use the cached version, my_id is the unique identifier for this transformation\\n is_src_side = (name in self.src_side_maps) or not cross_atten\\n my_id = (name_actual, is_src_side)\\n\\n cached = done.get(my_id)\\n if cached is not None:\\n outs[name] = cached\\n continue\\n\\n # No cache, actually compute\\n inp = attend_to if is_src_side else curr_state\\n v = self.selections[name_actual]\\n outs[name] = self.get_sel(inp, v, name)\\n\\n # Save history for regularization\\n if self.perplexity_reg > 0 and self.training:\\n if name not in self.sel_hist:\\n self.sel_hist[name] = []\\n self.sel_hist[name].append(outs[name].raw_sel)\\n\\n # Visualize statistics\\n if self.training and self.iter % 10 == 0:\\n self.sel_counts_100[name] = self.sel_counts_100.get(name, 0) + \\\\\\n F.one_hot(outs[name].raw_sel_index.flatten(), self.n_experts[name]).sum(0)\\n\\n done[my_id] = outs[name]\\n\\n return outs\\n\\n def project(self, name: str, src: torch.Tensor, sel: Dict[str, Selection]) -> torch.Tensor:\\n if name in sel:\\n sv = sel[name]\\n if self.norm_qk_score and name in {\\\"q\\\", \\\"k\\\"}:\\n sv.sel_index.reduction_weight = F.normalize(sv.sel_index.reduction_weight, p=1, dim=-1)\\n return self.exp_proj(src, self.projections[name], sv)\\n else:\\n return F.linear(src, self.projections[name])\\n\\n def attend(self, curr_state: torch.Tensor, attend_to: torch.Tensor, pos_offset: int, v: torch.Tensor,\\n k: torch.Tensor, q: torch.Tensor, mask: Optional[torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:\\n raise NotImplementedError()\\n\\n def attention_proj(self, att: torch.Tensor, v: torch.Tensor,\\n mask: Optional[torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:\\n if mask is not None:\\n att.masked_fill_(mask, float('-inf'))\\n\\n att = F.softmax(att, dim=-1)\\n\\n res = att @ v\\n return res, att\\n\\n def forward(self, curr_state: torch.Tensor, attend_to: torch.Tensor, mask: Optional[AttentionMask],\\n pos_offset: Optional[int] = None, need_weights: bool = False):\\n # curr_state: [batch_size, out_len, c]\\n # attend_to: [batch_size, in_len, c]\\n\\n if pos_offset is None:\\n assert curr_state.shape[1] == attend_to.shape[1], \\\"If attend_to has different shape than curr_state, pos_offset should be provided\\\"\\n pos_offset = 0\\n\\n sel = self.compute_sel(curr_state, attend_to)\\n\\n # scale q and k with sqrt(scale) before the attention. This should save memory, be faster, and\\n # keep the range of k and v better. It should make attention NaNs better with float16.\\n scale = self.scale.sqrt()\\n\\n q = self.project(\\\"q\\\", curr_state, sel)\\n q = q * scale.type_as(q)\\n k = self.project(\\\"k\\\", attend_to, sel)\\n k = k * scale.type_as(k)\\n v = self.project(\\\"v\\\", attend_to, sel)\\n\\n q = self.project_to_torch_order(q) if \\\"q\\\" not in sel else q.transpose(-2,-3)\\n k = self.project_to_torch_order(k) if \\\"k\\\" not in sel else k.transpose(-2,-3)\\n v = self.project_to_torch_order(v) if \\\"v\\\" not in sel else v.transpose(-2,-3)\\n\\n k = self.dropout(k)\\n\\n res, att = self.attend(curr_state, attend_to, pos_offset, v, k, q, self.get_mask_tensor(attend_to.shape[-2], mask))\\n res = self.norm_ret(res)\\n\\n if self.visualization_enabled:\\n self.attention_to_visualize.append(att[0].detach())\\n for k, s in sel.items():\\n if k not in self.selections_to_visualize:\\n self.selections_to_visualize[k] = []\\n\\n with torch.no_grad():\\n m = torch.zeros([*s.sel_val[0].shape[:-1], self.n_experts[k]], device=s.sel_val.device, dtype=s.sel_val.dtype)\\n m.scatter_(-1, s.raw_sel_index[0], s.sel_val[0])\\n\\n self.selections_to_visualize[k].append(m)\\n\\n if self.get_n_copies(\\\"k\\\") != self.get_n_copies(\\\"v\\\"):\\n res = res.view(\\n *res.shape[:-1], self.get_n_copies(\\\"v\\\") // self.get_n_copies(\\\"k\\\"), -1).transpose(2,3).flatten(1,2).contiguous()\\n\\n if self.is_expert[\\\"o\\\"]:\\n res = res.transpose(-2, -3)\\n # The output selection indices are calculated from the current state and are also used for projecting \\\"q\\\".\\n # But that projection needs to create multiple copies for the different heads. Here we already have the\\n # heads, but we have to create copies for the top-k elements. We can calculate that from the reduction\\n # weight. We also want to compute not only the weighted average between the top-k elements, but also\\n # of the different heads. So reshape the reduction weight accordingly.\\n o_sel = sel[\\\"o\\\"].sel_index.clone()\\n o_sel.sel_index = o_sel.out_index // o_sel.reduction_weight.shape[-1]\\n o_sel.reduction_weight = o_sel.reduction_weight.flatten(-2)\\n out = cvmm(res, o_sel, self.projections[\\\"o\\\"])\\n else:\\n res = res.transpose(-2, -3)\\n out = F.linear(res.contiguous().view(*curr_state.shape[:-1], -1), self.projections[\\\"o\\\"])\\n\\n return out\\n\\n def plot(self, options: Dict[str, Any]) -> Dict[str, Any]:\\n r = {}\\n marks = options.get(\\\"steplabel\\\")\\n n_steps = options.get(\\\"n_steps\\\") or 9999999\\n y_marks = options.get(\\\"target_labels\\\", marks)\\n\\n ns1 = (self.attention_to_visualize[0].shape[-2] + n_steps) if n_steps < 0 else 0\\n ns1_e = self.attention_to_visualize[0].shape[-2] if n_steps < 0 else n_steps\\n ns2 = (self.attention_to_visualize[0].shape[-1] + n_steps) if n_steps < 0 else 0\\n ns2_e = self.attention_to_visualize[0].shape[-1] if n_steps < 0 else n_steps\\n\\n if marks is not None:\\n assert len(marks) == self.attention_to_visualize[0].shape[-1]\\n marks = marks[ns2:ns2_e]\\n\\n if y_marks is not None:\\n assert len(y_marks) == self.attention_to_visualize[0].shape[-2]\\n y_marks = y_marks[ns1:ns1_e]\\n\\n if options.get(\\\"mha.plot_head_details\\\") and self.attention_to_visualize[0].shape[0] > 1:\\n for head in range(self.attention_to_visualize[0].shape[0]):\\n sel_map = {k: [e[:, head][ns1:ns1_e] if k in {'q', 'o'} else e[:, head][ns2:ns2_e] for e in v] for k, v in self.selections_to_visualize.items()}\\n selections = {k: torch.stack(v, 0).cpu() for k, v in sel_map.items()}\\n\\n x_selections = {k: v for k, v in selections.items() if k in {'k', 'v'}}\\n y_selections = {k: v for k, v in selections.items() if k in {'q', 'o'}}\\n\\n r[f\\\"head_{head}\\\"] = MoEAttentionPlot(\\n torch.stack([layer[head][ns1:ns1_e, ns2:ns2_e] for _, layer in enumerate(self.attention_to_visualize)], 0),\\n x_selections, y_selections,\\n ylabel=\\\"dest\\\", xlabel=\\\"src\\\", x_marks=marks, y_marks=y_marks)\\n\\n r[\\\"attention_max\\\"] = framework.visualize.plot.AnimatedHeatmap(\\n torch.stack([layer.max(0)[0][ns1:ns1_e, ns2:ns2_e] for _, layer in enumerate(self.attention_to_visualize)], 0),\\n ylabel=\\\"dest\\\", xlabel=\\\"src\\\", textval=False, x_marks=marks, y_marks=y_marks, ignore_wrong_marks=True)\\n\\n self.attention_to_visualize = []\\n self.selections_to_visualize = {}\\n return r\\n\\n def dump_logs(self, save_dir: str):\\n if torch.is_tensor(self.sel_correlation):\\n os.makedirs(save_dir, exist_ok=True)\\n torch.save(self.sel_correlation, os.path.join(save_dir, \\\"sel_correlation.pt\\\"))\\n\\n def get_logs(self) -> Dict[str, Any]:\\n res = super().get_logs()\\n\\n if torch.is_tensor(self.sel_correlation):\\n coo = self.sel_correlation / self.sel_correlation.flatten(1).sum(-1).clamp(min=1)[:, None, None]\\n for h in range(self.n_heads):\\n res[f\\\"expert_coocurence_{h}\\\"] = framework.visualize.plot.Heatmap(coo[h], xlabel=\\\"o expert\\\", ylabel=\\\"v expert\\\", textval=False)\\n self.sel_correlation = 0\\n return res\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import framework\nimport torch\nimport torch.nn\nimport torch.nn.functional as F\nimport torch.utils.data\nimport math\nfrom typing import List, Tuple, Dict, Any\nfrom models import TransformerLanguageModel\nfrom ... import task, args\nfrom layers.transformer import RelativeTransformerEncoderLayer, PrelnRelativeTransformerEncoderLayer\nfrom layers.transformer.relative_moe_transformer import RelativeMoeTransformerEncoderLayer\nfrom layers.transformer.fast_rope_transformer import FastRopeTransformerEncoderLayer\nfrom layers.transformer.moe_attention_relative_transformer import MoeAttentionRelativeTransformerEncoderLayer\nfrom layers.moe_layer import MoE\nfrom interfaces import Result\nfrom layers import LayerVisualizer\nfrom layers.transformer.full_moe_relative_attention import FullMoeRelativeAttentionCore"},"token_num":{"kind":"number","value":21372,"string":"21,372"},"cropped_code":{"kind":"string","value":" v_projection_size=self.helper.args.moe.att.v_size,\n same_sel=self.helper.args.moe.att.same_sel,\n moe_k=self.helper.args.moe.att.k,\n qside_n_experts=self.helper.args.moe.att.qside_n_experts,\n shared_experts=self.helper.args.moe.att.shared_experts,\n kq_n_experts=self.helper.args.moe.att.kq_n_experts,\n separate_kq_sel=self.helper.args.moe.att.separate_kq_sel,\n moa_mode=self.helper.args.moa.mode,\n cvloss=self.helper.args.moa.cvloss,\n switchloss=self.helper.args.moa.switchloss,\n zloss=self.helper.args.moa.zloss,\n rotate_fraction=self.helper.args.rope.rotate_fraction,\n rope_base=self.helper.args.rope.base,\n moeatt_norm_init=self.helper.args.moe.att.norm_init)\n elif self.helper.args.transformer.variant in {\"preln_rope\", \"rope\"}:\n mklayer = lambda: FastRopeTransformerEncoderLayer(\n **base_args, **extra_args,\n n_layers=self.helper.args.transformer.encoder_n_layers,\n head_projection_size=self.helper.args.transformer.head_projection_size,\n preln=self.is_preln(), rotate_fraction = self.helper.args.rope.rotate_fraction,\n rope_base=self.helper.args.rope.base)\n elif self.helper.args.transformer.variant in {\"preln_moe\", \"moe\"}:\n # def __init__(self, d_model, nhead, n_bins: int, bin_size: int, n_layers: int, dim_feedforward=2048,\n mklayer = lambda: RelativeMoeTransformerEncoderLayer(\n **base_args, **extra_args, preln=self.is_preln(),\n test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,\n n_layers=self.helper.args.transformer.encoder_n_layers,\n n_experts=self.helper.args.moe.n_experts,\n expert_size=self.helper.args.moe.expert_size,\n dropout_mode=self.helper.args.kvmem.dropout,\n selection_mode=self.helper.args.moe.selection_mode,\n perplexity_reg=self.helper.args.moe.perplexity_reg,\n n_heads=self.helper.args.pkm.n_heads,\n norm_keys=self.helper.args.moe.norm_keys,\n perplexity_reg_mode=self.helper.args.moe.perplexity_reg_mode,\n n_random=self.helper.args.moe.n_random,\n reg_type=self.helper.args.moe.reg_type,\n topk_mode=self.helper.args.moe.topk_mode,\n head_projection_size=self.helper.args.transformer.head_projection_size,\n activation_after_topk=self.helper.args.moe.activation_after_topk,\n drop_parallel=self.helper.args.moe.drop_parallel,\n norm_key_init=self.helper.args.moe.norm_key_init,\n norm_value_init=self.helper.args.moe.norm_value_init,\n normalize_expert_sel_init=self.helper.args.moe.norm_expert_sel_init,\n identical_init=self.helper.args.moe.identical_init,\n sel_norm=self.helper.args.moe.sel_norm,\n ln_affine=self.helper.args.transformer.ln_affine,\n moe_dropout_factor=self.helper.args.moe.dropout_factor,\n drop_expert=self.helper.args.moe.drop_expert,\n sync_distributed=self.helper.args.moe.sync_distributed,\n modulation_amplitude=self.helper.args.moe.modulation_amplitude,\n moe_init_scale=self.helper.args.moe.init_scale,\n moe_attention=self.helper.args.moe.att.enable,\n moe_att_n_experts=self.helper.args.moe.att.n_experts,\n moe_att_expert_dropout=self.helper.args.moe.drop_expert if self.helper.args.moe.att.drop_expert is None else self.helper.args.moe.att.drop_expert,\n moe_att_selection_mode=self.helper.args.moe.att.selection_mode,\n moe_att_variant=self.helper.args.moe.att.variant,\n moe_att_ppl_reg=self.helper.args.moe.perplexity_reg if self.helper.args.moe.att.perplexity_reg is None else self.helper.args.moe.att.perplexity_reg,\n moe_att_k=self.helper.args.moe.att.k,\n q_expert=self.helper.args.moe.att.q_expert,\n k_expert=self.helper.args.moe.att.k_expert,\n v_expert=self.helper.args.moe.att.v_expert,\n o_expert=self.helper.args.moe.att.o_expert,\n v_projection_size=self.helper.args.moe.att.v_size,\n qside_n_experts=self.helper.args.moe.att.qside_n_experts,\n moe_att_shared_experts=self.helper.args.moe.att.shared_experts,\n moe_att_kq_n_experts=self.helper.args.moe.att.kq_n_experts,\n moe_att_separate_kq_sel=self.helper.args.moe.att.separate_kq_sel,\n rotate_fraction=self.helper.args.rope.rotate_fraction,\n rope_base=self.helper.args.rope.base,\n moe_att_norm_init=self.helper.args.moe.att.norm_init,\n moe_att_same_sel=self.helper.args.moe.att.same_sel,\n moe_att_norm_retrieval=self.helper.args.moe.att.norm_ret)\n else:\n assert False, f\"Invalid variant \\\"{self.helper.args.transformer.variant}\\\"\"\n\n layers = [mklayer() for _ in range(self.helper.args.transformer.encoder_n_layers)]\n return layers\n\n\n def fix_init(self, model):\n init_std = 0.02\n\n torch.nn.init.normal_(model.embedding.weight, 0.0, init_std)\n # torch.nn.init.normal_(model.embedding_adapter.weight, 0.0, init_std)\n\n initialized = 0\n for m in model.modules():\n if isinstance(m, (torch.nn.Linear, torch.nn.Embedding)) and hasattr(m, \"weight\"):\n torch.nn.init.normal_(m.weight, 0.0, init_std)\n initialized += m.weight.numel()\n if isinstance(m, (torch.nn.Linear, torch.nn.LayerNorm)) and m.bias is not None:\n torch.nn.init.constant_(m.bias, 0)\n initialized += m.bias.numel()\n if isinstance(m, (torch.nn.LayerNorm)) and m.weight is not None:\n torch.nn.init.normal_(m.weight, 1.0, init_std)\n initialized += m.weight.numel()\n if isinstance(m, MoE):\n torch.nn.init.normal_(m.keys, 0.0, init_std)\n torch.nn.init.normal_(m.values, 0.0, init_std)\n if m.expert_sel is not None:\n torch.nn.init.normal_(m.expert_sel, 0.0, init_std)\n m.renorm_keep_std(m.expert_sel)\n initialized += m.expert_sel.numel()\n initialized += m.keys.numel() + m.values.numel()\n if isinstance(m, (FullMoeRelativeAttentionCore)):\n for p in m.parameters():\n torch.nn.init.normal_(p, 0.0, init_std)\n initialized += p.numel()\n\n for s in m.selections.values():\n m.renorm_keep_std(s)\n\n print(f\"Reinitialized {initialized/self.n_weights*100:.3f}% weights\")\n\n def create_model(self) -> torch.nn.Module:\n self.validation_started_on = None\n # pyright: reportOptionalMemberAccess=false\n tlayers = self.get_layers()\n\n"},"all_code":{"kind":"string","value":"\n\n@args\ndef a(parser: framework.helpers.ArgumentParser):\n parser.add_argument(\"-lm.trafo.context_blocks\", default=1)\n parser.add_argument(\"-lm.trafo.test_context_blocks\", default=\"none\", parser=parser.int_or_none_parser)\n parser.add_argument(\"-lm.trafo.test_pos_clamp\", default=\"none\", parser=parser.int_or_none_parser)\n parser.add_argument(\"-lm.trafo.same_length_eval\", default=False)\n parser.add_argument(\"-lm.trafo.same_length\", default=False)\n parser.add_argument(\"-lm.trafo.last_layer_context\", default=False)\n parser.add_argument(\"-lm.trafo.xl_init\", default=False)\n 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\"])\n parser.add_argument(\"-pkm.n_heads\", default=1)\n parser.add_argument(\"-moe.n_experts\", default=128)\n parser.add_argument(\"-moe.expert_size\", default=128)\n parser.add_argument(\"-moe.selection_mode\", default=\"sigmoid\", choice=[\"gate\", \"sigmoid\", \"mul\"])\n parser.add_argument(\"-moe.perplexity_reg\", default=0.0)\n parser.add_argument(\"-moe.perplexity_reg_mode\", default=\"step\", choice=[\"step\", \"global\", \"time\", \"global_time\"])\n parser.add_argument(\"-moe.reg_type\", default=\"entropy\", choice=[\"perplexity\", \"variance\", \"entropy\", \"l2\", \"switch\", \"normal\"])\n parser.add_argument(\"-moe.norm_keys\", default=False)\n parser.add_argument(\"-moe.n_random\", default=0)\n parser.add_argument(\"-moe.topk_mode\", default=\"full\", choice=[\"full\", \"l1_approx\", \"approx\"])\n parser.add_argument(\"-moe.activation_after_topk\", default=False)\n parser.add_argument(\"-moe.drop_parallel\", default=True)\n parser.add_argument(\"-moe.norm_key_init\", default=False)\n parser.add_argument(\"-moe.norm_value_init\", default=False)\n parser.add_argument(\"-moe.identical_init\", default=False)\n parser.add_argument(\"-moe.sel_lr_multipler\", default=1.0)\n parser.add_argument(\"-moe.expert_lr_multipler\", default=1.0)\n parser.add_argument(\"-moe.sel_norm\", default=\"none\", choice=[\"none\", \"cos\", \"input\", \"weights\"])\n parser.add_argument(\"-moe.dropout_factor\", default=1.0)\n parser.add_argument(\"-moe.drop_expert\", default=0.0)\n parser.add_argument(\"-moe.sync_distributed\", default=True)\n parser.add_argument(\"-moe.modulation_amplitude\", default=0.5)\n parser.add_argument(\"-moe.init_scale\", default=1.0)\n parser.add_argument(\"-moe.norm_expert_sel_init\", default=False)\n parser.add_argument(\"-kvmem.dropout\", default=\"none\", choice=[\"none\", \"early\", \"late\", \"weight\", \"score\"])\n parser.add_argument(\"-kvmem.norm_values\", default=False)\n parser.add_argument(\"-transformer.topk_value\", default=32)\n parser.add_argument(\"-transformer.activation\", default=\"relu\", choice=[\"relu\", \"topk\", \"gelu\", \"identity\", \"sigmoid\", \"softmax\"])\n parser.add_argument(\"-transformer.p_drop_layer\", default=0.0)\n parser.add_argument(\"-transformer.head_projection_size\", default=\"none\", parser=parser.int_or_none_parser)\n parser.add_argument(\"-transformer.ln_affine\", default=True)\n parser.add_argument(\"-transformer.ln_after_attention\", default=True)\n parser.add_argument(\"-moe.att.n_experts\", default=4)\n parser.add_argument(\"-moe.att.variant\", default=\"moa\", choice=[\"moa\", \"simple\", \"qside\", \"full\", \"full_rope\", \"seq\", \"target\"])\n parser.add_argument(\"-moe.att.enable\", default=False)\n parser.add_argument(\"-moe.att.q_expert\", default=True)\n parser.add_argument(\"-moe.att.k_expert\", default=True)\n parser.add_argument(\"-moe.att.v_expert\", default=True)\n parser.add_argument(\"-moe.att.o_expert\", default=True)\n parser.add_argument(\"-moe.att.k\", default=2)\n parser.add_argument(\"-moe.att.norm_qk\", default=False)\n parser.add_argument(\"-moe.att.v_size\", default=\"none\", parser=parser.int_or_none_parser)\n parser.add_argument(\"-moe.att.same_sel\", default=False)\n parser.add_argument(\"-moe.att.expert_dropout\", default=\"none\", parser=parser.float_or_none_parser)\n parser.add_argument(\"-moe.att.selection_mode\", default=\"sigmoid\", choice=[\"sigmoid\", \"softmax\"])\n parser.add_argument(\"-moe.att.perplexity_reg\", default=\"none\", parser=parser.float_or_none_parser)\n parser.add_argument(\"-moe.att.qside_n_experts\", default=\"none\", parser=parser.int_or_none_parser)\n parser.add_argument(\"-moe.att.k\", default=2)\n parser.add_argument(\"-moe.att.norm_ret\", default=False)\n parser.add_argument(\"-moe.att.shared_experts\", default=False)\n parser.add_argument(\"-moe.att.drop_expert\", default=\"none\", parser=parser.float_or_none_parser)\n parser.add_argument(\"-moe.att.kq_n_experts\", default=\"none\", parser=parser.int_or_none_parser)\n parser.add_argument(\"-moe.att.separate_kq_sel\", default=False)\n parser.add_argument(\"-moe.att.norm_init\", default=False)\n parser.add_argument(\"-rope.rotate_fraction\", default=0.5)\n parser.add_argument(\"-rope.base\", default=10000.0)\n parser.add_argument(\"-moa.mode\", default=\"my\", choice=[\"my\", \"moa\"])\n parser.add_argument(\"-moa.cvloss\", default=0.0)\n parser.add_argument(\"-moa.switchloss\", default=0.0)\n parser.add_argument(\"-moa.zloss\", default=0.0)\n parser.add_argument(\"-debug_plot_interval\", default=\"none\", parser=parser.int_or_none_parser)\n parser.add_argument(\"-transformer.plot_head_details\", default=False)\n parser.add_argument(\"-plot.n_steps\", default=-128)\n\n@task()\nclass TransformerLMMixin:\n helper: framework.helpers.TrainingHelper\n\n def is_preln(self) -> bool:\n return \"preln\" in self.helper.args.transformer.variant\n\n def topk_activation(self, x: torch.Tensor) -> torch.Tensor:\n nx = -x\n return torch.masked_fill(x, nx <= nx.kthvalue(self.helper.args.transformer.topk_value, keepdim=True)[0], 0)\n\n def get_layers(self) -> List[torch.nn.Module]:\n # pyright: reportOptionalMemberAccess=false\n if self.helper.args.transformer.activation == \"relu\":\n activation = F.relu\n elif self.helper.args.transformer.activation == \"topk\":\n activation = self.topk_activation\n elif self.helper.args.transformer.activation == \"identity\":\n activation = lambda x: x\n elif self.helper.args.transformer.activation == \"sigmoid\":\n activation = torch.sigmoid\n elif self.helper.args.transformer.activation == \"gelu\":\n activation = F.gelu\n elif self.helper.args.transformer.activation == \"softmax\":\n activation = lambda x: F.softmax(x, dim=-1)\n else:\n raise ValueError(f\"Invalid activation: {self.helper.args.transformer.activation}\")\n\n base_args = dict(\n d_model=self.helper.args.state_size,\n nhead=self.helper.args.transformer.n_heads,\n dropout=self.helper.args.dropout,\n activation=activation\n )\n\n if self.helper.args.transformer.variant not in {\"preln_moe\", \"moe\"}:\n base_args[\"dim_feedforward\"]=int(self.helper.args.state_size * self.helper.args.transformer.ff_multiplier)\n\n\n extra_args = {} if not self.helper.args.transformer.variant.endswith(\"_gelu\") else {\n \"activation\": F.gelu,\n \"drop_expand\": False\n }\n\n\n if self.helper.args.transformer.variant in {\"preln_relative\"}:\n mklayer = lambda: PrelnRelativeTransformerEncoderLayer(\n **base_args, **extra_args, test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,\n n_layers=self.helper.args.transformer.encoder_n_layers,\n head_projection_size=self.helper.args.transformer.head_projection_size,)\n elif self.helper.args.transformer.variant in {\"preln_moeatt\"}:\n mklayer = lambda: MoeAttentionRelativeTransformerEncoderLayer(\n **base_args, **extra_args, moe_att_n_experts=self.helper.args.moe.att.n_experts,\n n_layers=self.helper.args.transformer.encoder_n_layers,\n head_projection_size=self.helper.args.transformer.head_projection_size,\n att_perplexity_reg=self.helper.args.moe.perplexity_reg if self.helper.args.moe.att.perplexity_reg is None else self.helper.args.moe.att.perplexity_reg,\n expert_dropout=self.helper.args.moe.drop_expert if self.helper.args.moe.att.drop_expert is None else self.helper.args.moe.att.drop_expert,\n att_selection_mode=self.helper.args.moe.att.selection_mode,\n preln=self.is_preln(),\n attention_variant=self.helper.args.moe.att.variant,\n q_expert=self.helper.args.moe.att.q_expert,\n k_expert=self.helper.args.moe.att.k_expert,\n v_expert=self.helper.args.moe.att.v_expert,\n o_expert=self.helper.args.moe.att.o_expert,\n norm_qk_score=self.helper.args.moe.att.norm_qk,\n v_projection_size=self.helper.args.moe.att.v_size,\n same_sel=self.helper.args.moe.att.same_sel,\n moe_k=self.helper.args.moe.att.k,\n qside_n_experts=self.helper.args.moe.att.qside_n_experts,\n shared_experts=self.helper.args.moe.att.shared_experts,\n kq_n_experts=self.helper.args.moe.att.kq_n_experts,\n separate_kq_sel=self.helper.args.moe.att.separate_kq_sel,\n moa_mode=self.helper.args.moa.mode,\n cvloss=self.helper.args.moa.cvloss,\n switchloss=self.helper.args.moa.switchloss,\n zloss=self.helper.args.moa.zloss,\n rotate_fraction=self.helper.args.rope.rotate_fraction,\n rope_base=self.helper.args.rope.base,\n moeatt_norm_init=self.helper.args.moe.att.norm_init)\n elif self.helper.args.transformer.variant in {\"preln_rope\", \"rope\"}:\n mklayer = lambda: FastRopeTransformerEncoderLayer(\n **base_args, **extra_args,\n n_layers=self.helper.args.transformer.encoder_n_layers,\n head_projection_size=self.helper.args.transformer.head_projection_size,\n preln=self.is_preln(), rotate_fraction = self.helper.args.rope.rotate_fraction,\n rope_base=self.helper.args.rope.base)\n elif self.helper.args.transformer.variant in {\"preln_moe\", \"moe\"}:\n # def __init__(self, d_model, nhead, n_bins: int, bin_size: int, n_layers: int, dim_feedforward=2048,\n mklayer = lambda: RelativeMoeTransformerEncoderLayer(\n **base_args, **extra_args, preln=self.is_preln(),\n test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,\n n_layers=self.helper.args.transformer.encoder_n_layers,\n n_experts=self.helper.args.moe.n_experts,\n expert_size=self.helper.args.moe.expert_size,\n dropout_mode=self.helper.args.kvmem.dropout,\n selection_mode=self.helper.args.moe.selection_mode,\n perplexity_reg=self.helper.args.moe.perplexity_reg,\n n_heads=self.helper.args.pkm.n_heads,\n norm_keys=self.helper.args.moe.norm_keys,\n perplexity_reg_mode=self.helper.args.moe.perplexity_reg_mode,\n n_random=self.helper.args.moe.n_random,\n reg_type=self.helper.args.moe.reg_type,\n topk_mode=self.helper.args.moe.topk_mode,\n head_projection_size=self.helper.args.transformer.head_projection_size,\n activation_after_topk=self.helper.args.moe.activation_after_topk,\n drop_parallel=self.helper.args.moe.drop_parallel,\n norm_key_init=self.helper.args.moe.norm_key_init,\n norm_value_init=self.helper.args.moe.norm_value_init,\n normalize_expert_sel_init=self.helper.args.moe.norm_expert_sel_init,\n identical_init=self.helper.args.moe.identical_init,\n sel_norm=self.helper.args.moe.sel_norm,\n ln_affine=self.helper.args.transformer.ln_affine,\n moe_dropout_factor=self.helper.args.moe.dropout_factor,\n drop_expert=self.helper.args.moe.drop_expert,\n sync_distributed=self.helper.args.moe.sync_distributed,\n modulation_amplitude=self.helper.args.moe.modulation_amplitude,\n moe_init_scale=self.helper.args.moe.init_scale,\n moe_attention=self.helper.args.moe.att.enable,\n moe_att_n_experts=self.helper.args.moe.att.n_experts,\n moe_att_expert_dropout=self.helper.args.moe.drop_expert if self.helper.args.moe.att.drop_expert is None else self.helper.args.moe.att.drop_expert,\n moe_att_selection_mode=self.helper.args.moe.att.selection_mode,\n moe_att_variant=self.helper.args.moe.att.variant,\n moe_att_ppl_reg=self.helper.args.moe.perplexity_reg if self.helper.args.moe.att.perplexity_reg is None else self.helper.args.moe.att.perplexity_reg,\n moe_att_k=self.helper.args.moe.att.k,\n q_expert=self.helper.args.moe.att.q_expert,\n k_expert=self.helper.args.moe.att.k_expert,\n v_expert=self.helper.args.moe.att.v_expert,\n o_expert=self.helper.args.moe.att.o_expert,\n v_projection_size=self.helper.args.moe.att.v_size,\n qside_n_experts=self.helper.args.moe.att.qside_n_experts,\n moe_att_shared_experts=self.helper.args.moe.att.shared_experts,\n moe_att_kq_n_experts=self.helper.args.moe.att.kq_n_experts,\n moe_att_separate_kq_sel=self.helper.args.moe.att.separate_kq_sel,\n rotate_fraction=self.helper.args.rope.rotate_fraction,\n rope_base=self.helper.args.rope.base,\n moe_att_norm_init=self.helper.args.moe.att.norm_init,\n moe_att_same_sel=self.helper.args.moe.att.same_sel,\n moe_att_norm_retrieval=self.helper.args.moe.att.norm_ret)\n else:\n assert False, f\"Invalid variant \\\"{self.helper.args.transformer.variant}\\\"\"\n\n layers = [mklayer() for _ in range(self.helper.args.transformer.encoder_n_layers)]\n return layers\n\n\n def fix_init(self, model):\n init_std = 0.02\n\n torch.nn.init.normal_(model.embedding.weight, 0.0, init_std)\n # torch.nn.init.normal_(model.embedding_adapter.weight, 0.0, init_std)\n\n initialized = 0\n for m in model.modules():\n if isinstance(m, (torch.nn.Linear, torch.nn.Embedding)) and hasattr(m, \"weight\"):\n torch.nn.init.normal_(m.weight, 0.0, init_std)\n initialized += m.weight.numel()\n if isinstance(m, (torch.nn.Linear, torch.nn.LayerNorm)) and m.bias is not None:\n torch.nn.init.constant_(m.bias, 0)\n initialized += m.bias.numel()\n if isinstance(m, (torch.nn.LayerNorm)) and m.weight is not None:\n torch.nn.init.normal_(m.weight, 1.0, init_std)\n initialized += m.weight.numel()\n if isinstance(m, MoE):\n torch.nn.init.normal_(m.keys, 0.0, init_std)\n torch.nn.init.normal_(m.values, 0.0, init_std)\n if m.expert_sel is not None:\n torch.nn.init.normal_(m.expert_sel, 0.0, init_std)\n m.renorm_keep_std(m.expert_sel)\n initialized += m.expert_sel.numel()\n initialized += m.keys.numel() + m.values.numel()\n if isinstance(m, (FullMoeRelativeAttentionCore)):\n for p in m.parameters():\n torch.nn.init.normal_(p, 0.0, init_std)\n initialized += p.numel()\n\n for s in m.selections.values():\n m.renorm_keep_std(s)\n\n print(f\"Reinitialized {initialized/self.n_weights*100:.3f}% weights\")\n\n def create_model(self) -> torch.nn.Module:\n self.validation_started_on = None\n # pyright: reportOptionalMemberAccess=false\n tlayers = self.get_layers()\n"},"next_line":{"kind":"string","value":" model = TransformerLanguageModel("},"gold_snippet_index":{"kind":"number","value":0,"string":"0"},"created_at":{"kind":"string","value":"2023-12-13 08:45:02+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5971,"cells":{"repo_name":{"kind":"string","value":"AIFSH/NativeDancer"},"file_path":{"kind":"string","value":"nativedancer/third_part/magicanimate/pipelines/pipeline_animation.py"},"context":{"kind":"list like","value":[{"identifier":"UNet3DConditionModel","path":"nativedancer/third_part/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":"ControlNetModel","path":"nativedancer/third_part/magicanimate/models/controlnet.py","snippet":"class ControlNetModel(ModelMixin, ConfigMixin):\n _supports_gradient_checkpointing = True\n\n @register_to_config\n def __init__(\n self,\n in_channels: int = 4,\n flip_sin_to_cos: bool = True,\n freq_shift: int = 0,\n down_block_types: Tuple[str] = (\n \"CrossAttnDownBlock2D\",\n \"CrossAttnDownBlock2D\",\n \"CrossAttnDownBlock2D\",\n \"DownBlock2D\",\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: Optional[int] = 32,\n norm_eps: float = 1e-5,\n cross_attention_dim: int = 1280,\n attention_head_dim: Union[int, Tuple[int]] = 8,\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 projection_class_embeddings_input_dim: Optional[int] = None,\n controlnet_conditioning_channel_order: str = \"rgb\",\n conditioning_embedding_out_channels: Optional[Tuple[int]] = (16, 32, 96, 256),\n ):\n super().__init__()\n\n # Check inputs\n if len(block_out_channels) != len(down_block_types):\n raise ValueError(\n f\"Must provide the same number of `block_out_channels` as `down_block_types`. `block_out_channels`: {block_out_channels}. `down_block_types`: {down_block_types}.\"\n )\n\n if not isinstance(only_cross_attention, bool) and len(only_cross_attention) != len(down_block_types):\n raise ValueError(\n f\"Must provide the same number of `only_cross_attention` as `down_block_types`. `only_cross_attention`: {only_cross_attention}. `down_block_types`: {down_block_types}.\"\n )\n\n if not isinstance(attention_head_dim, int) and len(attention_head_dim) != len(down_block_types):\n raise ValueError(\n f\"Must provide the same number of `attention_head_dim` as `down_block_types`. `attention_head_dim`: {attention_head_dim}. `down_block_types`: {down_block_types}.\"\n )\n\n # input\n conv_in_kernel = 3\n conv_in_padding = (conv_in_kernel - 1) // 2\n self.conv_in = nn.Conv2d(\n in_channels, block_out_channels[0], kernel_size=conv_in_kernel, padding=conv_in_padding\n )\n\n # time\n time_embed_dim = block_out_channels[0] * 4\n\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(\n timestep_input_dim,\n time_embed_dim,\n act_fn=act_fn,\n )\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 elif class_embed_type == \"projection\":\n if projection_class_embeddings_input_dim is None:\n raise ValueError(\n \"`class_embed_type`: 'projection' requires `projection_class_embeddings_input_dim` be set\"\n )\n # The projection `class_embed_type` is the same as the timestep `class_embed_type` except\n # 1. the `class_labels` inputs are not first converted to sinusoidal embeddings\n # 2. it projects from an arbitrary input dimension.\n #\n # Note that `TimestepEmbedding` is quite general, being mainly linear layers and activations.\n # When used for embedding actual timesteps, the timesteps are first converted to sinusoidal embeddings.\n # As a result, `TimestepEmbedding` can be passed arbitrary vectors.\n self.class_embedding = TimestepEmbedding(projection_class_embeddings_input_dim, time_embed_dim)\n else:\n self.class_embedding = None\n\n # control net conditioning embedding\n self.controlnet_cond_embedding = ControlNetConditioningEmbedding(\n conditioning_embedding_channels=block_out_channels[0],\n block_out_channels=conditioning_embedding_out_channels,\n )\n\n self.down_blocks = nn.ModuleList([])\n self.controlnet_down_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\n controlnet_block = nn.Conv2d(output_channel, output_channel, kernel_size=1)\n controlnet_block = zero_module(controlnet_block)\n self.controlnet_down_blocks.append(controlnet_block)\n\n for i, down_block_type in enumerate(down_block_types):\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 num_attention_heads=attention_head_dim[i],\n downsample_padding=downsample_padding,\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 self.down_blocks.append(down_block)\n\n for _ in range(layers_per_block):\n controlnet_block = nn.Conv2d(output_channel, output_channel, kernel_size=1)\n controlnet_block = zero_module(controlnet_block)\n self.controlnet_down_blocks.append(controlnet_block)\n\n if not is_final_block:\n controlnet_block = nn.Conv2d(output_channel, output_channel, kernel_size=1)\n controlnet_block = zero_module(controlnet_block)\n self.controlnet_down_blocks.append(controlnet_block)\n\n # mid\n mid_block_channel = block_out_channels[-1]\n\n controlnet_block = nn.Conv2d(mid_block_channel, mid_block_channel, kernel_size=1)\n controlnet_block = zero_module(controlnet_block)\n self.controlnet_mid_block = controlnet_block\n\n self.mid_block = UNetMidBlock2DCrossAttn(\n in_channels=mid_block_channel,\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 num_attention_heads=attention_head_dim[-1],\n resnet_groups=norm_num_groups,\n use_linear_projection=use_linear_projection,\n upcast_attention=upcast_attention,\n )\n\n @classmethod\n def from_unet(\n cls,\n unet: UNet2DConditionModel,\n controlnet_conditioning_channel_order: str = \"rgb\",\n conditioning_embedding_out_channels: Optional[Tuple[int]] = (16, 32, 96, 256),\n load_weights_from_unet: bool = True,\n ):\n r\"\"\"\n Instantiate Controlnet class from UNet2DConditionModel.\n\n Parameters:\n unet (`UNet2DConditionModel`):\n UNet model which weights are copied to the ControlNet. Note that all configuration options are also\n copied where applicable.\n \"\"\"\n controlnet = cls(\n in_channels=unet.config.in_channels,\n flip_sin_to_cos=unet.config.flip_sin_to_cos,\n freq_shift=unet.config.freq_shift,\n down_block_types=unet.config.down_block_types,\n only_cross_attention=unet.config.only_cross_attention,\n block_out_channels=unet.config.block_out_channels,\n layers_per_block=unet.config.layers_per_block,\n downsample_padding=unet.config.downsample_padding,\n mid_block_scale_factor=unet.config.mid_block_scale_factor,\n act_fn=unet.config.act_fn,\n norm_num_groups=unet.config.norm_num_groups,\n norm_eps=unet.config.norm_eps,\n cross_attention_dim=unet.config.cross_attention_dim,\n attention_head_dim=unet.config.attention_head_dim,\n use_linear_projection=unet.config.use_linear_projection,\n class_embed_type=unet.config.class_embed_type,\n num_class_embeds=unet.config.num_class_embeds,\n upcast_attention=unet.config.upcast_attention,\n resnet_time_scale_shift=unet.config.resnet_time_scale_shift,\n projection_class_embeddings_input_dim=unet.config.projection_class_embeddings_input_dim,\n controlnet_conditioning_channel_order=controlnet_conditioning_channel_order,\n conditioning_embedding_out_channels=conditioning_embedding_out_channels,\n )\n\n if load_weights_from_unet:\n controlnet.conv_in.load_state_dict(unet.conv_in.state_dict())\n controlnet.time_proj.load_state_dict(unet.time_proj.state_dict())\n controlnet.time_embedding.load_state_dict(unet.time_embedding.state_dict())\n\n if controlnet.class_embedding:\n controlnet.class_embedding.load_state_dict(unet.class_embedding.state_dict())\n\n controlnet.down_blocks.load_state_dict(unet.down_blocks.state_dict())\n controlnet.mid_block.load_state_dict(unet.mid_block.state_dict())\n\n return controlnet\n\n # @property\n # # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors\n # def attn_processors(self) -> Dict[str, AttentionProcessor]:\n # r\"\"\"\n # Returns:\n # `dict` of attention processors: A dictionary containing all attention processors used in the model with\n # indexed by its weight name.\n # \"\"\"\n # # set recursively\n # processors = {}\n\n # def fn_recursive_add_processors(name: str, module: torch.nn.Module, processors: Dict[str, AttentionProcessor]):\n # if hasattr(module, \"set_processor\"):\n # processors[f\"{name}.processor\"] = module.processor\n\n # for sub_name, child in module.named_children():\n # fn_recursive_add_processors(f\"{name}.{sub_name}\", child, processors)\n\n # return processors\n\n # for name, module in self.named_children():\n # fn_recursive_add_processors(name, module, processors)\n\n # return processors\n\n # # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attn_processor\n # def set_attn_processor(self, processor: Union[AttentionProcessor, Dict[str, AttentionProcessor]]):\n # r\"\"\"\n # Parameters:\n # `processor (`dict` of `AttentionProcessor` or `AttentionProcessor`):\n # The instantiated processor class or a dictionary of processor classes that will be set as the processor\n # of **all** `Attention` layers.\n # In case `processor` is a dict, the key needs to define the path to the corresponding cross attention processor. This is strongly recommended when setting trainable attention processors.:\n\n # \"\"\"\n # count = len(self.attn_processors.keys())\n\n # if isinstance(processor, dict) and len(processor) != count:\n # raise ValueError(\n # f\"A dict of processors was passed, but the number of processors {len(processor)} does not match the\"\n # f\" number of attention layers: {count}. Please make sure to pass {count} processor classes.\"\n # )\n\n # def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor):\n # if hasattr(module, \"set_processor\"):\n # if not isinstance(processor, dict):\n # module.set_processor(processor)\n # else:\n # module.set_processor(processor.pop(f\"{name}.processor\"))\n\n # for sub_name, child in module.named_children():\n # fn_recursive_attn_processor(f\"{name}.{sub_name}\", child, processor)\n\n # for name, module in self.named_children():\n # fn_recursive_attn_processor(name, module, processor)\n\n # # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_default_attn_processor\n # def set_default_attn_processor(self):\n # \"\"\"\n # Disables custom attention processors and sets the default attention implementation.\n # \"\"\"\n # self.set_attn_processor(AttnProcessor())\n\n # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attention_slice\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\"`, maximum 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_sliceable_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_sliceable_dims(child)\n\n # retrieve number of attention layers\n for module in self.children():\n fn_recursive_retrieve_sliceable_dims(module)\n\n num_sliceable_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_sliceable_layers * [1]\n\n slice_size = num_sliceable_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, (CrossAttnDownBlock2D, DownBlock2D)):\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 controlnet_cond: torch.FloatTensor,\n conditioning_scale: float = 1.0,\n class_labels: Optional[torch.Tensor] = None,\n timestep_cond: Optional[torch.Tensor] = None,\n attention_mask: Optional[torch.Tensor] = None,\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\n return_dict: bool = True,\n ) -> Union[ControlNetOutput, Tuple]:\n # check channel order\n channel_order = self.config.controlnet_conditioning_channel_order\n\n if channel_order == \"rgb\":\n # in rgb order by default\n ...\n elif channel_order == \"bgr\":\n controlnet_cond = torch.flip(controlnet_cond, dims=[1])\n else:\n raise ValueError(f\"unknown `controlnet_conditioning_channel_order`: {channel_order}\")\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 # 1. time\n timesteps = timestep\n if not torch.is_tensor(timesteps):\n # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can\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\n emb = self.time_embedding(t_emb, timestep_cond)\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 # 2. pre-process\n sample = self.conv_in(sample)\n\n controlnet_cond = self.controlnet_cond_embedding(controlnet_cond)\n\n sample += controlnet_cond\n\n # 3. down\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 # cross_attention_kwargs=cross_attention_kwargs,\n )\n else:\n sample, res_samples = downsample_block(hidden_states=sample, temb=emb)\n\n down_block_res_samples += res_samples\n\n # 4. mid\n if self.mid_block is not None:\n sample = self.mid_block(\n sample,\n emb,\n encoder_hidden_states=encoder_hidden_states,\n attention_mask=attention_mask,\n # cross_attention_kwargs=cross_attention_kwargs,\n )\n\n # 5. Control net blocks\n\n controlnet_down_block_res_samples = ()\n\n for down_block_res_sample, controlnet_block in zip(down_block_res_samples, self.controlnet_down_blocks):\n down_block_res_sample = controlnet_block(down_block_res_sample)\n controlnet_down_block_res_samples += (down_block_res_sample,)\n\n down_block_res_samples = controlnet_down_block_res_samples\n\n mid_block_res_sample = self.controlnet_mid_block(sample)\n\n # 6. scaling\n down_block_res_samples = [sample * conditioning_scale for sample in down_block_res_samples]\n mid_block_res_sample *= conditioning_scale\n\n if not return_dict:\n return (down_block_res_samples, mid_block_res_sample)\n\n return ControlNetOutput(\n down_block_res_samples=down_block_res_samples, mid_block_res_sample=mid_block_res_sample\n )"},{"identifier":"ReferenceAttentionControl","path":"nativedancer/third_part/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":"nativedancer/third_part/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":"nativedancer/third_part/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":"nativedancer/third_part/magicanimate/utils/util.py","snippet":"def get_tensor_interpolation_method():\n return tensor_interpolation"}],"string":"[\n {\n \"identifier\": \"UNet3DConditionModel\",\n \"path\": \"nativedancer/third_part/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\": \"ControlNetModel\",\n \"path\": \"nativedancer/third_part/magicanimate/models/controlnet.py\",\n \"snippet\": \"class ControlNetModel(ModelMixin, ConfigMixin):\\n _supports_gradient_checkpointing = True\\n\\n @register_to_config\\n def __init__(\\n self,\\n in_channels: int = 4,\\n flip_sin_to_cos: bool = True,\\n freq_shift: int = 0,\\n down_block_types: Tuple[str] = (\\n \\\"CrossAttnDownBlock2D\\\",\\n \\\"CrossAttnDownBlock2D\\\",\\n \\\"CrossAttnDownBlock2D\\\",\\n \\\"DownBlock2D\\\",\\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: Optional[int] = 32,\\n norm_eps: float = 1e-5,\\n cross_attention_dim: int = 1280,\\n attention_head_dim: Union[int, Tuple[int]] = 8,\\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 projection_class_embeddings_input_dim: Optional[int] = None,\\n controlnet_conditioning_channel_order: str = \\\"rgb\\\",\\n conditioning_embedding_out_channels: Optional[Tuple[int]] = (16, 32, 96, 256),\\n ):\\n super().__init__()\\n\\n # Check inputs\\n if len(block_out_channels) != len(down_block_types):\\n raise ValueError(\\n f\\\"Must provide the same number of `block_out_channels` as `down_block_types`. `block_out_channels`: {block_out_channels}. `down_block_types`: {down_block_types}.\\\"\\n )\\n\\n if not isinstance(only_cross_attention, bool) and len(only_cross_attention) != len(down_block_types):\\n raise ValueError(\\n f\\\"Must provide the same number of `only_cross_attention` as `down_block_types`. `only_cross_attention`: {only_cross_attention}. `down_block_types`: {down_block_types}.\\\"\\n )\\n\\n if not isinstance(attention_head_dim, int) and len(attention_head_dim) != len(down_block_types):\\n raise ValueError(\\n f\\\"Must provide the same number of `attention_head_dim` as `down_block_types`. `attention_head_dim`: {attention_head_dim}. `down_block_types`: {down_block_types}.\\\"\\n )\\n\\n # input\\n conv_in_kernel = 3\\n conv_in_padding = (conv_in_kernel - 1) // 2\\n self.conv_in = nn.Conv2d(\\n in_channels, block_out_channels[0], kernel_size=conv_in_kernel, padding=conv_in_padding\\n )\\n\\n # time\\n time_embed_dim = block_out_channels[0] * 4\\n\\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(\\n timestep_input_dim,\\n time_embed_dim,\\n act_fn=act_fn,\\n )\\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 elif class_embed_type == \\\"projection\\\":\\n if projection_class_embeddings_input_dim is None:\\n raise ValueError(\\n \\\"`class_embed_type`: 'projection' requires `projection_class_embeddings_input_dim` be set\\\"\\n )\\n # The projection `class_embed_type` is the same as the timestep `class_embed_type` except\\n # 1. the `class_labels` inputs are not first converted to sinusoidal embeddings\\n # 2. it projects from an arbitrary input dimension.\\n #\\n # Note that `TimestepEmbedding` is quite general, being mainly linear layers and activations.\\n # When used for embedding actual timesteps, the timesteps are first converted to sinusoidal embeddings.\\n # As a result, `TimestepEmbedding` can be passed arbitrary vectors.\\n self.class_embedding = TimestepEmbedding(projection_class_embeddings_input_dim, time_embed_dim)\\n else:\\n self.class_embedding = None\\n\\n # control net conditioning embedding\\n self.controlnet_cond_embedding = ControlNetConditioningEmbedding(\\n conditioning_embedding_channels=block_out_channels[0],\\n block_out_channels=conditioning_embedding_out_channels,\\n )\\n\\n self.down_blocks = nn.ModuleList([])\\n self.controlnet_down_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\\n controlnet_block = nn.Conv2d(output_channel, output_channel, kernel_size=1)\\n controlnet_block = zero_module(controlnet_block)\\n self.controlnet_down_blocks.append(controlnet_block)\\n\\n for i, down_block_type in enumerate(down_block_types):\\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 num_attention_heads=attention_head_dim[i],\\n downsample_padding=downsample_padding,\\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 self.down_blocks.append(down_block)\\n\\n for _ in range(layers_per_block):\\n controlnet_block = nn.Conv2d(output_channel, output_channel, kernel_size=1)\\n controlnet_block = zero_module(controlnet_block)\\n self.controlnet_down_blocks.append(controlnet_block)\\n\\n if not is_final_block:\\n controlnet_block = nn.Conv2d(output_channel, output_channel, kernel_size=1)\\n controlnet_block = zero_module(controlnet_block)\\n self.controlnet_down_blocks.append(controlnet_block)\\n\\n # mid\\n mid_block_channel = block_out_channels[-1]\\n\\n controlnet_block = nn.Conv2d(mid_block_channel, mid_block_channel, kernel_size=1)\\n controlnet_block = zero_module(controlnet_block)\\n self.controlnet_mid_block = controlnet_block\\n\\n self.mid_block = UNetMidBlock2DCrossAttn(\\n in_channels=mid_block_channel,\\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 num_attention_heads=attention_head_dim[-1],\\n resnet_groups=norm_num_groups,\\n use_linear_projection=use_linear_projection,\\n upcast_attention=upcast_attention,\\n )\\n\\n @classmethod\\n def from_unet(\\n cls,\\n unet: UNet2DConditionModel,\\n controlnet_conditioning_channel_order: str = \\\"rgb\\\",\\n conditioning_embedding_out_channels: Optional[Tuple[int]] = (16, 32, 96, 256),\\n load_weights_from_unet: bool = True,\\n ):\\n r\\\"\\\"\\\"\\n Instantiate Controlnet class from UNet2DConditionModel.\\n\\n Parameters:\\n unet (`UNet2DConditionModel`):\\n UNet model which weights are copied to the ControlNet. Note that all configuration options are also\\n copied where applicable.\\n \\\"\\\"\\\"\\n controlnet = cls(\\n in_channels=unet.config.in_channels,\\n flip_sin_to_cos=unet.config.flip_sin_to_cos,\\n freq_shift=unet.config.freq_shift,\\n down_block_types=unet.config.down_block_types,\\n only_cross_attention=unet.config.only_cross_attention,\\n block_out_channels=unet.config.block_out_channels,\\n layers_per_block=unet.config.layers_per_block,\\n downsample_padding=unet.config.downsample_padding,\\n mid_block_scale_factor=unet.config.mid_block_scale_factor,\\n act_fn=unet.config.act_fn,\\n norm_num_groups=unet.config.norm_num_groups,\\n norm_eps=unet.config.norm_eps,\\n cross_attention_dim=unet.config.cross_attention_dim,\\n attention_head_dim=unet.config.attention_head_dim,\\n use_linear_projection=unet.config.use_linear_projection,\\n class_embed_type=unet.config.class_embed_type,\\n num_class_embeds=unet.config.num_class_embeds,\\n upcast_attention=unet.config.upcast_attention,\\n resnet_time_scale_shift=unet.config.resnet_time_scale_shift,\\n projection_class_embeddings_input_dim=unet.config.projection_class_embeddings_input_dim,\\n controlnet_conditioning_channel_order=controlnet_conditioning_channel_order,\\n conditioning_embedding_out_channels=conditioning_embedding_out_channels,\\n )\\n\\n if load_weights_from_unet:\\n controlnet.conv_in.load_state_dict(unet.conv_in.state_dict())\\n controlnet.time_proj.load_state_dict(unet.time_proj.state_dict())\\n controlnet.time_embedding.load_state_dict(unet.time_embedding.state_dict())\\n\\n if controlnet.class_embedding:\\n controlnet.class_embedding.load_state_dict(unet.class_embedding.state_dict())\\n\\n controlnet.down_blocks.load_state_dict(unet.down_blocks.state_dict())\\n controlnet.mid_block.load_state_dict(unet.mid_block.state_dict())\\n\\n return controlnet\\n\\n # @property\\n # # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors\\n # def attn_processors(self) -> Dict[str, AttentionProcessor]:\\n # r\\\"\\\"\\\"\\n # Returns:\\n # `dict` of attention processors: A dictionary containing all attention processors used in the model with\\n # indexed by its weight name.\\n # \\\"\\\"\\\"\\n # # set recursively\\n # processors = {}\\n\\n # def fn_recursive_add_processors(name: str, module: torch.nn.Module, processors: Dict[str, AttentionProcessor]):\\n # if hasattr(module, \\\"set_processor\\\"):\\n # processors[f\\\"{name}.processor\\\"] = module.processor\\n\\n # for sub_name, child in module.named_children():\\n # fn_recursive_add_processors(f\\\"{name}.{sub_name}\\\", child, processors)\\n\\n # return processors\\n\\n # for name, module in self.named_children():\\n # fn_recursive_add_processors(name, module, processors)\\n\\n # return processors\\n\\n # # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attn_processor\\n # def set_attn_processor(self, processor: Union[AttentionProcessor, Dict[str, AttentionProcessor]]):\\n # r\\\"\\\"\\\"\\n # Parameters:\\n # `processor (`dict` of `AttentionProcessor` or `AttentionProcessor`):\\n # The instantiated processor class or a dictionary of processor classes that will be set as the processor\\n # of **all** `Attention` layers.\\n # In case `processor` is a dict, the key needs to define the path to the corresponding cross attention processor. This is strongly recommended when setting trainable attention processors.:\\n\\n # \\\"\\\"\\\"\\n # count = len(self.attn_processors.keys())\\n\\n # if isinstance(processor, dict) and len(processor) != count:\\n # raise ValueError(\\n # f\\\"A dict of processors was passed, but the number of processors {len(processor)} does not match the\\\"\\n # f\\\" number of attention layers: {count}. Please make sure to pass {count} processor classes.\\\"\\n # )\\n\\n # def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor):\\n # if hasattr(module, \\\"set_processor\\\"):\\n # if not isinstance(processor, dict):\\n # module.set_processor(processor)\\n # else:\\n # module.set_processor(processor.pop(f\\\"{name}.processor\\\"))\\n\\n # for sub_name, child in module.named_children():\\n # fn_recursive_attn_processor(f\\\"{name}.{sub_name}\\\", child, processor)\\n\\n # for name, module in self.named_children():\\n # fn_recursive_attn_processor(name, module, processor)\\n\\n # # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_default_attn_processor\\n # def set_default_attn_processor(self):\\n # \\\"\\\"\\\"\\n # Disables custom attention processors and sets the default attention implementation.\\n # \\\"\\\"\\\"\\n # self.set_attn_processor(AttnProcessor())\\n\\n # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attention_slice\\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\\\"`, maximum 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_sliceable_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_sliceable_dims(child)\\n\\n # retrieve number of attention layers\\n for module in self.children():\\n fn_recursive_retrieve_sliceable_dims(module)\\n\\n num_sliceable_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_sliceable_layers * [1]\\n\\n slice_size = num_sliceable_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, (CrossAttnDownBlock2D, DownBlock2D)):\\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 controlnet_cond: torch.FloatTensor,\\n conditioning_scale: float = 1.0,\\n class_labels: Optional[torch.Tensor] = None,\\n timestep_cond: Optional[torch.Tensor] = None,\\n attention_mask: Optional[torch.Tensor] = None,\\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\\n return_dict: bool = True,\\n ) -> Union[ControlNetOutput, Tuple]:\\n # check channel order\\n channel_order = self.config.controlnet_conditioning_channel_order\\n\\n if channel_order == \\\"rgb\\\":\\n # in rgb order by default\\n ...\\n elif channel_order == \\\"bgr\\\":\\n controlnet_cond = torch.flip(controlnet_cond, dims=[1])\\n else:\\n raise ValueError(f\\\"unknown `controlnet_conditioning_channel_order`: {channel_order}\\\")\\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 # 1. time\\n timesteps = timestep\\n if not torch.is_tensor(timesteps):\\n # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can\\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\\n emb = self.time_embedding(t_emb, timestep_cond)\\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 # 2. pre-process\\n sample = self.conv_in(sample)\\n\\n controlnet_cond = self.controlnet_cond_embedding(controlnet_cond)\\n\\n sample += controlnet_cond\\n\\n # 3. down\\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 # cross_attention_kwargs=cross_attention_kwargs,\\n )\\n else:\\n sample, res_samples = downsample_block(hidden_states=sample, temb=emb)\\n\\n down_block_res_samples += res_samples\\n\\n # 4. mid\\n if self.mid_block is not None:\\n sample = self.mid_block(\\n sample,\\n emb,\\n encoder_hidden_states=encoder_hidden_states,\\n attention_mask=attention_mask,\\n # cross_attention_kwargs=cross_attention_kwargs,\\n )\\n\\n # 5. Control net blocks\\n\\n controlnet_down_block_res_samples = ()\\n\\n for down_block_res_sample, controlnet_block in zip(down_block_res_samples, self.controlnet_down_blocks):\\n down_block_res_sample = controlnet_block(down_block_res_sample)\\n controlnet_down_block_res_samples += (down_block_res_sample,)\\n\\n down_block_res_samples = controlnet_down_block_res_samples\\n\\n mid_block_res_sample = self.controlnet_mid_block(sample)\\n\\n # 6. scaling\\n down_block_res_samples = [sample * conditioning_scale for sample in down_block_res_samples]\\n mid_block_res_sample *= conditioning_scale\\n\\n if not return_dict:\\n return (down_block_res_samples, mid_block_res_sample)\\n\\n return ControlNetOutput(\\n down_block_res_samples=down_block_res_samples, mid_block_res_sample=mid_block_res_sample\\n )\"\n },\n {\n \"identifier\": \"ReferenceAttentionControl\",\n \"path\": \"nativedancer/third_part/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\": \"nativedancer/third_part/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\": \"nativedancer/third_part/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\": \"nativedancer/third_part/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.pipelines.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 ..models.unet_controlnet import UNet3DConditionModel\nfrom ..models.controlnet import ControlNetModel\nfrom ..models.mutual_self_attention import ReferenceAttentionControl\nfrom ..pipelines.context import (\n get_context_scheduler,\n get_total_steps\n)\nfrom ..utils.util import get_tensor_interpolation_method\n from accelerate import cpu_offload"},"token_num":{"kind":"number","value":16791,"string":"16,791"},"cropped_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\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"},"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\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,"},"next_line":{"kind":"string","value":" controlnet: ControlNetModel,"},"gold_snippet_index":{"kind":"number","value":1,"string":"1"},"created_at":{"kind":"string","value":"2023-12-10 20:14:00+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5972,"cells":{"repo_name":{"kind":"string","value":"mkang315/ASF-YOLO"},"file_path":{"kind":"string","value":"segment/val.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=torch.device('cpu'), dnn=False, data=None, fp16=False, fuse=True):\n # Usage:\n # PyTorch: weights = *.pt\n # TorchScript: *.torchscript\n # ONNX Runtime: *.onnx\n # ONNX OpenCV DNN: *.onnx --dnn\n # OpenVINO: *_openvino_model\n # CoreML: *.mlmodel\n # TensorRT: *.engine\n # TensorFlow SavedModel: *_saved_model\n # TensorFlow GraphDef: *.pb\n # TensorFlow Lite: *.tflite\n # TensorFlow Edge TPU: *_edgetpu.tflite\n # PaddlePaddle: *_paddle_model\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 pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle, triton = self._model_type(w)\n fp16 &= pt or jit or onnx or engine # FP16\n nhwc = coreml or saved_model or pb or tflite or edgetpu # BHWC formats (vs torch BCWH)\n stride = 32 # default stride\n cuda = torch.cuda.is_available() and device.type != 'cpu' # use CUDA\n if not (pt or triton):\n w = attempt_download(w) # download if not local\n\n if pt: # PyTorch\n model = attempt_load(weights if isinstance(weights, list) else w, device=device, inplace=True, fuse=fuse)\n stride = max(int(model.stride.max()), 32) # model stride\n names = model.module.names if hasattr(model, 'module') else model.names # get class names\n model.half() if fp16 else model.float()\n self.model = model # explicitly assign for to(), cpu(), cuda(), half()\n elif 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, map_location=device)\n model.half() if fp16 else model.float()\n if extra_files['config.txt']: # load metadata dict\n d = json.loads(extra_files['config.txt'],\n object_hook=lambda d: {int(k) if k.isdigit() else k: v\n for k, v in d.items()})\n stride, names = int(d['stride']), d['names']\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 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 output_names = [x.name for x in session.get_outputs()]\n meta = session.get_modelmeta().custom_metadata_map # metadata\n if 'stride' in meta:\n stride, names = int(meta['stride']), eval(meta['names'])\n elif xml: # OpenVINO\n LOGGER.info(f'Loading {w} for OpenVINO inference...')\n check_requirements('openvino') # requires openvino-dev: https://pypi.org/project/openvino-dev/\n from openvino.runtime import Core, Layout, get_batch\n ie = Core()\n if not Path(w).is_file(): # if not *.xml\n w = next(Path(w).glob('*.xml')) # get *.xml file from *_openvino_model dir\n network = ie.read_model(model=w, weights=Path(w).with_suffix('.bin'))\n if network.get_parameters()[0].get_layout().empty:\n network.get_parameters()[0].set_layout(Layout(\"NCHW\"))\n batch_dim = get_batch(network)\n if batch_dim.is_static:\n batch_size = batch_dim.get_length()\n executable_network = ie.compile_model(network, device_name=\"CPU\") # device_name=\"MYRIAD\" for Intel NCS2\n stride, names = self._load_metadata(Path(w).with_suffix('.yaml')) # load metadata\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__, '7.0.0', hard=True) # require tensorrt>=7.0.0\n if device.type == 'cpu':\n device = torch.device('cuda:0')\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 context = model.create_execution_context()\n bindings = OrderedDict()\n output_names = []\n fp16 = False # default updated below\n dynamic = False\n for i in range(model.num_bindings):\n name = model.get_binding_name(i)\n dtype = trt.nptype(model.get_binding_dtype(i))\n if model.binding_is_input(i):\n if -1 in tuple(model.get_binding_shape(i)): # dynamic\n dynamic = True\n context.set_binding_shape(i, tuple(model.get_profile_shape(0, i)[2]))\n if dtype == np.float16:\n fp16 = True\n else: # output\n output_names.append(name)\n shape = tuple(context.get_binding_shape(i))\n im = torch.from_numpy(np.empty(shape, dtype=dtype)).to(device)\n bindings[name] = Binding(name, dtype, shape, im, int(im.data_ptr()))\n binding_addrs = OrderedDict((n, d.ptr) for n, d in bindings.items())\n batch_size = bindings['images'].shape[0] # if dynamic, this is instead max batch size\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 saved_model: # TF SavedModel\n LOGGER.info(f'Loading {w} for TensorFlow SavedModel inference...')\n import tensorflow as tf\n keras = False # assume TF1 saved_model\n model = tf.keras.models.load_model(w) if keras else tf.saved_model.load(w)\n elif pb: # GraphDef https://www.tensorflow.org/guide/migrate#a_graphpb_or_graphpbtxt\n LOGGER.info(f'Loading {w} for TensorFlow GraphDef 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 ge = x.graph.as_graph_element\n return x.prune(tf.nest.map_structure(ge, inputs), tf.nest.map_structure(ge, outputs))\n\n def gd_outputs(gd):\n name_list, input_list = [], []\n for node in gd.node: # tensorflow.core.framework.node_def_pb2.NodeDef\n name_list.append(node.name)\n input_list.extend(node.input)\n return sorted(f'{x}:0' for x in list(set(name_list) - set(input_list)) if not x.startswith('NoOp'))\n\n gd = tf.Graph().as_graph_def() # TF GraphDef\n with open(w, 'rb') as f:\n gd.ParseFromString(f.read())\n frozen_func = wrap_frozen_graph(gd, inputs=\"x:0\", outputs=gd_outputs(gd))\n elif tflite or edgetpu: # https://www.tensorflow.org/lite/guide/python#install_tensorflow_lite_for_python\n try: # https://coral.ai/docs/edgetpu/tflite-python/#update-existing-tf-lite-code-for-the-edge-tpu\n from tflite_runtime.interpreter import Interpreter, load_delegate\n except ImportError:\n import tensorflow as tf\n Interpreter, load_delegate = tf.lite.Interpreter, tf.lite.experimental.load_delegate,\n if edgetpu: # TF Edge TPU https://coral.ai/software/#edgetpu-runtime\n LOGGER.info(f'Loading {w} for TensorFlow Lite Edge TPU inference...')\n delegate = {\n 'Linux': 'libedgetpu.so.1',\n 'Darwin': 'libedgetpu.1.dylib',\n 'Windows': 'edgetpu.dll'}[platform.system()]\n interpreter = Interpreter(model_path=w, experimental_delegates=[load_delegate(delegate)])\n else: # TFLite\n LOGGER.info(f'Loading {w} for TensorFlow Lite inference...')\n interpreter = 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 # load metadata\n with contextlib.suppress(zipfile.BadZipFile):\n with zipfile.ZipFile(w, \"r\") as model:\n meta_file = model.namelist()[0]\n meta = ast.literal_eval(model.read(meta_file).decode(\"utf-8\"))\n stride, names = int(meta['stride']), meta['names']\n elif tfjs: # TF.js\n raise NotImplementedError('ERROR: YOLOv5 TF.js inference is not supported')\n elif paddle: # PaddlePaddle\n LOGGER.info(f'Loading {w} for PaddlePaddle inference...')\n check_requirements('paddlepaddle-gpu' if cuda else 'paddlepaddle')\n import paddle.inference as pdi\n if not Path(w).is_file(): # if not *.pdmodel\n w = next(Path(w).rglob('*.pdmodel')) # get *.pdmodel file from *_paddle_model dir\n weights = Path(w).with_suffix('.pdiparams')\n config = pdi.Config(str(w), str(weights))\n if cuda:\n config.enable_use_gpu(memory_pool_init_size_mb=2048, device_id=0)\n predictor = pdi.create_predictor(config)\n input_handle = predictor.get_input_handle(predictor.get_input_names()[0])\n output_names = predictor.get_output_names()\n elif triton: # NVIDIA Triton Inference Server\n LOGGER.info(f'Using {w} as Triton Inference Server...')\n check_requirements('tritonclient[all]')\n from utils.triton import TritonRemoteModel\n model = TritonRemoteModel(url=w)\n nhwc = model.runtime.startswith(\"tensorflow\")\n else:\n raise NotImplementedError(f'ERROR: {w} is not a supported format')\n\n # class names\n if 'names' not in locals():\n names = yaml_load(data)['names'] if data else {i: f'class{i}' for i in range(999)}\n if names[0] == 'n01440764' and len(names) == 1000: # ImageNet\n names = yaml_load(ROOT / 'data/ImageNet.yaml')['names'] # human-readable names\n\n self.__dict__.update(locals()) # assign all variables to self\n\n def forward(self, im, augment=False, visualize=False):\n # YOLOv5 MultiBackend inference\n b, ch, h, w = im.shape # batch, channel, height, width\n if self.fp16 and im.dtype != torch.float16:\n im = im.half() # to FP16\n if self.nhwc:\n im = im.permute(0, 2, 3, 1) # torch BCHW to numpy BHWC shape(1,320,192,3)\n\n if self.pt: # PyTorch\n y = self.model(im, augment=augment, visualize=visualize) if augment or visualize else self.model(im)\n elif self.jit: # TorchScript\n y = self.model(im)\n elif self.dnn: # ONNX OpenCV DNN\n im = im.cpu().numpy() # torch to numpy\n self.net.setInput(im)\n y = self.net.forward()\n elif self.onnx: # ONNX Runtime\n im = im.cpu().numpy() # torch to numpy\n y = self.session.run(self.output_names, {self.session.get_inputs()[0].name: im})\n elif self.xml: # OpenVINO\n im = im.cpu().numpy() # FP32\n y = list(self.executable_network([im]).values())\n elif self.engine: # TensorRT\n if self.dynamic and im.shape != self.bindings['images'].shape:\n i = self.model.get_binding_index('images')\n self.context.set_binding_shape(i, im.shape) # reshape if dynamic\n self.bindings['images'] = self.bindings['images']._replace(shape=im.shape)\n for name in self.output_names:\n i = self.model.get_binding_index(name)\n self.bindings[name].data.resize_(tuple(self.context.get_binding_shape(i)))\n s = self.bindings['images'].shape\n assert im.shape == s, f\"input size {im.shape} {'>' if self.dynamic else 'not equal to'} max model size {s}\"\n self.binding_addrs['images'] = int(im.data_ptr())\n self.context.execute_v2(list(self.binding_addrs.values()))\n y = [self.bindings[x].data for x in sorted(self.output_names)]\n elif self.coreml: # CoreML\n im = im.cpu().numpy()\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 if 'confidence' in y:\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 else:\n y = list(reversed(y.values())) # reversed for segmentation models (pred, proto)\n elif self.paddle: # PaddlePaddle\n im = im.cpu().numpy().astype(np.float32)\n self.input_handle.copy_from_cpu(im)\n self.predictor.run()\n y = [self.predictor.get_output_handle(x).copy_to_cpu() for x in self.output_names]\n elif self.triton: # NVIDIA Triton Inference Server\n y = self.model(im)\n else: # TensorFlow (SavedModel, GraphDef, Lite, Edge TPU)\n im = im.cpu().numpy()\n if self.saved_model: # SavedModel\n y = self.model(im, training=False) if self.keras else self.model(im)\n elif self.pb: # GraphDef\n y = self.frozen_func(x=self.tf.constant(im))\n else: # Lite or Edge TPU\n input = self.input_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 = []\n for output in self.output_details:\n x = self.interpreter.get_tensor(output['index'])\n if int8:\n scale, zero_point = output['quantization']\n x = (x.astype(np.float32) - zero_point) * scale # re-scale\n y.append(x)\n y = [x if isinstance(x, np.ndarray) else x.numpy() for x in y]\n y[0][..., :4] *= [w, h, w, h] # xywh normalized to pixels\n\n if isinstance(y, (list, tuple)):\n return self.from_numpy(y[0]) if len(y) == 1 else [self.from_numpy(x) for x in y]\n else:\n return self.from_numpy(y)\n\n def from_numpy(self, x):\n return torch.from_numpy(x).to(self.device) if isinstance(x, np.ndarray) else x\n\n def warmup(self, imgsz=(1, 3, 640, 640)):\n # Warmup model by running inference once\n warmup_types = self.pt, self.jit, self.onnx, self.engine, self.saved_model, self.pb, self.triton\n if any(warmup_types) and (self.device.type != 'cpu' or self.triton):\n im = torch.empty(*imgsz, dtype=torch.half if self.fp16 else torch.float, device=self.device) # input\n for _ in range(2 if self.jit else 1): #\n self.forward(im) # warmup\n\n @staticmethod\n def _model_type(p='path/to/model.pt'):\n # Return model type from model path, i.e. path='path/to/model.onnx' -> type=onnx\n # types = [pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle]\n from export import export_formats\n from utils.downloads import is_url\n sf = list(export_formats().Suffix) # export suffixes\n if not is_url(p, check=False):\n check_suffix(p, sf) # checks\n url = urlparse(p) # if url may be Triton inference server\n types = [s in Path(p).name for s in sf]\n types[8] &= not types[9] # tflite &= not edgetpu\n triton = not any(types) and all([any(s in url.scheme for s in [\"http\", \"grpc\"]), url.netloc])\n return types + [triton]\n\n @staticmethod\n def _load_metadata(f=Path('path/to/meta.yaml')):\n # Load metadata from meta.yaml if it exists\n if f.exists():\n d = yaml_load(f)\n return d['stride'], d['names'] # assign stride, names\n return None, None"},{"identifier":"SegmentationModel","path":"models/yolo.py","snippet":"class SegmentationModel(DetectionModel):\n # YOLOv5 segmentation model\n def __init__(self, cfg='yolov5s-seg.yaml', ch=3, nc=None, anchors=None):\n super().__init__(cfg, ch, nc, anchors)"},{"identifier":"Callbacks","path":"utils/callbacks.py","snippet":"class Callbacks:\n \"\"\"\"\n Handles all registered callbacks for YOLOv5 Hooks\n \"\"\"\n\n def __init__(self):\n # Define the available callbacks\n self._callbacks = {\n 'on_pretrain_routine_start': [],\n 'on_pretrain_routine_end': [],\n 'on_train_start': [],\n 'on_train_epoch_start': [],\n 'on_train_batch_start': [],\n 'optimizer_step': [],\n 'on_before_zero_grad': [],\n 'on_train_batch_end': [],\n 'on_train_epoch_end': [],\n 'on_val_start': [],\n 'on_val_batch_start': [],\n 'on_val_image_end': [],\n 'on_val_batch_end': [],\n 'on_val_end': [],\n 'on_fit_epoch_end': [], # fit = train + val\n 'on_model_save': [],\n 'on_train_end': [],\n 'on_params_update': [],\n 'teardown': [],}\n self.stop_training = False # set True to interrupt training\n\n def register_action(self, hook, name='', callback=None):\n \"\"\"\n Register a new action to a callback hook\n\n Args:\n hook: The callback hook name to register the action to\n name: The name of the action for later reference\n callback: The callback to fire\n \"\"\"\n assert hook in self._callbacks, f\"hook '{hook}' not found in callbacks {self._callbacks}\"\n assert callable(callback), f\"callback '{callback}' is not callable\"\n self._callbacks[hook].append({'name': name, 'callback': callback})\n\n def get_registered_actions(self, hook=None):\n \"\"\"\"\n Returns all the registered actions by callback hook\n\n Args:\n hook: The name of the hook to check, defaults to all\n \"\"\"\n return self._callbacks[hook] if hook else self._callbacks\n\n def run(self, hook, *args, thread=False, **kwargs):\n \"\"\"\n Loop through the registered actions and fire all callbacks on main thread\n\n Args:\n hook: The name of the hook to check, defaults to all\n args: Arguments to receive from YOLOv5\n thread: (boolean) Run callbacks in daemon thread\n kwargs: Keyword Arguments to receive from YOLOv5\n \"\"\"\n\n assert hook in self._callbacks, f\"hook '{hook}' not found in callbacks {self._callbacks}\"\n for logger in self._callbacks[hook]:\n if thread:\n threading.Thread(target=logger['callback'], args=args, kwargs=kwargs, daemon=True).start()\n else:\n logger['callback'](*args, **kwargs)"},{"identifier":"LOGGER","path":"utils/general.py","snippet":"LOGGER = logging.getLogger(LOGGING_NAME) # define globally (used in train.py, val.py, detect.py, etc.)"},{"identifier":"NUM_THREADS","path":"utils/general.py","snippet":"NUM_THREADS = min(8, max(1, os.cpu_count() - 1)) # number of YOLOv5 multiprocessing threads"},{"identifier":"TQDM_BAR_FORMAT","path":"utils/general.py","snippet":"TQDM_BAR_FORMAT = '{l_bar}{bar:10}| {n_fmt}/{total_fmt} {elapsed}' # tqdm bar format"},{"identifier":"Profile","path":"utils/general.py","snippet":"class Profile(contextlib.ContextDecorator):\n # YOLOv5 Profile class. Usage: @Profile() decorator or 'with Profile():' context manager\n def __init__(self, t=0.0):\n self.t = t\n self.cuda = torch.cuda.is_available()\n\n def __enter__(self):\n self.start = self.time()\n return self\n\n def __exit__(self, type, value, traceback):\n self.dt = self.time() - self.start # delta-time\n self.t += self.dt # accumulate dt\n\n def time(self):\n if self.cuda:\n torch.cuda.synchronize()\n return time.time()"},{"identifier":"check_dataset","path":"utils/general.py","snippet":"def check_dataset(data, autodownload=True):\n # Download, check and/or unzip dataset if not found locally\n\n # Download (optional)\n extract_dir = ''\n if isinstance(data, (str, Path)) and (is_zipfile(data) or is_tarfile(data)):\n download(data, dir=f'{DATASETS_DIR}/{Path(data).stem}', unzip=True, delete=False, curl=False, threads=1)\n data = next((DATASETS_DIR / Path(data).stem).rglob('*.yaml'))\n extract_dir, autodownload = data.parent, False\n\n # Read yaml (optional)\n if isinstance(data, (str, Path)):\n data = yaml_load(data) # dictionary\n\n # Checks\n for k in 'train', 'val', 'names':\n assert k in data, emojis(f\"data.yaml '{k}:' field missing ❌\")\n if isinstance(data['names'], (list, tuple)): # old array format\n data['names'] = dict(enumerate(data['names'])) # convert to dict\n assert all(isinstance(k, int) for k in data['names'].keys()), 'data.yaml names keys must be integers, i.e. 2: car'\n data['nc'] = len(data['names'])\n\n # Resolve paths\n path = Path(extract_dir or data.get('path') or '') # optional 'path' default to '.'\n if not path.is_absolute():\n path = (ROOT / path).resolve()\n data['path'] = path # download scripts\n for k in 'train', 'val', 'test':\n if data.get(k): # prepend path\n if isinstance(data[k], str):\n x = (path / data[k]).resolve()\n if not x.exists() and data[k].startswith('../'):\n x = (path / data[k][3:]).resolve()\n data[k] = str(x)\n else:\n data[k] = [str((path / x).resolve()) for x in data[k]]\n\n # Parse yaml\n train, val, test, s = (data.get(x) for x in ('train', 'val', 'test', 'download'))\n if val:\n val = [Path(x).resolve() for x in (val if isinstance(val, list) else [val])] # val path\n if not all(x.exists() for x in val):\n LOGGER.info('\\nDataset not found ⚠️, missing paths %s' % [str(x) for x in val if not x.exists()])\n if not s or not autodownload:\n raise Exception('Dataset not found ❌')\n t = time.time()\n if s.startswith('http') and s.endswith('.zip'): # URL\n f = Path(s).name # filename\n LOGGER.info(f'Downloading {s} to {f}...')\n torch.hub.download_url_to_file(s, f)\n Path(DATASETS_DIR).mkdir(parents=True, exist_ok=True) # create root\n unzip_file(f, path=DATASETS_DIR) # unzip\n Path(f).unlink() # remove zip\n r = None # success\n elif s.startswith('bash '): # bash script\n LOGGER.info(f'Running {s} ...')\n r = os.system(s)\n else: # python script\n r = exec(s, {'yaml': data}) # return None\n dt = f'({round(time.time() - t, 1)}s)'\n s = f\"success ✅ {dt}, saved to {colorstr('bold', DATASETS_DIR)}\" if r in (0, None) else f\"failure {dt} ❌\"\n LOGGER.info(f\"Dataset download {s}\")\n check_font('Arial.ttf' if is_ascii(data['names']) else 'Arial.Unicode.ttf', progress=True) # download fonts\n return data # dictionary"},{"identifier":"check_img_size","path":"utils/general.py","snippet":"def check_img_size(imgsz, s=32, floor=0):\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 imgsz = list(imgsz) # convert to list if tuple\n new_size = [max(make_divisible(x, int(s)), floor) for x in imgsz]\n if new_size != imgsz:\n LOGGER.warning(f'WARNING ⚠️ --img-size {imgsz} must be multiple of max stride {s}, updating to {new_size}')\n return new_size"},{"identifier":"check_requirements","path":"utils/general.py","snippet":"@TryExcept()\ndef check_requirements(requirements=ROOT / 'requirements.txt', exclude=(), install=True, cmds=''):\n # Check installed dependencies meet YOLOv5 requirements (pass *.txt file or list of packages or single package str)\n prefix = colorstr('red', 'bold', 'requirements:')\n check_python() # check python version\n if isinstance(requirements, Path): # requirements.txt file\n file = requirements.resolve()\n assert file.exists(), f\"{prefix} {file} 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 elif isinstance(requirements, str):\n requirements = [requirements]\n\n s = ''\n n = 0\n for r in requirements:\n try:\n pkg.require(r)\n except (pkg.VersionConflict, pkg.DistributionNotFound): # exception if requirements not met\n s += f'\"{r}\" '\n n += 1\n\n if s and install and AUTOINSTALL: # check environment variable\n LOGGER.info(f\"{prefix} YOLOv5 requirement{'s' * (n > 1)} {s}not found, attempting AutoUpdate...\")\n try:\n # assert check_online(), \"AutoUpdate skipped (offline)\"\n LOGGER.info(check_output(f'pip install {s} {cmds}', shell=True).decode())\n source = file 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 LOGGER.info(s)\n except Exception as e:\n LOGGER.warning(f'{prefix} ❌ {e}')"},{"identifier":"check_yaml","path":"utils/general.py","snippet":"def check_yaml(file, suffix=('.yaml', '.yml')):\n # Search/download YAML file (if necessary) and return path, checking suffix\n return check_file(file, suffix)"},{"identifier":"coco80_to_coco91_class","path":"utils/general.py","snippet":"def coco80_to_coco91_class(): # converts 80-index (val2014) to 91-index (paper)\n # https://tech.amikelive.com/node-718/what-object-categories-labels-are-in-coco-dataset/\n # a = np.loadtxt('data/coco.names', dtype='str', delimiter='\\n')\n # b = np.loadtxt('data/coco_paper.names', dtype='str', delimiter='\\n')\n # x1 = [list(a[i] == b).index(True) + 1 for i in range(80)] # darknet to coco\n # x2 = [list(b[i] == a).index(True) if any(b[i] == a) else None for i in range(91)] # coco to darknet\n return [\n 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 28, 31, 32, 33, 34,\n 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\n 64, 65, 67, 70, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 89, 90]"},{"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 = {\n '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\n # Method 1\n for n in range(2, 9999):\n p = f'{path}{sep}{n}{suffix}' # increment path\n if not os.path.exists(p): #\n break\n path = Path(p)\n\n # Method 2 (deprecated)\n # dirs = glob.glob(f\"{path}{sep}*\") # similar paths\n # matches = [re.search(rf\"{path.stem}{sep}(\\d+)\", 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\n if mkdir:\n path.mkdir(parents=True, exist_ok=True) # make directory\n\n return path"},{"identifier":"non_max_suppression","path":"utils/general.py","snippet":"def non_max_suppression(\n prediction,\n conf_thres=0.25,\n iou_thres=0.45,\n classes=None,\n agnostic=False,\n multi_label=False,\n labels=(),\n max_det=300,\n nm=0, # number of masks\n):\n \"\"\"Non-Maximum Suppression (NMS) on inference results to reject overlapping detections\n\n Returns:\n list of detections, on (n,6) tensor per image [xyxy, conf, cls]\n \"\"\"\n\n if isinstance(prediction, (list, tuple)): # YOLOv5 model in validation model, output = (inference_out, loss_out)\n prediction = prediction[0] # select only inference output\n\n device = prediction.device\n mps = 'mps' in device.type # Apple MPS\n if mps: # MPS not fully supported yet, convert tensors to CPU before NMS\n prediction = prediction.cpu()\n bs = prediction.shape[0] # batch size\n nc = prediction.shape[2] - nm - 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 = 2 # (pixels) minimum box width and height\n max_wh = 7680 # (pixels) maximum box width and height\n max_nms = 30000 # maximum number of boxes into torchvision.ops.nms()\n time_limit = 0.5 + 0.05 * bs # 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 mi = 5 + nc # mask start index\n output = [torch.zeros((0, 6 + nm), device=prediction.device)] * bs\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 lb = labels[xi]\n v = torch.zeros((len(lb), nc + nm + 5), device=x.device)\n v[:, :4] = lb[:, 1:5] # box\n v[:, 4] = 1.0 # conf\n v[range(len(lb)), lb[:, 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/Mask\n box = xywh2xyxy(x[:, :4]) # center_x, center_y, width, height) to (x1, y1, x2, y2)\n mask = x[:, mi:] # zero columns if no masks\n\n # Detections matrix nx6 (xyxy, conf, cls)\n if multi_label:\n i, j = (x[:, 5:mi] > conf_thres).nonzero(as_tuple=False).T\n x = torch.cat((box[i], x[i, 5 + j, None], j[:, None].float(), mask[i]), 1)\n else: # best class only\n conf, j = x[:, 5:mi].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float(), mask), 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 else:\n x = x[x[:, 4].argsort(descending=True)] # 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 #i = my_soft_nms(boxes, scores, iou_thres) \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 mps:\n output[xi] = output[xi].to(device)\n if (time.time() - t) > time_limit:\n LOGGER.warning(f'WARNING ⚠️ NMS time limit {time_limit:.3f}s exceeded')\n break # time limit exceeded\n\n return output"},{"identifier":"print_args","path":"utils/general.py","snippet":"def print_args(args: Optional[dict] = None, show_file=True, show_func=False):\n # Print function arguments (optional args dict)\n x = inspect.currentframe().f_back # previous frame\n file, _, func, _, _ = inspect.getframeinfo(x)\n if args is None: # get args automatically\n args, _, _, frm = inspect.getargvalues(x)\n args = {k: v for k, v in frm.items() if k in args}\n try:\n file = Path(file).resolve().relative_to(ROOT).with_suffix('')\n except ValueError:\n file = Path(file).stem\n s = (f'{file}: ' if show_file else '') + (f'{func}: ' if show_func else '')\n LOGGER.info(colorstr(s) + ', '.join(f'{k}={v}' for k, v in args.items()))"},{"identifier":"scale_boxes","path":"utils/general.py","snippet":"def scale_boxes(img1_shape, boxes, img0_shape, ratio_pad=None):\n # Rescale boxes (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 boxes[:, [0, 2]] -= pad[0] # x padding\n boxes[:, [1, 3]] -= pad[1] # y padding\n boxes[:, :4] /= gain\n clip_boxes(boxes, img0_shape)\n return boxes"},{"identifier":"xywh2xyxy","path":"utils/general.py","snippet":"def xywh2xyxy(x):\n # Convert nx4 boxes from [x, y, w, h] to [x1, y1, x2, y2] 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 # top left x\n y[:, 1] = x[:, 1] - x[:, 3] / 2 # top left y\n y[:, 2] = x[:, 0] + x[:, 2] / 2 # bottom right x\n y[:, 3] = x[:, 1] + x[:, 3] / 2 # bottom right y\n return y"},{"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":"ConfusionMatrix","path":"utils/metrics.py","snippet":"class ConfusionMatrix:\n # Updated version of https://github.com/kaanakan/object_detection_confusion_matrix\n def __init__(self, nc, conf=0.25, iou_thres=0.45):\n self.matrix = np.zeros((nc + 1, nc + 1))\n self.nc = nc # number of classes\n self.conf = conf\n self.iou_thres = iou_thres\n\n def process_batch(self, detections, labels):\n \"\"\"\n Return intersection-over-union (Jaccard index) of boxes.\n Both sets of boxes are expected to be in (x1, y1, x2, y2) format.\n Arguments:\n detections (Array[N, 6]), x1, y1, x2, y2, conf, class\n labels (Array[M, 5]), class, x1, y1, x2, y2\n Returns:\n None, updates confusion matrix accordingly\n \"\"\"\n if detections is None:\n gt_classes = labels.int()\n for gc in gt_classes:\n self.matrix[self.nc, gc] += 1 # background FN\n return\n\n detections = detections[detections[:, 4] > self.conf]\n gt_classes = labels[:, 0].int()\n detection_classes = detections[:, 5].int()\n iou = box_iou(labels[:, 1:], detections[:, :4])\n\n x = torch.where(iou > self.iou_thres)\n if x[0].shape[0]:\n matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy()\n if x[0].shape[0] > 1:\n matches = matches[matches[:, 2].argsort()[::-1]]\n matches = matches[np.unique(matches[:, 1], return_index=True)[1]]\n matches = matches[matches[:, 2].argsort()[::-1]]\n matches = matches[np.unique(matches[:, 0], return_index=True)[1]]\n else:\n matches = np.zeros((0, 3))\n\n n = matches.shape[0] > 0\n m0, m1, _ = matches.transpose().astype(int)\n for i, gc in enumerate(gt_classes):\n j = m0 == i\n if n and sum(j) == 1:\n self.matrix[detection_classes[m1[j]], gc] += 1 # correct\n else:\n self.matrix[self.nc, gc] += 1 # true background\n\n if n:\n for i, dc in enumerate(detection_classes):\n if not any(m1 == i):\n self.matrix[dc, self.nc] += 1 # predicted background\n\n def tp_fp(self):\n tp = self.matrix.diagonal() # true positives\n fp = self.matrix.sum(1) - tp # false positives\n # fn = self.matrix.sum(0) - tp # false negatives (missed detections)\n return tp[:-1], fp[:-1] # remove background class\n\n @TryExcept('WARNING ⚠️ ConfusionMatrix plot failure')\n def plot(self, normalize=True, save_dir='', names=()):\n import seaborn as sn\n\n array = self.matrix / ((self.matrix.sum(0).reshape(1, -1) + 1E-9) if normalize else 1) # normalize columns\n array[array < 0.005] = np.nan # don't annotate (would appear as 0.00)\n\n fig, ax = plt.subplots(1, 1, figsize=(12, 9), tight_layout=True)\n nc, nn = self.nc, len(names) # number of classes, names\n sn.set(font_scale=1.0 if nc < 50 else 0.8) # for label size\n labels = (0 < nn < 99) and (nn == nc) # apply names to ticklabels\n ticklabels = (names + ['background']) if labels else \"auto\"\n with warnings.catch_warnings():\n warnings.simplefilter('ignore') # suppress empty matrix RuntimeWarning: All-NaN slice encountered\n sn.heatmap(array,\n ax=ax,\n annot=nc < 30,\n annot_kws={\n \"size\": 8},\n cmap='Blues',\n fmt='.2f',\n square=True,\n vmin=0.0,\n xticklabels=ticklabels,\n yticklabels=ticklabels).set_facecolor((1, 1, 1))\n ax.set_ylabel('True')\n ax.set_ylabel('Predicted')\n ax.set_title('Confusion Matrix')\n fig.savefig(Path(save_dir) / 'confusion_matrix.png', dpi=250)\n plt.close(fig)\n\n def print(self):\n for i in range(self.nc + 1):\n print(' '.join(map(str, self.matrix[i])))"},{"identifier":"box_iou","path":"utils/metrics.py","snippet":"def box_iou(box1, box2, eps=1e-7):\n # https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py\n \"\"\"\n Return intersection-over-union (Jaccard index) of boxes.\n Both sets of boxes are expected to be in (x1, y1, x2, y2) format.\n Arguments:\n box1 (Tensor[N, 4])\n box2 (Tensor[M, 4])\n Returns:\n iou (Tensor[N, M]): the NxM matrix containing the pairwise\n IoU values for every element in boxes1 and boxes2\n \"\"\"\n\n # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)\n (a1, a2), (b1, b2) = box1.unsqueeze(1).chunk(2, 2), box2.unsqueeze(0).chunk(2, 2)\n inter = (torch.min(a2, b2) - torch.max(a1, b1)).clamp(0).prod(2)\n\n # IoU = inter / (area1 + area2 - inter)\n return inter / ((a2 - a1).prod(2) + (b2 - b1).prod(2) - inter + eps)"},{"identifier":"output_to_target","path":"utils/plots.py","snippet":"def output_to_target(output, max_det=300):\n # Convert model output to target format [batch_id, class_id, x, y, w, h, conf] for plotting\n targets = []\n for i, o in enumerate(output):\n box, conf, cls = o[:max_det, :6].cpu().split((4, 1, 1), 1)\n j = torch.full((conf.shape[0], 1), i)\n targets.append(torch.cat((j, cls, xyxy2xywh(box), conf), 1))\n return torch.cat(targets, 0).numpy()"},{"identifier":"plot_val_study","path":"utils/plots.py","snippet":"def plot_val_study(file='', dir='', x=None): # from utils.plots import *; plot_val_study()\n # Plot file=study.txt generated by val.py (or plot all study*.txt in dir)\n save_dir = Path(file).parent if file else Path(dir)\n plot2 = False # plot additional results\n if plot2:\n ax = plt.subplots(2, 4, figsize=(10, 6), tight_layout=True)[1].ravel()\n\n fig2, ax2 = plt.subplots(1, 1, figsize=(8, 4), tight_layout=True)\n # for f in [save_dir / f'study_coco_{x}.txt' for x in ['yolov5n6', 'yolov5s6', 'yolov5m6', 'yolov5l6', 'yolov5x6']]:\n for f in sorted(save_dir.glob('study*.txt')):\n y = np.loadtxt(f, dtype=np.float32, usecols=[0, 1, 2, 3, 7, 8, 9], ndmin=2).T\n x = np.arange(y.shape[1]) if x is None else np.array(x)\n if plot2:\n s = ['P', 'R', 'mAP@.5', 'mAP@.5:.95', 't_preprocess (ms/img)', 't_inference (ms/img)', 't_NMS (ms/img)']\n for i in range(7):\n ax[i].plot(x, y[i], '.-', linewidth=2, markersize=8)\n ax[i].set_title(s[i])\n\n j = y[3].argmax() + 1\n ax2.plot(y[5, 1:j],\n y[3, 1:j] * 1E2,\n '.-',\n linewidth=2,\n markersize=8,\n label=f.stem.replace('study_coco_', '').replace('yolo', 'YOLO'))\n\n ax2.plot(1E3 / np.array([209, 140, 97, 58, 35, 18]), [34.6, 40.5, 43.0, 47.5, 49.7, 51.5],\n 'k.-',\n linewidth=2,\n markersize=8,\n alpha=.25,\n label='EfficientDet')\n\n ax2.grid(alpha=0.2)\n ax2.set_yticks(np.arange(20, 60, 5))\n ax2.set_xlim(0, 57)\n ax2.set_ylim(25, 55)\n ax2.set_xlabel('GPU Speed (ms/img)')\n ax2.set_ylabel('COCO AP val')\n ax2.legend(loc='lower right')\n f = save_dir / 'study.png'\n print(f'Saving {f}...')\n plt.savefig(f, dpi=300)"},{"identifier":"create_dataloader","path":"utils/segment/dataloaders.py","snippet":"def create_dataloader(path,\n imgsz,\n batch_size,\n stride,\n single_cls=False,\n hyp=None,\n augment=False,\n cache=False,\n pad=0.0,\n rect=False,\n rank=-1,\n workers=8,\n image_weights=False,\n quad=False,\n prefix='',\n shuffle=False,\n mask_downsample_ratio=1,\n overlap_mask=False):\n if rect and shuffle:\n LOGGER.warning('WARNING ⚠️ --rect is incompatible with DataLoader shuffle, setting shuffle=False')\n shuffle = False\n with torch_distributed_zero_first(rank): # init dataset *.cache only once if DDP\n dataset = LoadImagesAndLabelsAndMasks(\n path,\n imgsz,\n batch_size,\n augment=augment, # augmentation\n hyp=hyp, # hyperparameters\n rect=rect, # rectangular batches\n cache_images=cache,\n single_cls=single_cls,\n stride=int(stride),\n pad=pad,\n image_weights=image_weights,\n prefix=prefix,\n downsample_ratio=mask_downsample_ratio,\n overlap=overlap_mask)\n\n batch_size = min(batch_size, len(dataset))\n nd = torch.cuda.device_count() # number of CUDA devices\n nw = min([os.cpu_count() // max(nd, 1), batch_size if batch_size > 1 else 0, workers]) # number of workers\n sampler = None if rank == -1 else distributed.DistributedSampler(dataset, shuffle=shuffle)\n loader = DataLoader if image_weights else InfiniteDataLoader # only DataLoader allows for attribute updates\n generator = torch.Generator()\n generator.manual_seed(6148914691236517205 + RANK)\n return loader(\n dataset,\n batch_size=batch_size,\n shuffle=shuffle and sampler is None,\n num_workers=nw,\n sampler=sampler,\n pin_memory=True,\n collate_fn=LoadImagesAndLabelsAndMasks.collate_fn4 if quad else LoadImagesAndLabelsAndMasks.collate_fn,\n worker_init_fn=seed_worker,\n generator=generator,\n ), dataset"},{"identifier":"mask_iou","path":"utils/segment/general.py","snippet":"def mask_iou(mask1, mask2, eps=1e-7):\n \"\"\"\n mask1: [N, n] m1 means number of predicted objects\n mask2: [M, n] m2 means number of gt objects\n Note: n means image_w x image_h\n\n return: masks iou, [N, M]\n \"\"\"\n intersection = torch.matmul(mask1, mask2.t()).clamp(0)\n union = (mask1.sum(1)[:, None] + mask2.sum(1)[None]) - intersection # (area1 + area2) - intersection\n return intersection / (union + eps)"},{"identifier":"process_mask","path":"utils/segment/general.py","snippet":"def process_mask(protos, masks_in, bboxes, shape, upsample=False):\n \"\"\"\n Crop before upsample.\n proto_out: [mask_dim, mask_h, mask_w]\n out_masks: [n, mask_dim], n is number of masks after nms\n bboxes: [n, 4], n is number of masks after nms\n shape:input_image_size, (h, w)\n\n return: h, w, n\n \"\"\"\n\n c, mh, mw = protos.shape # CHW\n ih, iw = shape\n masks = (masks_in @ protos.float().view(c, -1)).sigmoid().view(-1, mh, mw) # CHW\n\n downsampled_bboxes = bboxes.clone()\n downsampled_bboxes[:, 0] *= mw / iw\n downsampled_bboxes[:, 2] *= mw / iw\n downsampled_bboxes[:, 3] *= mh / ih\n downsampled_bboxes[:, 1] *= mh / ih\n\n masks = crop_mask(masks, downsampled_bboxes) # CHW\n if upsample:\n masks = F.interpolate(masks[None], shape, mode='bilinear', align_corners=False)[0] # CHW\n return masks.gt_(0.5)"},{"identifier":"process_mask_upsample","path":"utils/segment/general.py","snippet":"def process_mask_upsample(protos, masks_in, bboxes, shape):\n \"\"\"\n Crop after upsample.\n proto_out: [mask_dim, mask_h, mask_w]\n out_masks: [n, mask_dim], n is number of masks after nms\n bboxes: [n, 4], n is number of masks after nms\n shape:input_image_size, (h, w)\n\n return: h, w, n\n \"\"\"\n\n c, mh, mw = protos.shape # CHW\n masks = (masks_in @ protos.float().view(c, -1)).sigmoid().view(-1, mh, mw)\n masks = F.interpolate(masks[None], shape, mode='bilinear', align_corners=False)[0] # CHW\n masks = crop_mask(masks, bboxes) # CHW\n return masks.gt_(0.5)"},{"identifier":"scale_image","path":"utils/segment/general.py","snippet":"def scale_image(im1_shape, masks, im0_shape, ratio_pad=None):\n \"\"\"\n img1_shape: model input shape, [h, w]\n img0_shape: origin pic shape, [h, w, 3]\n masks: [h, w, num]\n \"\"\"\n # Rescale coordinates (xyxy) from im1_shape to im0_shape\n if ratio_pad is None: # calculate from im0_shape\n gain = min(im1_shape[0] / im0_shape[0], im1_shape[1] / im0_shape[1]) # gain = old / new\n pad = (im1_shape[1] - im0_shape[1] * gain) / 2, (im1_shape[0] - im0_shape[0] * gain) / 2 # wh padding\n else:\n pad = ratio_pad[1]\n top, left = int(pad[1]), int(pad[0]) # y, x\n bottom, right = int(im1_shape[0] - pad[1]), int(im1_shape[1] - pad[0])\n\n if len(masks.shape) < 2:\n raise ValueError(f'\"len of masks shape\" should be 2 or 3, but got {len(masks.shape)}')\n masks = masks[top:bottom, left:right]\n # masks = masks.permute(2, 0, 1).contiguous()\n # masks = F.interpolate(masks[None], im0_shape[:2], mode='bilinear', align_corners=False)[0]\n # masks = masks.permute(1, 2, 0).contiguous()\n masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]))\n\n if len(masks.shape) == 2:\n masks = masks[:, :, None]\n return masks"},{"identifier":"Metrics","path":"utils/segment/metrics.py","snippet":"class Metrics:\n \"\"\"Metric for boxes and masks.\"\"\"\n\n def __init__(self) -> None:\n self.metric_box = Metric()\n self.metric_mask = Metric()\n\n def update(self, results):\n \"\"\"\n Args:\n results: Dict{'boxes': Dict{}, 'masks': Dict{}}\n \"\"\"\n self.metric_box.update(list(results[\"boxes\"].values()))\n self.metric_mask.update(list(results[\"masks\"].values()))\n\n def mean_results(self):\n return self.metric_box.mean_results() + self.metric_mask.mean_results()\n\n def class_result(self, i):\n return self.metric_box.class_result(i) + self.metric_mask.class_result(i)\n\n def get_maps(self, nc):\n return self.metric_box.get_maps(nc) + self.metric_mask.get_maps(nc)\n\n @property\n def ap_class_index(self):\n # boxes and masks have the same ap_class_index\n return self.metric_box.ap_class_index"},{"identifier":"ap_per_class_box_and_mask","path":"utils/segment/metrics.py","snippet":"def ap_per_class_box_and_mask(\n tp_m,\n tp_b,\n conf,\n pred_cls,\n target_cls,\n plot=False,\n save_dir=\".\",\n names=(),\n):\n \"\"\"\n Args:\n tp_b: tp of boxes.\n tp_m: tp of masks.\n other arguments see `func: ap_per_class`.\n \"\"\"\n results_boxes = ap_per_class(tp_b,\n conf,\n pred_cls,\n target_cls,\n plot=plot,\n save_dir=save_dir,\n names=names,\n prefix=\"Box\")[2:]\n results_masks = ap_per_class(tp_m,\n conf,\n pred_cls,\n target_cls,\n plot=plot,\n save_dir=save_dir,\n names=names,\n prefix=\"Mask\")[2:]\n\n results = {\n \"boxes\": {\n \"p\": results_boxes[0],\n \"r\": results_boxes[1],\n \"ap\": results_boxes[3],\n \"f1\": results_boxes[2],\n \"ap_class\": results_boxes[4]},\n \"masks\": {\n \"p\": results_masks[0],\n \"r\": results_masks[1],\n \"ap\": results_masks[3],\n \"f1\": results_masks[2],\n \"ap_class\": results_masks[4]}}\n return results"},{"identifier":"plot_images_and_masks","path":"utils/segment/plots.py","snippet":"@threaded\ndef plot_images_and_masks(images, targets, masks, paths=None, fname='images.jpg', names=None):\n # Plot image grid with labels\n if isinstance(images, torch.Tensor):\n images = images.cpu().float().numpy()\n if isinstance(targets, torch.Tensor):\n targets = targets.cpu().numpy()\n if isinstance(masks, torch.Tensor):\n masks = masks.cpu().numpy().astype(int)\n\n max_size = 1920 # max image size\n max_subplots = 16 # max image subplots, i.e. 4x4\n bs, _, h, w = images.shape # batch size, _, height, width\n bs = min(bs, max_subplots) # limit plot images\n ns = np.ceil(bs ** 0.5) # number of subplots (square)\n if np.max(images[0]) <= 1:\n images *= 255 # de-normalise (optional)\n\n # Build Image\n mosaic = np.full((int(ns * h), int(ns * w), 3), 255, dtype=np.uint8) # init\n for i, im in enumerate(images):\n if i == max_subplots: # if last batch has fewer images than we expect\n break\n x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin\n im = im.transpose(1, 2, 0)\n mosaic[y:y + h, x:x + w, :] = im\n\n # Resize (optional)\n scale = max_size / ns / max(h, w)\n if scale < 1:\n h = math.ceil(scale * h)\n w = math.ceil(scale * w)\n mosaic = cv2.resize(mosaic, tuple(int(x * ns) for x in (w, h)))\n\n # Annotate\n fs = int((h + w) * ns * 0.01) # font size\n annotator = Annotator(mosaic, line_width=round(fs / 10), font_size=fs, pil=True, example=names)\n for i in range(i + 1):\n x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin\n annotator.rectangle([x, y, x + w, y + h], None, (255, 255, 255), width=2) # borders\n if paths:\n annotator.text((x + 5, y + 5 + h), text=Path(paths[i]).name[:40], txt_color=(220, 220, 220)) # filenames\n if len(targets) > 0:\n idx = targets[:, 0] == i\n ti = targets[idx] # image targets\n\n boxes = xywh2xyxy(ti[:, 2:6]).T\n classes = ti[:, 1].astype('int')\n labels = ti.shape[1] == 6 # labels if no conf column\n conf = None if labels else ti[:, 6] # check for confidence presence (label vs pred)\n\n if boxes.shape[1]:\n if boxes.max() <= 1.01: # if normalized with tolerance 0.01\n boxes[[0, 2]] *= w # scale to pixels\n boxes[[1, 3]] *= h\n elif scale < 1: # absolute coords need scale if image scales\n boxes *= scale\n boxes[[0, 2]] += x\n boxes[[1, 3]] += y\n for j, box in enumerate(boxes.T.tolist()):\n cls = classes[j]\n color = colors(cls)\n cls = names[cls] if names else cls\n if labels or conf[j] > 0.25: # 0.25 conf thresh\n label = f'{cls}' if labels else f'{cls} {conf[j]:.1f}'\n annotator.box_label(box, label, color=color)\n\n # Plot masks\n if len(masks):\n if masks.max() > 1.0: # mean that masks are overlap\n image_masks = masks[[i]] # (1, 640, 640)\n nl = len(ti)\n index = np.arange(nl).reshape(nl, 1, 1) + 1\n image_masks = np.repeat(image_masks, nl, axis=0)\n image_masks = np.where(image_masks == index, 1.0, 0.0)\n else:\n image_masks = masks[idx]\n\n im = np.asarray(annotator.im).copy()\n for j, box in enumerate(boxes.T.tolist()):\n if labels or conf[j] > 0.25: # 0.25 conf thresh\n color = colors(classes[j])\n mh, mw = image_masks[j].shape\n if mh != h or mw != w:\n mask = image_masks[j].astype(np.uint8)\n mask = cv2.resize(mask, (w, h))\n mask = mask.astype(bool)\n else:\n mask = image_masks[j].astype(bool)\n with contextlib.suppress(Exception):\n im[y:y + h, x:x + w, :][mask] = im[y:y + h, x:x + w, :][mask] * 0.4 + np.array(color) * 0.6\n annotator.fromarray(im)\n annotator.im.save(fname) # save"},{"identifier":"de_parallel","path":"utils/torch_utils.py","snippet":"def de_parallel(model):\n # De-parallelize a model: returns single-GPU model if model is of type DP or DDP\n return model.module if is_parallel(model) else model"},{"identifier":"select_device","path":"utils/torch_utils.py","snippet":"def select_device(device='', batch_size=0, newline=True):\n # device = None or 'cpu' or 0 or '0' or '0,1,2,3'\n s = f'YOLOv5 🚀 {git_describe() or file_date()} Python-{platform.python_version()} torch-{torch.__version__} '\n device = str(device).strip().lower().replace('cuda:', '').replace('none', '') # to string, 'cuda:0' to '0'\n cpu = device == 'cpu'\n mps = device == 'mps' # Apple Metal Performance Shaders (MPS)\n if cpu or mps:\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 - must be before assert is_available()\n assert torch.cuda.is_available() and torch.cuda.device_count() >= len(device.replace(',', '')), \\\n f\"Invalid CUDA '--device {device}' requested, use '--device cpu' or pass valid CUDA device(s)\"\n\n if not cpu and not mps and torch.cuda.is_available(): # prefer GPU if available\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 / (1 << 20):.0f}MiB)\\n\" # bytes to MB\n arg = 'cuda:0'\n elif mps and getattr(torch, 'has_mps', False) and torch.backends.mps.is_available(): # prefer MPS if available\n s += 'MPS\\n'\n arg = 'mps'\n else: # revert to CPU\n s += 'CPU\\n'\n arg = 'cpu'\n\n if not newline:\n s = s.rstrip()\n LOGGER.info(s)\n return torch.device(arg)"},{"identifier":"smart_inference_mode","path":"utils/torch_utils.py","snippet":"def smart_inference_mode(torch_1_9=check_version(torch.__version__, '1.9.0')):\n # Applies torch.inference_mode() decorator if torch>=1.9.0 else torch.no_grad() decorator\n def decorate(fn):\n return (torch.inference_mode if torch_1_9 else torch.no_grad)()(fn)\n\n return decorate"}],"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=torch.device('cpu'), dnn=False, data=None, fp16=False, fuse=True):\\n # Usage:\\n # PyTorch: weights = *.pt\\n # TorchScript: *.torchscript\\n # ONNX Runtime: *.onnx\\n # ONNX OpenCV DNN: *.onnx --dnn\\n # OpenVINO: *_openvino_model\\n # CoreML: *.mlmodel\\n # TensorRT: *.engine\\n # TensorFlow SavedModel: *_saved_model\\n # TensorFlow GraphDef: *.pb\\n # TensorFlow Lite: *.tflite\\n # TensorFlow Edge TPU: *_edgetpu.tflite\\n # PaddlePaddle: *_paddle_model\\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 pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle, triton = self._model_type(w)\\n fp16 &= pt or jit or onnx or engine # FP16\\n nhwc = coreml or saved_model or pb or tflite or edgetpu # BHWC formats (vs torch BCWH)\\n stride = 32 # default stride\\n cuda = torch.cuda.is_available() and device.type != 'cpu' # use CUDA\\n if not (pt or triton):\\n w = attempt_download(w) # download if not local\\n\\n if pt: # PyTorch\\n model = attempt_load(weights if isinstance(weights, list) else w, device=device, inplace=True, fuse=fuse)\\n stride = max(int(model.stride.max()), 32) # model stride\\n names = model.module.names if hasattr(model, 'module') else model.names # get class names\\n model.half() if fp16 else model.float()\\n self.model = model # explicitly assign for to(), cpu(), cuda(), half()\\n elif 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, map_location=device)\\n model.half() if fp16 else model.float()\\n if extra_files['config.txt']: # load metadata dict\\n d = json.loads(extra_files['config.txt'],\\n object_hook=lambda d: {int(k) if k.isdigit() else k: v\\n for k, v in d.items()})\\n stride, names = int(d['stride']), d['names']\\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 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 output_names = [x.name for x in session.get_outputs()]\\n meta = session.get_modelmeta().custom_metadata_map # metadata\\n if 'stride' in meta:\\n stride, names = int(meta['stride']), eval(meta['names'])\\n elif xml: # OpenVINO\\n LOGGER.info(f'Loading {w} for OpenVINO inference...')\\n check_requirements('openvino') # requires openvino-dev: https://pypi.org/project/openvino-dev/\\n from openvino.runtime import Core, Layout, get_batch\\n ie = Core()\\n if not Path(w).is_file(): # if not *.xml\\n w = next(Path(w).glob('*.xml')) # get *.xml file from *_openvino_model dir\\n network = ie.read_model(model=w, weights=Path(w).with_suffix('.bin'))\\n if network.get_parameters()[0].get_layout().empty:\\n network.get_parameters()[0].set_layout(Layout(\\\"NCHW\\\"))\\n batch_dim = get_batch(network)\\n if batch_dim.is_static:\\n batch_size = batch_dim.get_length()\\n executable_network = ie.compile_model(network, device_name=\\\"CPU\\\") # device_name=\\\"MYRIAD\\\" for Intel NCS2\\n stride, names = self._load_metadata(Path(w).with_suffix('.yaml')) # load metadata\\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__, '7.0.0', hard=True) # require tensorrt>=7.0.0\\n if device.type == 'cpu':\\n device = torch.device('cuda:0')\\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 context = model.create_execution_context()\\n bindings = OrderedDict()\\n output_names = []\\n fp16 = False # default updated below\\n dynamic = False\\n for i in range(model.num_bindings):\\n name = model.get_binding_name(i)\\n dtype = trt.nptype(model.get_binding_dtype(i))\\n if model.binding_is_input(i):\\n if -1 in tuple(model.get_binding_shape(i)): # dynamic\\n dynamic = True\\n context.set_binding_shape(i, tuple(model.get_profile_shape(0, i)[2]))\\n if dtype == np.float16:\\n fp16 = True\\n else: # output\\n output_names.append(name)\\n shape = tuple(context.get_binding_shape(i))\\n im = torch.from_numpy(np.empty(shape, dtype=dtype)).to(device)\\n bindings[name] = Binding(name, dtype, shape, im, int(im.data_ptr()))\\n binding_addrs = OrderedDict((n, d.ptr) for n, d in bindings.items())\\n batch_size = bindings['images'].shape[0] # if dynamic, this is instead max batch size\\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 saved_model: # TF SavedModel\\n LOGGER.info(f'Loading {w} for TensorFlow SavedModel inference...')\\n import tensorflow as tf\\n keras = False # assume TF1 saved_model\\n model = tf.keras.models.load_model(w) if keras else tf.saved_model.load(w)\\n elif pb: # GraphDef https://www.tensorflow.org/guide/migrate#a_graphpb_or_graphpbtxt\\n LOGGER.info(f'Loading {w} for TensorFlow GraphDef 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 ge = x.graph.as_graph_element\\n return x.prune(tf.nest.map_structure(ge, inputs), tf.nest.map_structure(ge, outputs))\\n\\n def gd_outputs(gd):\\n name_list, input_list = [], []\\n for node in gd.node: # tensorflow.core.framework.node_def_pb2.NodeDef\\n name_list.append(node.name)\\n input_list.extend(node.input)\\n return sorted(f'{x}:0' for x in list(set(name_list) - set(input_list)) if not x.startswith('NoOp'))\\n\\n gd = tf.Graph().as_graph_def() # TF GraphDef\\n with open(w, 'rb') as f:\\n gd.ParseFromString(f.read())\\n frozen_func = wrap_frozen_graph(gd, inputs=\\\"x:0\\\", outputs=gd_outputs(gd))\\n elif tflite or edgetpu: # https://www.tensorflow.org/lite/guide/python#install_tensorflow_lite_for_python\\n try: # https://coral.ai/docs/edgetpu/tflite-python/#update-existing-tf-lite-code-for-the-edge-tpu\\n from tflite_runtime.interpreter import Interpreter, load_delegate\\n except ImportError:\\n import tensorflow as tf\\n Interpreter, load_delegate = tf.lite.Interpreter, tf.lite.experimental.load_delegate,\\n if edgetpu: # TF Edge TPU https://coral.ai/software/#edgetpu-runtime\\n LOGGER.info(f'Loading {w} for TensorFlow Lite Edge TPU inference...')\\n delegate = {\\n 'Linux': 'libedgetpu.so.1',\\n 'Darwin': 'libedgetpu.1.dylib',\\n 'Windows': 'edgetpu.dll'}[platform.system()]\\n interpreter = Interpreter(model_path=w, experimental_delegates=[load_delegate(delegate)])\\n else: # TFLite\\n LOGGER.info(f'Loading {w} for TensorFlow Lite inference...')\\n interpreter = 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 # load metadata\\n with contextlib.suppress(zipfile.BadZipFile):\\n with zipfile.ZipFile(w, \\\"r\\\") as model:\\n meta_file = model.namelist()[0]\\n meta = ast.literal_eval(model.read(meta_file).decode(\\\"utf-8\\\"))\\n stride, names = int(meta['stride']), meta['names']\\n elif tfjs: # TF.js\\n raise NotImplementedError('ERROR: YOLOv5 TF.js inference is not supported')\\n elif paddle: # PaddlePaddle\\n LOGGER.info(f'Loading {w} for PaddlePaddle inference...')\\n check_requirements('paddlepaddle-gpu' if cuda else 'paddlepaddle')\\n import paddle.inference as pdi\\n if not Path(w).is_file(): # if not *.pdmodel\\n w = next(Path(w).rglob('*.pdmodel')) # get *.pdmodel file from *_paddle_model dir\\n weights = Path(w).with_suffix('.pdiparams')\\n config = pdi.Config(str(w), str(weights))\\n if cuda:\\n config.enable_use_gpu(memory_pool_init_size_mb=2048, device_id=0)\\n predictor = pdi.create_predictor(config)\\n input_handle = predictor.get_input_handle(predictor.get_input_names()[0])\\n output_names = predictor.get_output_names()\\n elif triton: # NVIDIA Triton Inference Server\\n LOGGER.info(f'Using {w} as Triton Inference Server...')\\n check_requirements('tritonclient[all]')\\n from utils.triton import TritonRemoteModel\\n model = TritonRemoteModel(url=w)\\n nhwc = model.runtime.startswith(\\\"tensorflow\\\")\\n else:\\n raise NotImplementedError(f'ERROR: {w} is not a supported format')\\n\\n # class names\\n if 'names' not in locals():\\n names = yaml_load(data)['names'] if data else {i: f'class{i}' for i in range(999)}\\n if names[0] == 'n01440764' and len(names) == 1000: # ImageNet\\n names = yaml_load(ROOT / 'data/ImageNet.yaml')['names'] # human-readable names\\n\\n self.__dict__.update(locals()) # assign all variables to self\\n\\n def forward(self, im, augment=False, visualize=False):\\n # YOLOv5 MultiBackend inference\\n b, ch, h, w = im.shape # batch, channel, height, width\\n if self.fp16 and im.dtype != torch.float16:\\n im = im.half() # to FP16\\n if self.nhwc:\\n im = im.permute(0, 2, 3, 1) # torch BCHW to numpy BHWC shape(1,320,192,3)\\n\\n if self.pt: # PyTorch\\n y = self.model(im, augment=augment, visualize=visualize) if augment or visualize else self.model(im)\\n elif self.jit: # TorchScript\\n y = self.model(im)\\n elif self.dnn: # ONNX OpenCV DNN\\n im = im.cpu().numpy() # torch to numpy\\n self.net.setInput(im)\\n y = self.net.forward()\\n elif self.onnx: # ONNX Runtime\\n im = im.cpu().numpy() # torch to numpy\\n y = self.session.run(self.output_names, {self.session.get_inputs()[0].name: im})\\n elif self.xml: # OpenVINO\\n im = im.cpu().numpy() # FP32\\n y = list(self.executable_network([im]).values())\\n elif self.engine: # TensorRT\\n if self.dynamic and im.shape != self.bindings['images'].shape:\\n i = self.model.get_binding_index('images')\\n self.context.set_binding_shape(i, im.shape) # reshape if dynamic\\n self.bindings['images'] = self.bindings['images']._replace(shape=im.shape)\\n for name in self.output_names:\\n i = self.model.get_binding_index(name)\\n self.bindings[name].data.resize_(tuple(self.context.get_binding_shape(i)))\\n s = self.bindings['images'].shape\\n assert im.shape == s, f\\\"input size {im.shape} {'>' if self.dynamic else 'not equal to'} max model size {s}\\\"\\n self.binding_addrs['images'] = int(im.data_ptr())\\n self.context.execute_v2(list(self.binding_addrs.values()))\\n y = [self.bindings[x].data for x in sorted(self.output_names)]\\n elif self.coreml: # CoreML\\n im = im.cpu().numpy()\\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 if 'confidence' in y:\\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 else:\\n y = list(reversed(y.values())) # reversed for segmentation models (pred, proto)\\n elif self.paddle: # PaddlePaddle\\n im = im.cpu().numpy().astype(np.float32)\\n self.input_handle.copy_from_cpu(im)\\n self.predictor.run()\\n y = [self.predictor.get_output_handle(x).copy_to_cpu() for x in self.output_names]\\n elif self.triton: # NVIDIA Triton Inference Server\\n y = self.model(im)\\n else: # TensorFlow (SavedModel, GraphDef, Lite, Edge TPU)\\n im = im.cpu().numpy()\\n if self.saved_model: # SavedModel\\n y = self.model(im, training=False) if self.keras else self.model(im)\\n elif self.pb: # GraphDef\\n y = self.frozen_func(x=self.tf.constant(im))\\n else: # Lite or Edge TPU\\n input = self.input_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 = []\\n for output in self.output_details:\\n x = self.interpreter.get_tensor(output['index'])\\n if int8:\\n scale, zero_point = output['quantization']\\n x = (x.astype(np.float32) - zero_point) * scale # re-scale\\n y.append(x)\\n y = [x if isinstance(x, np.ndarray) else x.numpy() for x in y]\\n y[0][..., :4] *= [w, h, w, h] # xywh normalized to pixels\\n\\n if isinstance(y, (list, tuple)):\\n return self.from_numpy(y[0]) if len(y) == 1 else [self.from_numpy(x) for x in y]\\n else:\\n return self.from_numpy(y)\\n\\n def from_numpy(self, x):\\n return torch.from_numpy(x).to(self.device) if isinstance(x, np.ndarray) else x\\n\\n def warmup(self, imgsz=(1, 3, 640, 640)):\\n # Warmup model by running inference once\\n warmup_types = self.pt, self.jit, self.onnx, self.engine, self.saved_model, self.pb, self.triton\\n if any(warmup_types) and (self.device.type != 'cpu' or self.triton):\\n im = torch.empty(*imgsz, dtype=torch.half if self.fp16 else torch.float, device=self.device) # input\\n for _ in range(2 if self.jit else 1): #\\n self.forward(im) # warmup\\n\\n @staticmethod\\n def _model_type(p='path/to/model.pt'):\\n # Return model type from model path, i.e. path='path/to/model.onnx' -> type=onnx\\n # types = [pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle]\\n from export import export_formats\\n from utils.downloads import is_url\\n sf = list(export_formats().Suffix) # export suffixes\\n if not is_url(p, check=False):\\n check_suffix(p, sf) # checks\\n url = urlparse(p) # if url may be Triton inference server\\n types = [s in Path(p).name for s in sf]\\n types[8] &= not types[9] # tflite &= not edgetpu\\n triton = not any(types) and all([any(s in url.scheme for s in [\\\"http\\\", \\\"grpc\\\"]), url.netloc])\\n return types + [triton]\\n\\n @staticmethod\\n def _load_metadata(f=Path('path/to/meta.yaml')):\\n # Load metadata from meta.yaml if it exists\\n if f.exists():\\n d = yaml_load(f)\\n return d['stride'], d['names'] # assign stride, names\\n return None, None\"\n },\n {\n \"identifier\": \"SegmentationModel\",\n \"path\": \"models/yolo.py\",\n \"snippet\": \"class SegmentationModel(DetectionModel):\\n # YOLOv5 segmentation model\\n def __init__(self, cfg='yolov5s-seg.yaml', ch=3, nc=None, anchors=None):\\n super().__init__(cfg, ch, nc, anchors)\"\n },\n {\n \"identifier\": \"Callbacks\",\n \"path\": \"utils/callbacks.py\",\n \"snippet\": \"class Callbacks:\\n \\\"\\\"\\\"\\\"\\n Handles all registered callbacks for YOLOv5 Hooks\\n \\\"\\\"\\\"\\n\\n def __init__(self):\\n # Define the available callbacks\\n self._callbacks = {\\n 'on_pretrain_routine_start': [],\\n 'on_pretrain_routine_end': [],\\n 'on_train_start': [],\\n 'on_train_epoch_start': [],\\n 'on_train_batch_start': [],\\n 'optimizer_step': [],\\n 'on_before_zero_grad': [],\\n 'on_train_batch_end': [],\\n 'on_train_epoch_end': [],\\n 'on_val_start': [],\\n 'on_val_batch_start': [],\\n 'on_val_image_end': [],\\n 'on_val_batch_end': [],\\n 'on_val_end': [],\\n 'on_fit_epoch_end': [], # fit = train + val\\n 'on_model_save': [],\\n 'on_train_end': [],\\n 'on_params_update': [],\\n 'teardown': [],}\\n self.stop_training = False # set True to interrupt training\\n\\n def register_action(self, hook, name='', callback=None):\\n \\\"\\\"\\\"\\n Register a new action to a callback hook\\n\\n Args:\\n hook: The callback hook name to register the action to\\n name: The name of the action for later reference\\n callback: The callback to fire\\n \\\"\\\"\\\"\\n assert hook in self._callbacks, f\\\"hook '{hook}' not found in callbacks {self._callbacks}\\\"\\n assert callable(callback), f\\\"callback '{callback}' is not callable\\\"\\n self._callbacks[hook].append({'name': name, 'callback': callback})\\n\\n def get_registered_actions(self, hook=None):\\n \\\"\\\"\\\"\\\"\\n Returns all the registered actions by callback hook\\n\\n Args:\\n hook: The name of the hook to check, defaults to all\\n \\\"\\\"\\\"\\n return self._callbacks[hook] if hook else self._callbacks\\n\\n def run(self, hook, *args, thread=False, **kwargs):\\n \\\"\\\"\\\"\\n Loop through the registered actions and fire all callbacks on main thread\\n\\n Args:\\n hook: The name of the hook to check, defaults to all\\n args: Arguments to receive from YOLOv5\\n thread: (boolean) Run callbacks in daemon thread\\n kwargs: Keyword Arguments to receive from YOLOv5\\n \\\"\\\"\\\"\\n\\n assert hook in self._callbacks, f\\\"hook '{hook}' not found in callbacks {self._callbacks}\\\"\\n for logger in self._callbacks[hook]:\\n if thread:\\n threading.Thread(target=logger['callback'], args=args, kwargs=kwargs, daemon=True).start()\\n else:\\n logger['callback'](*args, **kwargs)\"\n },\n {\n \"identifier\": \"LOGGER\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"LOGGER = logging.getLogger(LOGGING_NAME) # define globally (used in train.py, val.py, detect.py, etc.)\"\n },\n {\n \"identifier\": \"NUM_THREADS\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"NUM_THREADS = min(8, max(1, os.cpu_count() - 1)) # number of YOLOv5 multiprocessing threads\"\n },\n {\n \"identifier\": \"TQDM_BAR_FORMAT\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"TQDM_BAR_FORMAT = '{l_bar}{bar:10}| {n_fmt}/{total_fmt} {elapsed}' # tqdm bar format\"\n },\n {\n \"identifier\": \"Profile\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"class Profile(contextlib.ContextDecorator):\\n # YOLOv5 Profile class. Usage: @Profile() decorator or 'with Profile():' context manager\\n def __init__(self, t=0.0):\\n self.t = t\\n self.cuda = torch.cuda.is_available()\\n\\n def __enter__(self):\\n self.start = self.time()\\n return self\\n\\n def __exit__(self, type, value, traceback):\\n self.dt = self.time() - self.start # delta-time\\n self.t += self.dt # accumulate dt\\n\\n def time(self):\\n if self.cuda:\\n torch.cuda.synchronize()\\n return time.time()\"\n },\n {\n \"identifier\": \"check_dataset\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def check_dataset(data, autodownload=True):\\n # Download, check and/or unzip dataset if not found locally\\n\\n # Download (optional)\\n extract_dir = ''\\n if isinstance(data, (str, Path)) and (is_zipfile(data) or is_tarfile(data)):\\n download(data, dir=f'{DATASETS_DIR}/{Path(data).stem}', unzip=True, delete=False, curl=False, threads=1)\\n data = next((DATASETS_DIR / Path(data).stem).rglob('*.yaml'))\\n extract_dir, autodownload = data.parent, False\\n\\n # Read yaml (optional)\\n if isinstance(data, (str, Path)):\\n data = yaml_load(data) # dictionary\\n\\n # Checks\\n for k in 'train', 'val', 'names':\\n assert k in data, emojis(f\\\"data.yaml '{k}:' field missing ❌\\\")\\n if isinstance(data['names'], (list, tuple)): # old array format\\n data['names'] = dict(enumerate(data['names'])) # convert to dict\\n assert all(isinstance(k, int) for k in data['names'].keys()), 'data.yaml names keys must be integers, i.e. 2: car'\\n data['nc'] = len(data['names'])\\n\\n # Resolve paths\\n path = Path(extract_dir or data.get('path') or '') # optional 'path' default to '.'\\n if not path.is_absolute():\\n path = (ROOT / path).resolve()\\n data['path'] = path # download scripts\\n for k in 'train', 'val', 'test':\\n if data.get(k): # prepend path\\n if isinstance(data[k], str):\\n x = (path / data[k]).resolve()\\n if not x.exists() and data[k].startswith('../'):\\n x = (path / data[k][3:]).resolve()\\n data[k] = str(x)\\n else:\\n data[k] = [str((path / x).resolve()) for x in data[k]]\\n\\n # Parse yaml\\n train, val, test, s = (data.get(x) for x in ('train', 'val', 'test', 'download'))\\n if val:\\n val = [Path(x).resolve() for x in (val if isinstance(val, list) else [val])] # val path\\n if not all(x.exists() for x in val):\\n LOGGER.info('\\\\nDataset not found ⚠️, missing paths %s' % [str(x) for x in val if not x.exists()])\\n if not s or not autodownload:\\n raise Exception('Dataset not found ❌')\\n t = time.time()\\n if s.startswith('http') and s.endswith('.zip'): # URL\\n f = Path(s).name # filename\\n LOGGER.info(f'Downloading {s} to {f}...')\\n torch.hub.download_url_to_file(s, f)\\n Path(DATASETS_DIR).mkdir(parents=True, exist_ok=True) # create root\\n unzip_file(f, path=DATASETS_DIR) # unzip\\n Path(f).unlink() # remove zip\\n r = None # success\\n elif s.startswith('bash '): # bash script\\n LOGGER.info(f'Running {s} ...')\\n r = os.system(s)\\n else: # python script\\n r = exec(s, {'yaml': data}) # return None\\n dt = f'({round(time.time() - t, 1)}s)'\\n s = f\\\"success ✅ {dt}, saved to {colorstr('bold', DATASETS_DIR)}\\\" if r in (0, None) else f\\\"failure {dt} ❌\\\"\\n LOGGER.info(f\\\"Dataset download {s}\\\")\\n check_font('Arial.ttf' if is_ascii(data['names']) else 'Arial.Unicode.ttf', progress=True) # download fonts\\n return data # dictionary\"\n },\n {\n \"identifier\": \"check_img_size\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def check_img_size(imgsz, s=32, floor=0):\\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 imgsz = list(imgsz) # convert to list if tuple\\n new_size = [max(make_divisible(x, int(s)), floor) for x in imgsz]\\n if new_size != imgsz:\\n LOGGER.warning(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_requirements\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"@TryExcept()\\ndef check_requirements(requirements=ROOT / 'requirements.txt', exclude=(), install=True, cmds=''):\\n # Check installed dependencies meet YOLOv5 requirements (pass *.txt file or list of packages or single package str)\\n prefix = colorstr('red', 'bold', 'requirements:')\\n check_python() # check python version\\n if isinstance(requirements, Path): # requirements.txt file\\n file = requirements.resolve()\\n assert file.exists(), f\\\"{prefix} {file} 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 elif isinstance(requirements, str):\\n requirements = [requirements]\\n\\n s = ''\\n n = 0\\n for r in requirements:\\n try:\\n pkg.require(r)\\n except (pkg.VersionConflict, pkg.DistributionNotFound): # exception if requirements not met\\n s += f'\\\"{r}\\\" '\\n n += 1\\n\\n if s and install and AUTOINSTALL: # check environment variable\\n LOGGER.info(f\\\"{prefix} YOLOv5 requirement{'s' * (n > 1)} {s}not found, attempting AutoUpdate...\\\")\\n try:\\n # assert check_online(), \\\"AutoUpdate skipped (offline)\\\"\\n LOGGER.info(check_output(f'pip install {s} {cmds}', shell=True).decode())\\n source = file 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 LOGGER.info(s)\\n except Exception as e:\\n LOGGER.warning(f'{prefix} ❌ {e}')\"\n },\n {\n \"identifier\": \"check_yaml\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def check_yaml(file, suffix=('.yaml', '.yml')):\\n # Search/download YAML file (if necessary) and return path, checking suffix\\n return check_file(file, suffix)\"\n },\n {\n \"identifier\": \"coco80_to_coco91_class\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def coco80_to_coco91_class(): # converts 80-index (val2014) to 91-index (paper)\\n # https://tech.amikelive.com/node-718/what-object-categories-labels-are-in-coco-dataset/\\n # a = np.loadtxt('data/coco.names', dtype='str', delimiter='\\\\n')\\n # b = np.loadtxt('data/coco_paper.names', dtype='str', delimiter='\\\\n')\\n # x1 = [list(a[i] == b).index(True) + 1 for i in range(80)] # darknet to coco\\n # x2 = [list(b[i] == a).index(True) if any(b[i] == a) else None for i in range(91)] # coco to darknet\\n return [\\n 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 28, 31, 32, 33, 34,\\n 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,\\n 64, 65, 67, 70, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 89, 90]\"\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 = {\\n '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\\n # Method 1\\n for n in range(2, 9999):\\n p = f'{path}{sep}{n}{suffix}' # increment path\\n if not os.path.exists(p): #\\n break\\n path = Path(p)\\n\\n # Method 2 (deprecated)\\n # dirs = glob.glob(f\\\"{path}{sep}*\\\") # similar paths\\n # matches = [re.search(rf\\\"{path.stem}{sep}(\\\\d+)\\\", 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\\n if mkdir:\\n path.mkdir(parents=True, exist_ok=True) # make directory\\n\\n return path\"\n },\n {\n \"identifier\": \"non_max_suppression\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def non_max_suppression(\\n prediction,\\n conf_thres=0.25,\\n iou_thres=0.45,\\n classes=None,\\n agnostic=False,\\n multi_label=False,\\n labels=(),\\n max_det=300,\\n nm=0, # number of masks\\n):\\n \\\"\\\"\\\"Non-Maximum Suppression (NMS) on inference results to reject overlapping detections\\n\\n Returns:\\n list of detections, on (n,6) tensor per image [xyxy, conf, cls]\\n \\\"\\\"\\\"\\n\\n if isinstance(prediction, (list, tuple)): # YOLOv5 model in validation model, output = (inference_out, loss_out)\\n prediction = prediction[0] # select only inference output\\n\\n device = prediction.device\\n mps = 'mps' in device.type # Apple MPS\\n if mps: # MPS not fully supported yet, convert tensors to CPU before NMS\\n prediction = prediction.cpu()\\n bs = prediction.shape[0] # batch size\\n nc = prediction.shape[2] - nm - 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 = 2 # (pixels) minimum box width and height\\n max_wh = 7680 # (pixels) maximum box width and height\\n max_nms = 30000 # maximum number of boxes into torchvision.ops.nms()\\n time_limit = 0.5 + 0.05 * bs # 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 mi = 5 + nc # mask start index\\n output = [torch.zeros((0, 6 + nm), device=prediction.device)] * bs\\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 lb = labels[xi]\\n v = torch.zeros((len(lb), nc + nm + 5), device=x.device)\\n v[:, :4] = lb[:, 1:5] # box\\n v[:, 4] = 1.0 # conf\\n v[range(len(lb)), lb[:, 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/Mask\\n box = xywh2xyxy(x[:, :4]) # center_x, center_y, width, height) to (x1, y1, x2, y2)\\n mask = x[:, mi:] # zero columns if no masks\\n\\n # Detections matrix nx6 (xyxy, conf, cls)\\n if multi_label:\\n i, j = (x[:, 5:mi] > conf_thres).nonzero(as_tuple=False).T\\n x = torch.cat((box[i], x[i, 5 + j, None], j[:, None].float(), mask[i]), 1)\\n else: # best class only\\n conf, j = x[:, 5:mi].max(1, keepdim=True)\\n x = torch.cat((box, conf, j.float(), mask), 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 else:\\n x = x[x[:, 4].argsort(descending=True)] # 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 #i = my_soft_nms(boxes, scores, iou_thres) \\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 mps:\\n output[xi] = output[xi].to(device)\\n if (time.time() - t) > time_limit:\\n LOGGER.warning(f'WARNING ⚠️ NMS time limit {time_limit:.3f}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(args: Optional[dict] = None, show_file=True, show_func=False):\\n # Print function arguments (optional args dict)\\n x = inspect.currentframe().f_back # previous frame\\n file, _, func, _, _ = inspect.getframeinfo(x)\\n if args is None: # get args automatically\\n args, _, _, frm = inspect.getargvalues(x)\\n args = {k: v for k, v in frm.items() if k in args}\\n try:\\n file = Path(file).resolve().relative_to(ROOT).with_suffix('')\\n except ValueError:\\n file = Path(file).stem\\n s = (f'{file}: ' if show_file else '') + (f'{func}: ' if show_func else '')\\n LOGGER.info(colorstr(s) + ', '.join(f'{k}={v}' for k, v in args.items()))\"\n },\n {\n \"identifier\": \"scale_boxes\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def scale_boxes(img1_shape, boxes, img0_shape, ratio_pad=None):\\n # Rescale boxes (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 boxes[:, [0, 2]] -= pad[0] # x padding\\n boxes[:, [1, 3]] -= pad[1] # y padding\\n boxes[:, :4] /= gain\\n clip_boxes(boxes, img0_shape)\\n return boxes\"\n },\n {\n \"identifier\": \"xywh2xyxy\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def xywh2xyxy(x):\\n # Convert nx4 boxes from [x, y, w, h] to [x1, y1, x2, y2] 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 # top left x\\n y[:, 1] = x[:, 1] - x[:, 3] / 2 # top left y\\n y[:, 2] = x[:, 0] + x[:, 2] / 2 # bottom right x\\n y[:, 3] = x[:, 1] + x[:, 3] / 2 # bottom right y\\n return y\"\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\": \"ConfusionMatrix\",\n \"path\": \"utils/metrics.py\",\n \"snippet\": \"class ConfusionMatrix:\\n # Updated version of https://github.com/kaanakan/object_detection_confusion_matrix\\n def __init__(self, nc, conf=0.25, iou_thres=0.45):\\n self.matrix = np.zeros((nc + 1, nc + 1))\\n self.nc = nc # number of classes\\n self.conf = conf\\n self.iou_thres = iou_thres\\n\\n def process_batch(self, detections, labels):\\n \\\"\\\"\\\"\\n Return intersection-over-union (Jaccard index) of boxes.\\n Both sets of boxes are expected to be in (x1, y1, x2, y2) format.\\n Arguments:\\n detections (Array[N, 6]), x1, y1, x2, y2, conf, class\\n labels (Array[M, 5]), class, x1, y1, x2, y2\\n Returns:\\n None, updates confusion matrix accordingly\\n \\\"\\\"\\\"\\n if detections is None:\\n gt_classes = labels.int()\\n for gc in gt_classes:\\n self.matrix[self.nc, gc] += 1 # background FN\\n return\\n\\n detections = detections[detections[:, 4] > self.conf]\\n gt_classes = labels[:, 0].int()\\n detection_classes = detections[:, 5].int()\\n iou = box_iou(labels[:, 1:], detections[:, :4])\\n\\n x = torch.where(iou > self.iou_thres)\\n if x[0].shape[0]:\\n matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy()\\n if x[0].shape[0] > 1:\\n matches = matches[matches[:, 2].argsort()[::-1]]\\n matches = matches[np.unique(matches[:, 1], return_index=True)[1]]\\n matches = matches[matches[:, 2].argsort()[::-1]]\\n matches = matches[np.unique(matches[:, 0], return_index=True)[1]]\\n else:\\n matches = np.zeros((0, 3))\\n\\n n = matches.shape[0] > 0\\n m0, m1, _ = matches.transpose().astype(int)\\n for i, gc in enumerate(gt_classes):\\n j = m0 == i\\n if n and sum(j) == 1:\\n self.matrix[detection_classes[m1[j]], gc] += 1 # correct\\n else:\\n self.matrix[self.nc, gc] += 1 # true background\\n\\n if n:\\n for i, dc in enumerate(detection_classes):\\n if not any(m1 == i):\\n self.matrix[dc, self.nc] += 1 # predicted background\\n\\n def tp_fp(self):\\n tp = self.matrix.diagonal() # true positives\\n fp = self.matrix.sum(1) - tp # false positives\\n # fn = self.matrix.sum(0) - tp # false negatives (missed detections)\\n return tp[:-1], fp[:-1] # remove background class\\n\\n @TryExcept('WARNING ⚠️ ConfusionMatrix plot failure')\\n def plot(self, normalize=True, save_dir='', names=()):\\n import seaborn as sn\\n\\n array = self.matrix / ((self.matrix.sum(0).reshape(1, -1) + 1E-9) if normalize else 1) # normalize columns\\n array[array < 0.005] = np.nan # don't annotate (would appear as 0.00)\\n\\n fig, ax = plt.subplots(1, 1, figsize=(12, 9), tight_layout=True)\\n nc, nn = self.nc, len(names) # number of classes, names\\n sn.set(font_scale=1.0 if nc < 50 else 0.8) # for label size\\n labels = (0 < nn < 99) and (nn == nc) # apply names to ticklabels\\n ticklabels = (names + ['background']) if labels else \\\"auto\\\"\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore') # suppress empty matrix RuntimeWarning: All-NaN slice encountered\\n sn.heatmap(array,\\n ax=ax,\\n annot=nc < 30,\\n annot_kws={\\n \\\"size\\\": 8},\\n cmap='Blues',\\n fmt='.2f',\\n square=True,\\n vmin=0.0,\\n xticklabels=ticklabels,\\n yticklabels=ticklabels).set_facecolor((1, 1, 1))\\n ax.set_ylabel('True')\\n ax.set_ylabel('Predicted')\\n ax.set_title('Confusion Matrix')\\n fig.savefig(Path(save_dir) / 'confusion_matrix.png', dpi=250)\\n plt.close(fig)\\n\\n def print(self):\\n for i in range(self.nc + 1):\\n print(' '.join(map(str, self.matrix[i])))\"\n },\n {\n \"identifier\": \"box_iou\",\n \"path\": \"utils/metrics.py\",\n \"snippet\": \"def box_iou(box1, box2, eps=1e-7):\\n # https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py\\n \\\"\\\"\\\"\\n Return intersection-over-union (Jaccard index) of boxes.\\n Both sets of boxes are expected to be in (x1, y1, x2, y2) format.\\n Arguments:\\n box1 (Tensor[N, 4])\\n box2 (Tensor[M, 4])\\n Returns:\\n iou (Tensor[N, M]): the NxM matrix containing the pairwise\\n IoU values for every element in boxes1 and boxes2\\n \\\"\\\"\\\"\\n\\n # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)\\n (a1, a2), (b1, b2) = box1.unsqueeze(1).chunk(2, 2), box2.unsqueeze(0).chunk(2, 2)\\n inter = (torch.min(a2, b2) - torch.max(a1, b1)).clamp(0).prod(2)\\n\\n # IoU = inter / (area1 + area2 - inter)\\n return inter / ((a2 - a1).prod(2) + (b2 - b1).prod(2) - inter + eps)\"\n },\n {\n \"identifier\": \"output_to_target\",\n \"path\": \"utils/plots.py\",\n \"snippet\": \"def output_to_target(output, max_det=300):\\n # Convert model output to target format [batch_id, class_id, x, y, w, h, conf] for plotting\\n targets = []\\n for i, o in enumerate(output):\\n box, conf, cls = o[:max_det, :6].cpu().split((4, 1, 1), 1)\\n j = torch.full((conf.shape[0], 1), i)\\n targets.append(torch.cat((j, cls, xyxy2xywh(box), conf), 1))\\n return torch.cat(targets, 0).numpy()\"\n },\n {\n \"identifier\": \"plot_val_study\",\n \"path\": \"utils/plots.py\",\n \"snippet\": \"def plot_val_study(file='', dir='', x=None): # from utils.plots import *; plot_val_study()\\n # Plot file=study.txt generated by val.py (or plot all study*.txt in dir)\\n save_dir = Path(file).parent if file else Path(dir)\\n plot2 = False # plot additional results\\n if plot2:\\n ax = plt.subplots(2, 4, figsize=(10, 6), tight_layout=True)[1].ravel()\\n\\n fig2, ax2 = plt.subplots(1, 1, figsize=(8, 4), tight_layout=True)\\n # for f in [save_dir / f'study_coco_{x}.txt' for x in ['yolov5n6', 'yolov5s6', 'yolov5m6', 'yolov5l6', 'yolov5x6']]:\\n for f in sorted(save_dir.glob('study*.txt')):\\n y = np.loadtxt(f, dtype=np.float32, usecols=[0, 1, 2, 3, 7, 8, 9], ndmin=2).T\\n x = np.arange(y.shape[1]) if x is None else np.array(x)\\n if plot2:\\n s = ['P', 'R', 'mAP@.5', 'mAP@.5:.95', 't_preprocess (ms/img)', 't_inference (ms/img)', 't_NMS (ms/img)']\\n for i in range(7):\\n ax[i].plot(x, y[i], '.-', linewidth=2, markersize=8)\\n ax[i].set_title(s[i])\\n\\n j = y[3].argmax() + 1\\n ax2.plot(y[5, 1:j],\\n y[3, 1:j] * 1E2,\\n '.-',\\n linewidth=2,\\n markersize=8,\\n label=f.stem.replace('study_coco_', '').replace('yolo', 'YOLO'))\\n\\n ax2.plot(1E3 / np.array([209, 140, 97, 58, 35, 18]), [34.6, 40.5, 43.0, 47.5, 49.7, 51.5],\\n 'k.-',\\n linewidth=2,\\n markersize=8,\\n alpha=.25,\\n label='EfficientDet')\\n\\n ax2.grid(alpha=0.2)\\n ax2.set_yticks(np.arange(20, 60, 5))\\n ax2.set_xlim(0, 57)\\n ax2.set_ylim(25, 55)\\n ax2.set_xlabel('GPU Speed (ms/img)')\\n ax2.set_ylabel('COCO AP val')\\n ax2.legend(loc='lower right')\\n f = save_dir / 'study.png'\\n print(f'Saving {f}...')\\n plt.savefig(f, dpi=300)\"\n },\n {\n \"identifier\": \"create_dataloader\",\n \"path\": \"utils/segment/dataloaders.py\",\n \"snippet\": \"def create_dataloader(path,\\n imgsz,\\n batch_size,\\n stride,\\n single_cls=False,\\n hyp=None,\\n augment=False,\\n cache=False,\\n pad=0.0,\\n rect=False,\\n rank=-1,\\n workers=8,\\n image_weights=False,\\n quad=False,\\n prefix='',\\n shuffle=False,\\n mask_downsample_ratio=1,\\n overlap_mask=False):\\n if rect and shuffle:\\n LOGGER.warning('WARNING ⚠️ --rect is incompatible with DataLoader shuffle, setting shuffle=False')\\n shuffle = False\\n with torch_distributed_zero_first(rank): # init dataset *.cache only once if DDP\\n dataset = LoadImagesAndLabelsAndMasks(\\n path,\\n imgsz,\\n batch_size,\\n augment=augment, # augmentation\\n hyp=hyp, # hyperparameters\\n rect=rect, # rectangular batches\\n cache_images=cache,\\n single_cls=single_cls,\\n stride=int(stride),\\n pad=pad,\\n image_weights=image_weights,\\n prefix=prefix,\\n downsample_ratio=mask_downsample_ratio,\\n overlap=overlap_mask)\\n\\n batch_size = min(batch_size, len(dataset))\\n nd = torch.cuda.device_count() # number of CUDA devices\\n nw = min([os.cpu_count() // max(nd, 1), batch_size if batch_size > 1 else 0, workers]) # number of workers\\n sampler = None if rank == -1 else distributed.DistributedSampler(dataset, shuffle=shuffle)\\n loader = DataLoader if image_weights else InfiniteDataLoader # only DataLoader allows for attribute updates\\n generator = torch.Generator()\\n generator.manual_seed(6148914691236517205 + RANK)\\n return loader(\\n dataset,\\n batch_size=batch_size,\\n shuffle=shuffle and sampler is None,\\n num_workers=nw,\\n sampler=sampler,\\n pin_memory=True,\\n collate_fn=LoadImagesAndLabelsAndMasks.collate_fn4 if quad else LoadImagesAndLabelsAndMasks.collate_fn,\\n worker_init_fn=seed_worker,\\n generator=generator,\\n ), dataset\"\n },\n {\n \"identifier\": \"mask_iou\",\n \"path\": \"utils/segment/general.py\",\n \"snippet\": \"def mask_iou(mask1, mask2, eps=1e-7):\\n \\\"\\\"\\\"\\n mask1: [N, n] m1 means number of predicted objects\\n mask2: [M, n] m2 means number of gt objects\\n Note: n means image_w x image_h\\n\\n return: masks iou, [N, M]\\n \\\"\\\"\\\"\\n intersection = torch.matmul(mask1, mask2.t()).clamp(0)\\n union = (mask1.sum(1)[:, None] + mask2.sum(1)[None]) - intersection # (area1 + area2) - intersection\\n return intersection / (union + eps)\"\n },\n {\n \"identifier\": \"process_mask\",\n \"path\": \"utils/segment/general.py\",\n \"snippet\": \"def process_mask(protos, masks_in, bboxes, shape, upsample=False):\\n \\\"\\\"\\\"\\n Crop before upsample.\\n proto_out: [mask_dim, mask_h, mask_w]\\n out_masks: [n, mask_dim], n is number of masks after nms\\n bboxes: [n, 4], n is number of masks after nms\\n shape:input_image_size, (h, w)\\n\\n return: h, w, n\\n \\\"\\\"\\\"\\n\\n c, mh, mw = protos.shape # CHW\\n ih, iw = shape\\n masks = (masks_in @ protos.float().view(c, -1)).sigmoid().view(-1, mh, mw) # CHW\\n\\n downsampled_bboxes = bboxes.clone()\\n downsampled_bboxes[:, 0] *= mw / iw\\n downsampled_bboxes[:, 2] *= mw / iw\\n downsampled_bboxes[:, 3] *= mh / ih\\n downsampled_bboxes[:, 1] *= mh / ih\\n\\n masks = crop_mask(masks, downsampled_bboxes) # CHW\\n if upsample:\\n masks = F.interpolate(masks[None], shape, mode='bilinear', align_corners=False)[0] # CHW\\n return masks.gt_(0.5)\"\n },\n {\n \"identifier\": \"process_mask_upsample\",\n \"path\": \"utils/segment/general.py\",\n \"snippet\": \"def process_mask_upsample(protos, masks_in, bboxes, shape):\\n \\\"\\\"\\\"\\n Crop after upsample.\\n proto_out: [mask_dim, mask_h, mask_w]\\n out_masks: [n, mask_dim], n is number of masks after nms\\n bboxes: [n, 4], n is number of masks after nms\\n shape:input_image_size, (h, w)\\n\\n return: h, w, n\\n \\\"\\\"\\\"\\n\\n c, mh, mw = protos.shape # CHW\\n masks = (masks_in @ protos.float().view(c, -1)).sigmoid().view(-1, mh, mw)\\n masks = F.interpolate(masks[None], shape, mode='bilinear', align_corners=False)[0] # CHW\\n masks = crop_mask(masks, bboxes) # CHW\\n return masks.gt_(0.5)\"\n },\n {\n \"identifier\": \"scale_image\",\n \"path\": \"utils/segment/general.py\",\n \"snippet\": \"def scale_image(im1_shape, masks, im0_shape, ratio_pad=None):\\n \\\"\\\"\\\"\\n img1_shape: model input shape, [h, w]\\n img0_shape: origin pic shape, [h, w, 3]\\n masks: [h, w, num]\\n \\\"\\\"\\\"\\n # Rescale coordinates (xyxy) from im1_shape to im0_shape\\n if ratio_pad is None: # calculate from im0_shape\\n gain = min(im1_shape[0] / im0_shape[0], im1_shape[1] / im0_shape[1]) # gain = old / new\\n pad = (im1_shape[1] - im0_shape[1] * gain) / 2, (im1_shape[0] - im0_shape[0] * gain) / 2 # wh padding\\n else:\\n pad = ratio_pad[1]\\n top, left = int(pad[1]), int(pad[0]) # y, x\\n bottom, right = int(im1_shape[0] - pad[1]), int(im1_shape[1] - pad[0])\\n\\n if len(masks.shape) < 2:\\n raise ValueError(f'\\\"len of masks shape\\\" should be 2 or 3, but got {len(masks.shape)}')\\n masks = masks[top:bottom, left:right]\\n # masks = masks.permute(2, 0, 1).contiguous()\\n # masks = F.interpolate(masks[None], im0_shape[:2], mode='bilinear', align_corners=False)[0]\\n # masks = masks.permute(1, 2, 0).contiguous()\\n masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]))\\n\\n if len(masks.shape) == 2:\\n masks = masks[:, :, None]\\n return masks\"\n },\n {\n \"identifier\": \"Metrics\",\n \"path\": \"utils/segment/metrics.py\",\n \"snippet\": \"class Metrics:\\n \\\"\\\"\\\"Metric for boxes and masks.\\\"\\\"\\\"\\n\\n def __init__(self) -> None:\\n self.metric_box = Metric()\\n self.metric_mask = Metric()\\n\\n def update(self, results):\\n \\\"\\\"\\\"\\n Args:\\n results: Dict{'boxes': Dict{}, 'masks': Dict{}}\\n \\\"\\\"\\\"\\n self.metric_box.update(list(results[\\\"boxes\\\"].values()))\\n self.metric_mask.update(list(results[\\\"masks\\\"].values()))\\n\\n def mean_results(self):\\n return self.metric_box.mean_results() + self.metric_mask.mean_results()\\n\\n def class_result(self, i):\\n return self.metric_box.class_result(i) + self.metric_mask.class_result(i)\\n\\n def get_maps(self, nc):\\n return self.metric_box.get_maps(nc) + self.metric_mask.get_maps(nc)\\n\\n @property\\n def ap_class_index(self):\\n # boxes and masks have the same ap_class_index\\n return self.metric_box.ap_class_index\"\n },\n {\n \"identifier\": \"ap_per_class_box_and_mask\",\n \"path\": \"utils/segment/metrics.py\",\n \"snippet\": \"def ap_per_class_box_and_mask(\\n tp_m,\\n tp_b,\\n conf,\\n pred_cls,\\n target_cls,\\n plot=False,\\n save_dir=\\\".\\\",\\n names=(),\\n):\\n \\\"\\\"\\\"\\n Args:\\n tp_b: tp of boxes.\\n tp_m: tp of masks.\\n other arguments see `func: ap_per_class`.\\n \\\"\\\"\\\"\\n results_boxes = ap_per_class(tp_b,\\n conf,\\n pred_cls,\\n target_cls,\\n plot=plot,\\n save_dir=save_dir,\\n names=names,\\n prefix=\\\"Box\\\")[2:]\\n results_masks = ap_per_class(tp_m,\\n conf,\\n pred_cls,\\n target_cls,\\n plot=plot,\\n save_dir=save_dir,\\n names=names,\\n prefix=\\\"Mask\\\")[2:]\\n\\n results = {\\n \\\"boxes\\\": {\\n \\\"p\\\": results_boxes[0],\\n \\\"r\\\": results_boxes[1],\\n \\\"ap\\\": results_boxes[3],\\n \\\"f1\\\": results_boxes[2],\\n \\\"ap_class\\\": results_boxes[4]},\\n \\\"masks\\\": {\\n \\\"p\\\": results_masks[0],\\n \\\"r\\\": results_masks[1],\\n \\\"ap\\\": results_masks[3],\\n \\\"f1\\\": results_masks[2],\\n \\\"ap_class\\\": results_masks[4]}}\\n return results\"\n },\n {\n \"identifier\": \"plot_images_and_masks\",\n \"path\": \"utils/segment/plots.py\",\n \"snippet\": \"@threaded\\ndef plot_images_and_masks(images, targets, masks, paths=None, fname='images.jpg', names=None):\\n # Plot image grid with labels\\n if isinstance(images, torch.Tensor):\\n images = images.cpu().float().numpy()\\n if isinstance(targets, torch.Tensor):\\n targets = targets.cpu().numpy()\\n if isinstance(masks, torch.Tensor):\\n masks = masks.cpu().numpy().astype(int)\\n\\n max_size = 1920 # max image size\\n max_subplots = 16 # max image subplots, i.e. 4x4\\n bs, _, h, w = images.shape # batch size, _, height, width\\n bs = min(bs, max_subplots) # limit plot images\\n ns = np.ceil(bs ** 0.5) # number of subplots (square)\\n if np.max(images[0]) <= 1:\\n images *= 255 # de-normalise (optional)\\n\\n # Build Image\\n mosaic = np.full((int(ns * h), int(ns * w), 3), 255, dtype=np.uint8) # init\\n for i, im in enumerate(images):\\n if i == max_subplots: # if last batch has fewer images than we expect\\n break\\n x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin\\n im = im.transpose(1, 2, 0)\\n mosaic[y:y + h, x:x + w, :] = im\\n\\n # Resize (optional)\\n scale = max_size / ns / max(h, w)\\n if scale < 1:\\n h = math.ceil(scale * h)\\n w = math.ceil(scale * w)\\n mosaic = cv2.resize(mosaic, tuple(int(x * ns) for x in (w, h)))\\n\\n # Annotate\\n fs = int((h + w) * ns * 0.01) # font size\\n annotator = Annotator(mosaic, line_width=round(fs / 10), font_size=fs, pil=True, example=names)\\n for i in range(i + 1):\\n x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin\\n annotator.rectangle([x, y, x + w, y + h], None, (255, 255, 255), width=2) # borders\\n if paths:\\n annotator.text((x + 5, y + 5 + h), text=Path(paths[i]).name[:40], txt_color=(220, 220, 220)) # filenames\\n if len(targets) > 0:\\n idx = targets[:, 0] == i\\n ti = targets[idx] # image targets\\n\\n boxes = xywh2xyxy(ti[:, 2:6]).T\\n classes = ti[:, 1].astype('int')\\n labels = ti.shape[1] == 6 # labels if no conf column\\n conf = None if labels else ti[:, 6] # check for confidence presence (label vs pred)\\n\\n if boxes.shape[1]:\\n if boxes.max() <= 1.01: # if normalized with tolerance 0.01\\n boxes[[0, 2]] *= w # scale to pixels\\n boxes[[1, 3]] *= h\\n elif scale < 1: # absolute coords need scale if image scales\\n boxes *= scale\\n boxes[[0, 2]] += x\\n boxes[[1, 3]] += y\\n for j, box in enumerate(boxes.T.tolist()):\\n cls = classes[j]\\n color = colors(cls)\\n cls = names[cls] if names else cls\\n if labels or conf[j] > 0.25: # 0.25 conf thresh\\n label = f'{cls}' if labels else f'{cls} {conf[j]:.1f}'\\n annotator.box_label(box, label, color=color)\\n\\n # Plot masks\\n if len(masks):\\n if masks.max() > 1.0: # mean that masks are overlap\\n image_masks = masks[[i]] # (1, 640, 640)\\n nl = len(ti)\\n index = np.arange(nl).reshape(nl, 1, 1) + 1\\n image_masks = np.repeat(image_masks, nl, axis=0)\\n image_masks = np.where(image_masks == index, 1.0, 0.0)\\n else:\\n image_masks = masks[idx]\\n\\n im = np.asarray(annotator.im).copy()\\n for j, box in enumerate(boxes.T.tolist()):\\n if labels or conf[j] > 0.25: # 0.25 conf thresh\\n color = colors(classes[j])\\n mh, mw = image_masks[j].shape\\n if mh != h or mw != w:\\n mask = image_masks[j].astype(np.uint8)\\n mask = cv2.resize(mask, (w, h))\\n mask = mask.astype(bool)\\n else:\\n mask = image_masks[j].astype(bool)\\n with contextlib.suppress(Exception):\\n im[y:y + h, x:x + w, :][mask] = im[y:y + h, x:x + w, :][mask] * 0.4 + np.array(color) * 0.6\\n annotator.fromarray(im)\\n annotator.im.save(fname) # save\"\n },\n {\n \"identifier\": \"de_parallel\",\n \"path\": \"utils/torch_utils.py\",\n \"snippet\": \"def de_parallel(model):\\n # De-parallelize a model: returns single-GPU model if model is of type DP or DDP\\n return model.module if is_parallel(model) else model\"\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 = None or 'cpu' or 0 or '0' or '0,1,2,3'\\n s = f'YOLOv5 🚀 {git_describe() or file_date()} Python-{platform.python_version()} torch-{torch.__version__} '\\n device = str(device).strip().lower().replace('cuda:', '').replace('none', '') # to string, 'cuda:0' to '0'\\n cpu = device == 'cpu'\\n mps = device == 'mps' # Apple Metal Performance Shaders (MPS)\\n if cpu or mps:\\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 - must be before assert is_available()\\n assert torch.cuda.is_available() and torch.cuda.device_count() >= len(device.replace(',', '')), \\\\\\n f\\\"Invalid CUDA '--device {device}' requested, use '--device cpu' or pass valid CUDA device(s)\\\"\\n\\n if not cpu and not mps and torch.cuda.is_available(): # prefer GPU if available\\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 / (1 << 20):.0f}MiB)\\\\n\\\" # bytes to MB\\n arg = 'cuda:0'\\n elif mps and getattr(torch, 'has_mps', False) and torch.backends.mps.is_available(): # prefer MPS if available\\n s += 'MPS\\\\n'\\n arg = 'mps'\\n else: # revert to CPU\\n s += 'CPU\\\\n'\\n arg = 'cpu'\\n\\n if not newline:\\n s = s.rstrip()\\n LOGGER.info(s)\\n return torch.device(arg)\"\n },\n {\n \"identifier\": \"smart_inference_mode\",\n \"path\": \"utils/torch_utils.py\",\n \"snippet\": \"def smart_inference_mode(torch_1_9=check_version(torch.__version__, '1.9.0')):\\n # Applies torch.inference_mode() decorator if torch>=1.9.0 else torch.no_grad() decorator\\n def decorate(fn):\\n return (torch.inference_mode if torch_1_9 else torch.no_grad)()(fn)\\n\\n return decorate\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import argparse\nimport json\nimport os\nimport sys\nimport numpy as np\nimport torch\nimport torch.nn.functional as F\n import time\nfrom multiprocessing.pool import ThreadPool\nfrom pathlib import Path\nfrom tqdm import tqdm\nfrom models.common import DetectMultiBackend\nfrom models.yolo import SegmentationModel\nfrom utils.callbacks import Callbacks\nfrom utils.general import (LOGGER, NUM_THREADS, TQDM_BAR_FORMAT, Profile, check_dataset, check_img_size,\n check_requirements, check_yaml, coco80_to_coco91_class, colorstr, increment_path,\n non_max_suppression, print_args, scale_boxes, xywh2xyxy, xyxy2xywh)\nfrom utils.metrics import ConfusionMatrix, box_iou\nfrom utils.plots import output_to_target, plot_val_study\nfrom utils.segment.dataloaders import create_dataloader\nfrom utils.segment.general import mask_iou, process_mask, process_mask_upsample, scale_image\nfrom utils.segment.metrics import Metrics, ap_per_class_box_and_mask\nfrom utils.segment.plots import plot_images_and_masks\nfrom utils.torch_utils import de_parallel, select_device, smart_inference_mode\n from pycocotools.mask import encode\n from pycocotools.coco import COCO\n from pycocotools.cocoeval import COCOeval"},"token_num":{"kind":"number","value":21552,"string":"21,552"},"cropped_code":{"kind":"string","value":" # Print results\n pf = '%22s' + '%11i' * 2 + '%11.3g' * 8 # print format\n LOGGER.info(pf % (\"all\", seen, nt.sum(), *metrics.mean_results()))\n if nt.sum() == 0:\n LOGGER.warning(f'WARNING ⚠️ no labels found in {task} set, can not compute metrics without labels')\n\n # Print results per class\n if (verbose or (nc < 50 and not training)) and nc > 1 and len(stats):\n for i, c in enumerate(metrics.ap_class_index):\n LOGGER.info(pf % (names[c], seen, nt[c], *metrics.class_result(i)))\n\n # Print speeds\n t = tuple(x.t / seen * 1E3 for x in dt) # speeds per image\n if not training:\n shape = (batch_size, 3, imgsz, imgsz)\n LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {shape}' % t)\n\n # Plots\n if plots:\n confusion_matrix.plot(save_dir=save_dir, names=list(names.values()))\n # callbacks.run('on_val_end')\n\n mp_bbox, mr_bbox, map50_bbox, map_bbox, mp_mask, mr_mask, map50_mask, map_mask = metrics.mean_results()\n\n # Save JSON\n if save_json and len(jdict):\n w = Path(weights[0] if isinstance(weights, list) else weights).stem if weights is not None else '' # weights\n anno_json = str(Path(data.get('path', '../coco')) / 'annotations/instances_val2017.json') # annotations json\n pred_json = str(save_dir / f\"{w}_predictions.json\") # predictions json\n LOGGER.info(f'\\nEvaluating pycocotools mAP... saving {pred_json}...')\n with open(pred_json, 'w') as f:\n json.dump(jdict, f)\n\n try: # https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb\n\n anno = COCO(anno_json) # init annotations api\n pred = anno.loadRes(pred_json) # init predictions api\n results = []\n for eval in COCOeval(anno, pred, 'bbox'), COCOeval(anno, pred, 'segm'):\n if is_coco:\n eval.params.imgIds = [int(Path(x).stem) for x in dataloader.dataset.im_files] # img ID to evaluate\n eval.evaluate()\n eval.accumulate()\n eval.summarize()\n results.extend(eval.stats[:2]) # update results (mAP@0.5:0.95, mAP@0.5)\n map_bbox, map50_bbox, map_mask, map50_mask = results\n except Exception as e:\n LOGGER.info(f'pycocotools unable to run: {e}')\n\n # Return results\n model.float() # for training\n if not training:\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 final_metric = mp_bbox, mr_bbox, map50_bbox, map_bbox, mp_mask, mr_mask, map50_mask, map_mask\n return (*final_metric, *(loss.cpu() / len(dataloader)).tolist()), metrics.get_maps(nc), t\n\n\ndef parse_opt():\n parser = argparse.ArgumentParser()\n parser.add_argument('--data', type=str, default=ROOT / 'data/BCC.yaml', help='dataset.yaml path')\n parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'runs_2/train-seg/base/weights/best.pt', help='model path(s)')\n parser.add_argument('--batch-size', type=int, default=1, help='batch size')\n parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='inference size (pixels)')\n parser.add_argument('--conf-thres', type=float, default=0.01, help='confidence threshold')\n parser.add_argument('--iou-thres', type=float, default=0.45, help='NMS IoU threshold')\n parser.add_argument('--max-det', type=int, default=300, help='maximum detections per image')\n parser.add_argument('--task', default='val', help='train, val, test, speed or study')\n parser.add_argument('--device', default='6', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')\n parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')\n parser.add_argument('--single-cls', action='store_true', help='treat as single-class dataset')\n parser.add_argument('--augment', action='store_true', help='augmented inference')\n parser.add_argument('--verbose', action='store_true', help='report mAP by class')\n parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')\n parser.add_argument('--save-hybrid', action='store_true', help='save label+prediction hybrid results to *.txt')\n parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')\n parser.add_argument('--save-json', action='store_true', help='save a COCO-JSON results file')\n parser.add_argument('--project', default=ROOT / 'runs_2/val_test', help='save results to project/name')\n parser.add_argument('--name', default='base', help='save to project/name')\n parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')\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.data = check_yaml(opt.data) # check YAML\n # opt.save_json |= opt.data.endswith('coco.yaml')\n opt.save_txt |= opt.save_hybrid\n print_args(vars(opt))\n return opt\n\n\ndef main(opt):\n check_requirements(requirements=ROOT / 'requirements.txt', exclude=('tensorboard', 'thop'))\n\n if opt.task in ('train', 'val', 'test'): # run normally\n if opt.conf_thres > 0.001: # https://github.com/ultralytics/yolov5/issues/1466\n LOGGER.warning(f'WARNING ⚠️ confidence threshold {opt.conf_thres} > 0.001 produces invalid results')\n if opt.save_hybrid:\n LOGGER.warning('WARNING ⚠️ --save-hybrid returns high mAP from hybrid labels, not from predictions alone')\n run(**vars(opt))\n\n else:\n weights = opt.weights if isinstance(opt.weights, list) else [opt.weights]\n opt.half = torch.cuda.is_available() and opt.device != 'cpu' # FP16 for fastest results\n if opt.task == 'speed': # speed benchmarks\n # python val.py --task speed --data coco.yaml --batch 1 --weights yolov5n.pt yolov5s.pt...\n opt.conf_thres, opt.iou_thres, opt.save_json = 0.25, 0.45, False\n for opt.weights in weights:\n run(**vars(opt), plots=False)\n\n elif opt.task == 'study': # speed vs mAP benchmarks\n # python val.py --task study --data coco.yaml --iou 0.7 --weights yolov5n.pt yolov5s.pt...\n for opt.weights in weights:\n f = f'study_{Path(opt.data).stem}_{Path(opt.weights).stem}.txt' # filename to save to\n x, y = list(range(256, 1536 + 128, 128)), [] # x axis (image sizes), y axis\n for opt.imgsz in x: # img-size\n LOGGER.info(f'\\nRunning {f} --imgsz {opt.imgsz}...')\n r, _, t = run(**vars(opt), plots=False)\n y.append(r + t) # results and times\n np.savetxt(f, y, fmt='%10.4g') # save\n os.system('zip -r study.zip study_*.txt')\n"},"all_code":{"kind":"string","value":"# YOLOv5 🚀 by Ultralytics, GPL-3.0 license\n\"\"\"\nValidate a trained YOLOv5 segment model on a segment dataset\n\nUsage:\n $ bash data/scripts/get_coco.sh --val --segments # download COCO-segments val split (1G, 5000 images)\n $ python segment/val.py --weights yolov5s-seg.pt --data coco.yaml --img 640 # validate COCO-segments\n\nUsage - formats:\n $ python segment/val.py --weights yolov5s-seg.pt # PyTorch\n yolov5s-seg.torchscript # TorchScript\n yolov5s-seg.onnx # ONNX Runtime or OpenCV DNN with --dnn\n yolov5s-seg_openvino_label # OpenVINO\n yolov5s-seg.engine # TensorRT\n yolov5s-seg.mlmodel # CoreML (macOS-only)\n yolov5s-seg_saved_model # TensorFlow SavedModel\n yolov5s-seg.pb # TensorFlow GraphDef\n yolov5s-seg.tflite # TensorFlow Lite\n yolov5s-seg_edgetpu.tflite # TensorFlow Edge TPU\n yolov5s-seg_paddle_model # PaddlePaddle\n\"\"\"\n\n\n\nFILE = Path(__file__).resolve()\nROOT = FILE.parents[1] # 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\ndef save_one_txt(predn, save_conf, shape, file):\n # Save one txt result\n gn = torch.tensor(shape)[[1, 0, 1, 0]] # normalization gain whwh\n for *xyxy, conf, cls in predn.tolist():\n xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh\n line = (cls, *xywh, conf) if save_conf else (cls, *xywh) # label format\n with open(file, 'a') as f:\n f.write(('%g ' * len(line)).rstrip() % line + '\\n')\n\n\ndef save_one_json(predn, jdict, path, class_map, pred_masks):\n # Save one JSON result {\"image_id\": 42, \"category_id\": 18, \"bbox\": [258.15, 41.29, 348.26, 243.78], \"score\": 0.236}\n\n def single_encode(x):\n rle = encode(np.asarray(x[:, :, None], order=\"F\", dtype=\"uint8\"))[0]\n rle[\"counts\"] = rle[\"counts\"].decode(\"utf-8\")\n return rle\n\n image_id = int(path.stem) if path.stem.isnumeric() else path.stem\n box = xyxy2xywh(predn[:, :4]) # xywh\n box[:, :2] -= box[:, 2:] / 2 # xy center to top-left corner\n pred_masks = np.transpose(pred_masks, (2, 0, 1))\n with ThreadPool(NUM_THREADS) as pool:\n rles = pool.map(single_encode, pred_masks)\n for i, (p, b) in enumerate(zip(predn.tolist(), box.tolist())):\n jdict.append({\n 'image_id': image_id,\n 'category_id': class_map[int(p[5])],\n 'bbox': [round(x, 3) for x in b],\n 'score': round(p[4], 5),\n 'segmentation': rles[i]})\n\n\ndef process_batch(detections, labels, iouv, pred_masks=None, gt_masks=None, overlap=False, masks=False):\n \"\"\"\n Return correct prediction matrix\n Arguments:\n detections (array[N, 6]), x1, y1, x2, y2, conf, class\n labels (array[M, 5]), class, x1, y1, x2, y2\n Returns:\n correct (array[N, 10]), for 10 IoU levels\n \"\"\"\n if masks:\n if overlap:\n nl = len(labels)\n index = torch.arange(nl, device=gt_masks.device).view(nl, 1, 1) + 1\n gt_masks = gt_masks.repeat(nl, 1, 1) # shape(1,640,640) -> (n,640,640)\n gt_masks = torch.where(gt_masks == index, 1.0, 0.0)\n if gt_masks.shape[1:] != pred_masks.shape[1:]:\n gt_masks = F.interpolate(gt_masks[None], pred_masks.shape[1:], mode=\"bilinear\", align_corners=False)[0]\n gt_masks = gt_masks.gt_(0.5)\n iou = mask_iou(gt_masks.view(gt_masks.shape[0], -1), pred_masks.view(pred_masks.shape[0], -1))\n else: # boxes\n iou = box_iou(labels[:, 1:], detections[:, :4])\n\n correct = np.zeros((detections.shape[0], iouv.shape[0])).astype(bool)\n correct_class = labels[:, 0:1] == detections[:, 5]\n for i in range(len(iouv)):\n x = torch.where((iou >= iouv[i]) & correct_class) # IoU > threshold and classes match\n if x[0].shape[0]:\n matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy() # [label, detect, iou]\n if x[0].shape[0] > 1:\n matches = matches[matches[:, 2].argsort()[::-1]]\n matches = matches[np.unique(matches[:, 1], return_index=True)[1]]\n # matches = matches[matches[:, 2].argsort()[::-1]]\n matches = matches[np.unique(matches[:, 0], return_index=True)[1]]\n correct[matches[:, 1].astype(int), i] = True\n return torch.tensor(correct, dtype=torch.bool, device=iouv.device)\n\n\n@smart_inference_mode()\ndef run(\n data,\n weights=None, # model.pt path(s)\n batch_size=32, # batch size\n imgsz=640, # inference size (pixels)\n conf_thres=0.001, # confidence threshold\n iou_thres=0.6, # NMS IoU threshold\n max_det=300, # maximum detections per image\n task='val', # train, val, test, speed or study\n device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu\n workers=8, # max dataloader workers (per RANK in DDP mode)\n single_cls=False, # treat as single-class dataset\n augment=False, # augmented inference\n verbose=False, # verbose output\n save_txt=False, # save results to *.txt\n save_hybrid=False, # save label+prediction hybrid results to *.txt\n save_conf=False, # save confidences in --save-txt labels\n save_json=False, # save a COCO-JSON results file\n project=ROOT / 'runs/val-seg', # save to project/name\n name='exp', # save to project/name\n exist_ok=False, # existing project/name ok, do not increment\n half=True, # use FP16 half-precision inference\n dnn=False, # use OpenCV DNN for ONNX inference\n model=None,\n dataloader=None,\n save_dir=Path(''),\n plots=True,\n overlap=False,\n mask_downsample_ratio=1,\n compute_loss=None,\n callbacks=Callbacks(),\n):\n if save_json:\n check_requirements(['pycocotools'])\n process = process_mask_upsample # more accurate\n else:\n process = process_mask # faster\n\n # Initialize/load model and set device\n training = model is not None\n if training: # called by train.py\n device, pt, jit, engine = next(model.parameters()).device, True, False, False # get model device, PyTorch model\n half &= device.type != 'cpu' # half precision only supported on CUDA\n model.half() if half else model.float()\n nm = de_parallel(model).model[-1].nm # number of masks\n else: # called directly\n device = select_device(device, batch_size=batch_size)\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 model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data, fp16=half)\n stride, pt, jit, engine = model.stride, model.pt, model.jit, model.engine\n imgsz = check_img_size(imgsz, s=stride) # check image size\n half = model.fp16 # FP16 supported on limited backends with CUDA\n nm = de_parallel(model).model.model[-1].nm if isinstance(model, SegmentationModel) else 32 # number of masks\n if engine:\n batch_size = model.batch_size\n else:\n device = model.device\n if not (pt or jit):\n batch_size = 1 # export.py models default to batch-size 1\n LOGGER.info(f'Forcing --batch-size 1 square inference (1,3,{imgsz},{imgsz}) for non-PyTorch models')\n\n # Data\n data = check_dataset(data) # check\n\n # Configure\n model.eval()\n cuda = device.type != 'cpu'\n is_coco = isinstance(data.get('val'), str) and data['val'].endswith(f'coco{os.sep}val2017.txt') # COCO dataset\n nc = 1 if single_cls else int(data['nc']) # number of classes\n iouv = torch.linspace(0.5, 0.95, 10, device=device) # iou vector for mAP@0.5:0.95\n niou = iouv.numel()\n\n # Dataloader\n if not training:\n if pt and not single_cls: # check --weights are trained on --data\n ncm = model.model.nc\n assert ncm == nc, f'{weights} ({ncm} classes) trained on different --data than what you passed ({nc} ' \\\n f'classes). Pass correct combination of --weights and --data that are trained together.'\n model.warmup(imgsz=(1 if pt else batch_size, 3, imgsz, imgsz)) # warmup\n pad, rect = (0.0, False) if task == 'speed' else (0.5, pt) # square inference for benchmarks\n task = task if task in ('train', 'val', 'test') else 'val' # path to train/val/test images\n dataloader = create_dataloader(data[task],\n imgsz,\n batch_size,\n stride,\n single_cls,\n pad=pad,\n rect=rect,\n workers=workers,\n prefix=colorstr(f'{task}: '),\n overlap_mask=overlap,\n mask_downsample_ratio=mask_downsample_ratio)[0]\n\n seen = 0\n confusion_matrix = ConfusionMatrix(nc=nc)\n names = model.names if hasattr(model, 'names') else model.module.names # get class names\n if isinstance(names, (list, tuple)): # old format\n names = dict(enumerate(names))\n class_map = coco80_to_coco91_class() if is_coco else list(range(1000))\n s = ('%22s' + '%11s' * 10) % ('Class', 'Images', 'Instances', 'Box(P', \"R\", \"mAP50\", \"mAP50-95)\", \"Mask(P\", \"R\",\n \"mAP50\", \"mAP50-95)\")\n dt = Profile(), Profile(), Profile()\n metrics = Metrics()\n loss = torch.zeros(4, device=device)\n jdict, stats = [], []\n # callbacks.run('on_val_start')\n pbar = tqdm(dataloader, desc=s, bar_format=TQDM_BAR_FORMAT) # progress bar\n for batch_i, (im, targets, paths, shapes, masks) in enumerate(pbar):\n # callbacks.run('on_val_batch_start')\n with dt[0]:\n if cuda:\n im = im.to(device, non_blocking=True)\n targets = targets.to(device)\n masks = masks.to(device)\n masks = masks.float()\n im = im.half() if half else im.float() # uint8 to fp16/32\n im /= 255 # 0 - 255 to 0.0 - 1.0\n nb, _, height, width = im.shape # batch size, channels, height, width\n\n # Inference\n with dt[1]:\n act = time.time()\n preds, protos, train_out = model(im) if compute_loss else (*model(im, augment=augment)[:2], None)\n #print('time.time():',time.time()-act)\n\n # Loss\n if compute_loss:\n loss += compute_loss((train_out, protos), targets, masks)[1] # box, obj, cls\n\n # NMS\n targets[:, 2:] *= torch.tensor((width, height, width, height), device=device) # to pixels\n lb = [targets[targets[:, 0] == i, 1:] for i in range(nb)] if save_hybrid else [] # for autolabelling\n with dt[2]:\n preds = non_max_suppression(preds,\n conf_thres,\n iou_thres,\n labels=lb,\n multi_label=True,\n agnostic=single_cls,\n max_det=max_det,\n nm=nm)\n\n # Metrics\n plot_masks = [] # masks for plotting\n for si, (pred, proto) in enumerate(zip(preds, protos)):\n labels = targets[targets[:, 0] == si, 1:]\n nl, npr = labels.shape[0], pred.shape[0] # number of labels, predictions\n path, shape = Path(paths[si]), shapes[si][0]\n correct_masks = torch.zeros(npr, niou, dtype=torch.bool, device=device) # init\n correct_bboxes = torch.zeros(npr, niou, dtype=torch.bool, device=device) # init\n seen += 1\n\n if npr == 0:\n if nl:\n stats.append((correct_masks, correct_bboxes, *torch.zeros((2, 0), device=device), labels[:, 0]))\n if plots:\n confusion_matrix.process_batch(detections=None, labels=labels[:, 0])\n continue\n\n # Masks\n midx = [si] if overlap else targets[:, 0] == si\n gt_masks = masks[midx]\n pred_masks = process(proto, pred[:, 6:], pred[:, :4], shape=im[si].shape[1:])\n\n # Predictions\n if single_cls:\n pred[:, 5] = 0\n predn = pred.clone()\n scale_boxes(im[si].shape[1:], predn[:, :4], shape, shapes[si][1]) # native-space pred\n\n # Evaluate\n if nl:\n tbox = xywh2xyxy(labels[:, 1:5]) # target boxes\n scale_boxes(im[si].shape[1:], tbox, shape, shapes[si][1]) # native-space labels\n labelsn = torch.cat((labels[:, 0:1], tbox), 1) # native-space labels\n correct_bboxes = process_batch(predn, labelsn, iouv)\n correct_masks = process_batch(predn, labelsn, iouv, pred_masks, gt_masks, overlap=overlap, masks=True)\n if plots:\n confusion_matrix.process_batch(predn, labelsn)\n stats.append((correct_masks, correct_bboxes, pred[:, 4], pred[:, 5], labels[:, 0])) # (conf, pcls, tcls)\n\n pred_masks = torch.as_tensor(pred_masks, dtype=torch.uint8)\n if plots and batch_i < 3:\n plot_masks.append(pred_masks[:15].cpu()) # filter top 15 to plot\n\n # Save/log\n if save_txt:\n save_one_txt(predn, save_conf, shape, file=save_dir / 'labels' / f'{path.stem}.txt')\n if save_json:\n pred_masks = scale_image(im[si].shape[1:],\n pred_masks.permute(1, 2, 0).contiguous().cpu().numpy(), shape, shapes[si][1])\n save_one_json(predn, jdict, path, class_map, pred_masks) # append to COCO-JSON dictionary\n # callbacks.run('on_val_image_end', pred, predn, path, names, im[si])\n\n # Plot images\n if plots and batch_i < 3:\n if len(plot_masks):\n plot_masks = torch.cat(plot_masks, dim=0)\n plot_images_and_masks(im, targets, masks, paths, save_dir / f'val_batch{batch_i}_labels.jpg', names)\n plot_images_and_masks(im, output_to_target(preds, max_det=15), plot_masks, paths,\n save_dir / f'val_batch{batch_i}_pred.jpg', names) # pred\n\n # callbacks.run('on_val_batch_end')\n\n # Compute metrics\n stats = [torch.cat(x, 0).cpu().numpy() for x in zip(*stats)] # to numpy\n if len(stats) and stats[0].any():\n results = ap_per_class_box_and_mask(*stats, plot=plots, save_dir=save_dir, names=names)\n metrics.update(results)\n nt = np.bincount(stats[4].astype(int), minlength=nc) # number of targets per class\n\n # Print results\n pf = '%22s' + '%11i' * 2 + '%11.3g' * 8 # print format\n LOGGER.info(pf % (\"all\", seen, nt.sum(), *metrics.mean_results()))\n if nt.sum() == 0:\n LOGGER.warning(f'WARNING ⚠️ no labels found in {task} set, can not compute metrics without labels')\n\n # Print results per class\n if (verbose or (nc < 50 and not training)) and nc > 1 and len(stats):\n for i, c in enumerate(metrics.ap_class_index):\n LOGGER.info(pf % (names[c], seen, nt[c], *metrics.class_result(i)))\n\n # Print speeds\n t = tuple(x.t / seen * 1E3 for x in dt) # speeds per image\n if not training:\n shape = (batch_size, 3, imgsz, imgsz)\n LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {shape}' % t)\n\n # Plots\n if plots:\n confusion_matrix.plot(save_dir=save_dir, names=list(names.values()))\n # callbacks.run('on_val_end')\n\n mp_bbox, mr_bbox, map50_bbox, map_bbox, mp_mask, mr_mask, map50_mask, map_mask = metrics.mean_results()\n\n # Save JSON\n if save_json and len(jdict):\n w = Path(weights[0] if isinstance(weights, list) else weights).stem if weights is not None else '' # weights\n anno_json = str(Path(data.get('path', '../coco')) / 'annotations/instances_val2017.json') # annotations json\n pred_json = str(save_dir / f\"{w}_predictions.json\") # predictions json\n LOGGER.info(f'\\nEvaluating pycocotools mAP... saving {pred_json}...')\n with open(pred_json, 'w') as f:\n json.dump(jdict, f)\n\n try: # https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb\n\n anno = COCO(anno_json) # init annotations api\n pred = anno.loadRes(pred_json) # init predictions api\n results = []\n for eval in COCOeval(anno, pred, 'bbox'), COCOeval(anno, pred, 'segm'):\n if is_coco:\n eval.params.imgIds = [int(Path(x).stem) for x in dataloader.dataset.im_files] # img ID to evaluate\n eval.evaluate()\n eval.accumulate()\n eval.summarize()\n results.extend(eval.stats[:2]) # update results (mAP@0.5:0.95, mAP@0.5)\n map_bbox, map50_bbox, map_mask, map50_mask = results\n except Exception as e:\n LOGGER.info(f'pycocotools unable to run: {e}')\n\n # Return results\n model.float() # for training\n if not training:\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 final_metric = mp_bbox, mr_bbox, map50_bbox, map_bbox, mp_mask, mr_mask, map50_mask, map_mask\n return (*final_metric, *(loss.cpu() / len(dataloader)).tolist()), metrics.get_maps(nc), t\n\n\ndef parse_opt():\n parser = argparse.ArgumentParser()\n parser.add_argument('--data', type=str, default=ROOT / 'data/BCC.yaml', help='dataset.yaml path')\n parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'runs_2/train-seg/base/weights/best.pt', help='model path(s)')\n parser.add_argument('--batch-size', type=int, default=1, help='batch size')\n parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='inference size (pixels)')\n parser.add_argument('--conf-thres', type=float, default=0.01, help='confidence threshold')\n parser.add_argument('--iou-thres', type=float, default=0.45, help='NMS IoU threshold')\n parser.add_argument('--max-det', type=int, default=300, help='maximum detections per image')\n parser.add_argument('--task', default='val', help='train, val, test, speed or study')\n parser.add_argument('--device', default='6', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')\n parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')\n parser.add_argument('--single-cls', action='store_true', help='treat as single-class dataset')\n parser.add_argument('--augment', action='store_true', help='augmented inference')\n parser.add_argument('--verbose', action='store_true', help='report mAP by class')\n parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')\n parser.add_argument('--save-hybrid', action='store_true', help='save label+prediction hybrid results to *.txt')\n parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')\n parser.add_argument('--save-json', action='store_true', help='save a COCO-JSON results file')\n parser.add_argument('--project', default=ROOT / 'runs_2/val_test', help='save results to project/name')\n parser.add_argument('--name', default='base', help='save to project/name')\n parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')\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.data = check_yaml(opt.data) # check YAML\n # opt.save_json |= opt.data.endswith('coco.yaml')\n opt.save_txt |= opt.save_hybrid\n print_args(vars(opt))\n return opt\n\n\ndef main(opt):\n check_requirements(requirements=ROOT / 'requirements.txt', exclude=('tensorboard', 'thop'))\n\n if opt.task in ('train', 'val', 'test'): # run normally\n if opt.conf_thres > 0.001: # https://github.com/ultralytics/yolov5/issues/1466\n LOGGER.warning(f'WARNING ⚠️ confidence threshold {opt.conf_thres} > 0.001 produces invalid results')\n if opt.save_hybrid:\n LOGGER.warning('WARNING ⚠️ --save-hybrid returns high mAP from hybrid labels, not from predictions alone')\n run(**vars(opt))\n\n else:\n weights = opt.weights if isinstance(opt.weights, list) else [opt.weights]\n opt.half = torch.cuda.is_available() and opt.device != 'cpu' # FP16 for fastest results\n if opt.task == 'speed': # speed benchmarks\n # python val.py --task speed --data coco.yaml --batch 1 --weights yolov5n.pt yolov5s.pt...\n opt.conf_thres, opt.iou_thres, opt.save_json = 0.25, 0.45, False\n for opt.weights in weights:\n run(**vars(opt), plots=False)\n\n elif opt.task == 'study': # speed vs mAP benchmarks\n # python val.py --task study --data coco.yaml --iou 0.7 --weights yolov5n.pt yolov5s.pt...\n for opt.weights in weights:\n f = f'study_{Path(opt.data).stem}_{Path(opt.weights).stem}.txt' # filename to save to\n x, y = list(range(256, 1536 + 128, 128)), [] # x axis (image sizes), y axis\n for opt.imgsz in x: # img-size\n LOGGER.info(f'\\nRunning {f} --imgsz {opt.imgsz}...')\n r, _, t = run(**vars(opt), plots=False)\n y.append(r + t) # results and times\n np.savetxt(f, y, fmt='%10.4g') # save\n os.system('zip -r study.zip study_*.txt')"},"next_line":{"kind":"string","value":" plot_val_study(x=x) # plot"},"gold_snippet_index":{"kind":"number","value":22,"string":"22"},"created_at":{"kind":"string","value":"2023-12-10 14:18:29+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5973,"cells":{"repo_name":{"kind":"string","value":"youngskkim/CRN"},"file_path":{"kind":"string","value":"exps/base_exp.py"},"context":{"kind":"list like","value":[{"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 info_paths,\n is_train,\n load_interval=1,\n num_sweeps=1,\n img_conf=dict(img_mean=[123.675, 116.28, 103.53],\n img_std=[58.395, 57.12, 57.375],\n to_rgb=True),\n img_backbone_conf=dict(\n x_bound=[-51.2, 51.2, 0.8],\n y_bound=[-51.2, 51.2, 0.8],\n z_bound=[-5, 3, 8],\n d_bound=[2.0, 58.0, 0.5]\n ),\n drop_aug_conf=None,\n return_image=True,\n return_depth=False,\n return_radar_pv=False,\n depth_path='depth_gt',\n radar_pv_path='radar_pv_filter',\n remove_z_axis=False,\n use_cbgs=False,\n gt_for_radar_only=False,\n sweep_idxes=list(),\n key_idxes=list()):\n \"\"\"Dataset used for bevdetection task.\n Args:\n ida_aug_conf (dict): Config for ida augmentation.\n bda_aug_conf (dict): Config for bda augmentation.\n classes (list): Class names.\n use_cbgs (bool): Whether to use cbgs strategy,\n Default: False.\n num_sweeps (int): Number of sweeps to be used for each sample.\n default: 1.\n img_conf (dict): Config for image.\n return_depth (bool): Whether to use depth gt.\n default: False.\n sweep_idxes (list): List of sweep idxes to be used.\n default: list().\n key_idxes (list): List of key idxes to be used.\n default: list().\n \"\"\"\n super().__init__()\n if isinstance(info_paths, list):\n self.infos = list()\n for info_path in info_paths:\n self.infos.extend(mmcv.load(info_path))\n else:\n self.infos = mmcv.load(info_paths)\n self.is_train = is_train\n self.ida_aug_conf = ida_aug_conf\n self.bda_aug_conf = bda_aug_conf\n self.rda_aug_conf = rda_aug_conf\n self.drop_aug_conf = drop_aug_conf\n self.data_root = data_root\n self.classes = classes\n self.use_cbgs = use_cbgs\n if self.use_cbgs:\n self.cat2id = {name: i for i, name in enumerate(self.classes)}\n self.sample_indices = self._get_sample_indices()\n self.num_sweeps = num_sweeps\n self.img_mean = np.array(img_conf['img_mean'], np.float32)\n self.img_std = np.array(img_conf['img_std'], np.float32)\n self.to_rgb = img_conf['to_rgb']\n self.img_backbone_conf = img_backbone_conf\n\n self.return_image = return_image\n self.return_depth = return_depth\n self.return_radar_pv = return_radar_pv\n\n self.remove_z_axis = remove_z_axis\n self.gt_for_radar_only = gt_for_radar_only\n\n assert sum([sweep_idx >= 0 for sweep_idx in sweep_idxes]) \\\n == len(sweep_idxes), 'All `sweep_idxes` must greater \\\n than or equal to 0.'\n\n self.sweeps_idx = sweep_idxes\n assert sum([key_idx < 0 for key_idx in key_idxes]) == len(key_idxes),\\\n 'All `key_idxes` must less than 0.'\n self.key_idxes = [0] + key_idxes\n if load_interval > 1:\n self.infos = self.infos[::load_interval]\n self.depth_path = depth_path\n self.radar_pv_path = radar_pv_path\n\n self.max_radar_points_pv = 1536\n self.max_distance_pv = self.img_backbone_conf['d_bound'][1]\n\n def _get_sample_indices(self):\n \"\"\"Load annotations from ann_file.\n\n Args:\n ann_file (str): Path of the annotation file.\n\n Returns:\n list[dict]: List of annotations after class sampling.\n \"\"\"\n class_sample_idxs = {cat_id: [] for cat_id in self.cat2id.values()}\n for idx, info in enumerate(self.infos):\n gt_names = set(\n [ann_info['category_name'] for ann_info in info['ann_infos']])\n for gt_name in gt_names:\n gt_name = map_name_from_general_to_detection[gt_name]\n if gt_name not in self.classes:\n continue\n class_sample_idxs[self.cat2id[gt_name]].append(idx)\n duplicated_samples = sum(\n [len(v) for _, v in class_sample_idxs.items()])\n class_distribution = {\n k: len(v) / duplicated_samples\n for k, v in class_sample_idxs.items()\n }\n\n sample_indices = []\n\n frac = 1.0 / len(self.classes)\n ratios = [frac / v for v in class_distribution.values()]\n for cls_inds, ratio in zip(list(class_sample_idxs.values()), ratios):\n sample_indices += np.random.choice(cls_inds,\n int(len(cls_inds) *\n ratio)).tolist()\n return sample_indices\n\n def sample_ida_augmentation(self):\n \"\"\"Generate ida augmentation values based on ida_config.\"\"\"\n H, W = self.ida_aug_conf['H'], self.ida_aug_conf['W']\n fH, fW = self.ida_aug_conf['final_dim']\n if self.is_train:\n resize = np.random.uniform(*self.ida_aug_conf['resize_lim'])\n resize_dims = (int(W * resize), int(H * resize))\n newW, newH = resize_dims\n crop_h = int(\n (1 - np.random.uniform(*self.ida_aug_conf['bot_pct_lim'])) *\n newH) - fH\n crop_w = int(np.random.uniform(0, max(0, newW - fW)))\n crop = (crop_w, crop_h, crop_w + fW, crop_h + fH)\n flip = False\n if self.ida_aug_conf['rand_flip'] and np.random.choice([0, 1]):\n flip = True\n rotate_ida = np.random.uniform(*self.ida_aug_conf['rot_lim'])\n else:\n resize = max(fH / H, fW / W)\n resize_dims = (int(W * resize), int(H * resize))\n newW, newH = resize_dims\n crop_h = int(\n (1 - np.mean(self.ida_aug_conf['bot_pct_lim'])) * newH) - fH\n crop_w = int(max(0, newW - fW) / 2)\n crop = (crop_w, crop_h, crop_w + fW, crop_h + fH)\n flip = False\n rotate_ida = 0\n return resize, resize_dims, crop, flip, rotate_ida\n\n def sample_bda_augmentation(self):\n \"\"\"Generate bda augmentation values based on bda_config.\"\"\"\n if self.is_train:\n if np.random.uniform() < self.bda_aug_conf['rot_ratio']:\n rotate_bda = np.random.uniform(*self.bda_aug_conf['rot_lim'])\n else:\n rotate_bda = 0\n scale_bda = np.random.uniform(*self.bda_aug_conf['scale_lim'])\n flip_dx = np.random.uniform() < self.bda_aug_conf['flip_dx_ratio']\n flip_dy = np.random.uniform() < self.bda_aug_conf['flip_dy_ratio']\n else:\n rotate_bda = 0\n scale_bda = 1.0\n flip_dx = False\n flip_dy = False\n return rotate_bda, scale_bda, flip_dx, flip_dy\n\n def sample_radar_augmentation(self):\n \"\"\"Generate bda augmentation values based on bda_config.\"\"\"\n if self.is_train:\n radar_idx = np.random.choice(self.rda_aug_conf['N_sweeps'],\n self.rda_aug_conf['N_use'],\n replace=False)\n else:\n radar_idx = np.arange(self.rda_aug_conf['N_sweeps'])\n return radar_idx\n\n def transform_radar_pv(self, points, resize, resize_dims, crop, flip, rotate, radar_idx):\n points = points[points[:, 2] < self.max_distance_pv, :]\n\n H, W = resize_dims\n points[:, :2] = points[:, :2] * resize\n points[:, 0] -= crop[0]\n points[:, 1] -= crop[1]\n if flip:\n points[:, 0] = resize_dims[1] - points[:, 0]\n\n points[:, 0] -= W / 2.0\n points[:, 1] -= H / 2.0\n\n h = rotate / 180 * np.pi\n rot_matrix = [\n [np.cos(h), np.sin(h)],\n [-np.sin(h), np.cos(h)],\n ]\n points[:, :2] = np.matmul(rot_matrix, points[:, :2].T).T\n\n points[:, 0] += W / 2.0\n points[:, 1] += H / 2.0\n\n depth_coords = points[:, :2].astype(np.int16)\n\n valid_mask = ((depth_coords[:, 1] < resize_dims[0])\n & (depth_coords[:, 0] < resize_dims[1])\n & (depth_coords[:, 1] >= 0)\n & (depth_coords[:, 0] >= 0))\n\n points = torch.Tensor(points[valid_mask])\n\n if self.remove_z_axis:\n points[:, 1] = 1. # dummy height value\n\n points_save = []\n for i in radar_idx:\n points_save.append(points[points[:, 6] == i])\n points = torch.cat(points_save, dim=0)\n\n # mean, std of rcs and speed are from train set\n points[:, 3] = (points[:, 3] - 4.783) / 7.576\n points[:, 4] = (torch.norm(points[:, 4:6], dim=1) - 0.677) / 1.976\n\n if self.is_train:\n drop_idx = np.random.uniform(size=points.shape[0]) # randomly drop points\n points = points[drop_idx > self.rda_aug_conf['drop_ratio']]\n\n num_points, num_feat = points.shape\n if num_points > self.max_radar_points_pv:\n choices = np.random.choice(num_points, self.max_radar_points_pv, replace=False)\n points = points[choices]\n else:\n num_append = self.max_radar_points_pv - num_points\n points = torch.cat([points, -999*torch.ones(num_append, num_feat)], dim=0)\n\n if num_points == 0:\n points[0, :] = points.new_tensor([0.1, 0.1, self.max_distance_pv-1, 0, 0, 0, 0])\n\n points[..., [0, 1, 2]] = points[..., [0, 2, 1]] # convert [w, h, d] to [w, d, h]\n\n return points[..., :5]\n\n def depth_transform(self, cam_depth, resize, resize_dims, crop, flip, rotate):\n \"\"\"Transform depth based on ida augmentation configuration.\n\n Args:\n cam_depth (np array): Nx3, 3: x,y,d.\n resize (float): Resize factor.\n resize_dims (tuple): Final dimension.\n crop (tuple): x1, y1, x2, y2\n flip (bool): Whether to flip.\n rotate (float): Rotation value.\n\n Returns:\n np array: [h/down_ratio, w/down_ratio, d]\n \"\"\"\n valid_depth = cam_depth[:, 2] < self.img_backbone_conf['d_bound'][1]\n cam_depth = cam_depth[valid_depth, :]\n\n H, W = resize_dims\n cam_depth[:, :2] = cam_depth[:, :2] * resize\n cam_depth[:, 0] -= crop[0]\n cam_depth[:, 1] -= crop[1]\n if flip:\n cam_depth[:, 0] = resize_dims[1] - cam_depth[:, 0]\n\n cam_depth[:, 0] -= W / 2.0\n cam_depth[:, 1] -= H / 2.0\n\n h = rotate / 180 * np.pi\n rot_matrix = [\n [np.cos(h), np.sin(h)],\n [-np.sin(h), np.cos(h)],\n ]\n cam_depth[:, :2] = np.matmul(rot_matrix, cam_depth[:, :2].T).T\n\n cam_depth[:, 0] += W / 2.0\n cam_depth[:, 1] += H / 2.0\n\n depth_coords = cam_depth[:, :2].astype(np.int16)\n\n depth_map = np.zeros(resize_dims)\n valid_mask = ((depth_coords[:, 1] < resize_dims[0])\n & (depth_coords[:, 0] < resize_dims[1])\n & (depth_coords[:, 1] >= 0)\n & (depth_coords[:, 0] >= 0))\n depth_map[depth_coords[valid_mask, 1],\n depth_coords[valid_mask, 0]] = cam_depth[valid_mask, 2]\n\n return torch.Tensor(depth_map)\n\n def get_image(self, cam_infos, cams):\n \"\"\"Given data and cam_names, return image data needed.\n\n Args:\n sweeps_data (list): Raw data used to generate the data we needed.\n cams (list): Camera names.\n\n Returns:\n Tensor: Image data after processing.\n Tensor: Transformation matrix from camera to ego.\n Tensor: Intrinsic matrix.\n Tensor: Transformation matrix for ida.\n Tensor: Transformation matrix from key\n frame camera to sweep frame camera.\n Tensor: timestamps.\n dict: meta infos needed for evaluation.\n \"\"\"\n assert len(cam_infos) > 0\n sweep_imgs = list()\n sweep_sensor2ego_mats = list()\n sweep_intrin_mats = list()\n sweep_ida_mats = list()\n sweep_sensor2sensor_mats = list()\n sweep_timestamps = list()\n sweep_gt_depths = list()\n sweep_radar_points = list()\n for cam in cams:\n imgs = list()\n sensor2ego_mats = list()\n intrin_mats = list()\n ida_mats = list()\n sensor2sensor_mats = list()\n timestamps = list()\n gt_depths = list()\n radar_points = list()\n key_info = cam_infos[0]\n resize, resize_dims, crop, flip, \\\n rotate_ida = self.sample_ida_augmentation()\n radar_idx = self.sample_radar_augmentation()\n\n for sweep_idx, cam_info in enumerate(cam_infos):\n img = Image.open(\n os.path.join(self.data_root, cam_info[cam]['filename']))\n\n w, x, y, z = cam_info[cam]['calibrated_sensor']['rotation']\n # sweep sensor to sweep ego\n sweepsensor2sweepego_rot = torch.Tensor(\n Quaternion(w, x, y, z).rotation_matrix)\n sweepsensor2sweepego_tran = torch.Tensor(\n cam_info[cam]['calibrated_sensor']['translation'])\n sweepsensor2sweepego = sweepsensor2sweepego_rot.new_zeros(\n (4, 4))\n sweepsensor2sweepego[3, 3] = 1\n sweepsensor2sweepego[:3, :3] = sweepsensor2sweepego_rot\n sweepsensor2sweepego[:3, -1] = sweepsensor2sweepego_tran\n # sweep ego to global\n w, x, y, z = cam_info[cam]['ego_pose']['rotation']\n sweepego2global_rot = torch.Tensor(\n Quaternion(w, x, y, z).rotation_matrix)\n sweepego2global_tran = torch.Tensor(\n cam_info[cam]['ego_pose']['translation'])\n sweepego2global = sweepego2global_rot.new_zeros((4, 4))\n sweepego2global[3, 3] = 1\n sweepego2global[:3, :3] = sweepego2global_rot\n sweepego2global[:3, -1] = sweepego2global_tran\n\n # global sensor to cur ego\n w, x, y, z = key_info[cam]['ego_pose']['rotation']\n keyego2global_rot = torch.Tensor(\n Quaternion(w, x, y, z).rotation_matrix)\n keyego2global_tran = torch.Tensor(\n key_info[cam]['ego_pose']['translation'])\n keyego2global = keyego2global_rot.new_zeros((4, 4))\n keyego2global[3, 3] = 1\n keyego2global[:3, :3] = keyego2global_rot\n keyego2global[:3, -1] = keyego2global_tran\n global2keyego = keyego2global.inverse()\n\n # cur ego to sensor\n w, x, y, z = key_info[cam]['calibrated_sensor']['rotation']\n keysensor2keyego_rot = torch.Tensor(\n Quaternion(w, x, y, z).rotation_matrix)\n keysensor2keyego_tran = torch.Tensor(\n key_info[cam]['calibrated_sensor']['translation'])\n keysensor2keyego = keysensor2keyego_rot.new_zeros((4, 4))\n keysensor2keyego[3, 3] = 1\n keysensor2keyego[:3, :3] = keysensor2keyego_rot\n keysensor2keyego[:3, -1] = keysensor2keyego_tran\n keyego2keysensor = keysensor2keyego.inverse()\n keysensor2sweepsensor = (\n keyego2keysensor @ global2keyego @ sweepego2global\n @ sweepsensor2sweepego).inverse()\n sweepsensor2keyego = global2keyego @ sweepego2global @\\\n sweepsensor2sweepego\n sensor2ego_mats.append(sweepsensor2keyego)\n sensor2sensor_mats.append(keysensor2sweepsensor)\n intrin_mat = torch.zeros((4, 4))\n intrin_mat[3, 3] = 1\n intrin_mat[:3, :3] = torch.Tensor(\n cam_info[cam]['calibrated_sensor']['camera_intrinsic'])\n\n file_name = os.path.split(cam_info[cam]['filename'])[-1]\n if self.return_depth:\n point_depth = np.fromfile(os.path.join(\n self.data_root, self.depth_path, f'{file_name}.bin'),\n dtype=np.float32,\n count=-1)\n point_depth = point_depth.reshape(-1, 3)\n point_depth_augmented = self.depth_transform(\n point_depth, resize, self.ida_aug_conf['final_dim'],\n crop, flip, rotate_ida)\n gt_depths.append(point_depth_augmented)\n\n if self.return_radar_pv:\n radar_point = np.fromfile(os.path.join(\n self.data_root, self.radar_pv_path, f'{file_name}.bin'),\n dtype=np.float32,\n count=-1).reshape(-1, 7)\n radar_point_augmented = self.transform_radar_pv(\n radar_point, resize, self.ida_aug_conf['final_dim'],\n crop, flip, rotate_ida, radar_idx)\n radar_points.append(radar_point_augmented)\n\n img, ida_mat = img_transform(\n img,\n resize=resize,\n resize_dims=resize_dims,\n crop=crop,\n flip=flip,\n rotate=rotate_ida,\n )\n ida_mats.append(ida_mat)\n img = mmcv.imnormalize(np.array(img), self.img_mean,\n self.img_std, self.to_rgb)\n img = torch.from_numpy(img).permute(2, 0, 1)\n imgs.append(img)\n intrin_mats.append(intrin_mat)\n timestamps.append(cam_info[cam]['timestamp'])\n sweep_imgs.append(torch.stack(imgs))\n sweep_sensor2ego_mats.append(torch.stack(sensor2ego_mats))\n sweep_intrin_mats.append(torch.stack(intrin_mats))\n sweep_ida_mats.append(torch.stack(ida_mats))\n sweep_sensor2sensor_mats.append(torch.stack(sensor2sensor_mats))\n sweep_timestamps.append(torch.tensor(timestamps))\n if self.return_depth:\n sweep_gt_depths.append(torch.stack(gt_depths))\n if self.return_radar_pv:\n sweep_radar_points.append(torch.stack(radar_points))\n\n ret_list = [\n torch.stack(sweep_imgs).permute(1, 0, 2, 3, 4),\n torch.stack(sweep_sensor2ego_mats).permute(1, 0, 2, 3),\n torch.stack(sweep_intrin_mats).permute(1, 0, 2, 3),\n torch.stack(sweep_ida_mats).permute(1, 0, 2, 3),\n torch.stack(sweep_sensor2sensor_mats).permute(1, 0, 2, 3),\n torch.stack(sweep_timestamps).permute(1, 0),\n ]\n if self.return_depth:\n ret_list.append(torch.stack(sweep_gt_depths).permute(1, 0, 2, 3),)\n else:\n ret_list.append(None)\n if self.return_radar_pv:\n ret_list.append(torch.stack(sweep_radar_points).permute(1, 0, 2, 3),)\n else:\n ret_list.append(None)\n return ret_list\n\n def get_image_meta(self, cam_infos, cams):\n key_info = cam_infos[0]\n\n # Get mean pose of all cams.\n ego2global_rotation = np.mean(\n [key_info[cam]['ego_pose']['rotation'] for cam in cams], 0)\n ego2global_translation = np.mean(\n [key_info[cam]['ego_pose']['translation'] for cam in cams], 0)\n img_metas = dict(\n box_type_3d=LiDARInstance3DBoxes,\n ego2global_translation=ego2global_translation,\n ego2global_rotation=ego2global_rotation,\n )\n return img_metas\n\n def get_image_sensor2ego_mats(self, cam_infos, cams):\n sweep_sensor2ego_mats = list()\n for cam in cams:\n sensor2ego_mats = list()\n key_info = cam_infos[0]\n for sweep_idx, cam_info in enumerate(cam_infos):\n w, x, y, z = cam_info[cam]['calibrated_sensor']['rotation']\n # sweep sensor to sweep ego\n sweepsensor2sweepego_rot = torch.Tensor(\n Quaternion(w, x, y, z).rotation_matrix)\n sweepsensor2sweepego_tran = torch.Tensor(\n cam_info[cam]['calibrated_sensor']['translation'])\n sweepsensor2sweepego = sweepsensor2sweepego_rot.new_zeros(\n (4, 4))\n sweepsensor2sweepego[3, 3] = 1\n sweepsensor2sweepego[:3, :3] = sweepsensor2sweepego_rot\n sweepsensor2sweepego[:3, -1] = sweepsensor2sweepego_tran\n # sweep ego to global\n w, x, y, z = cam_info[cam]['ego_pose']['rotation']\n sweepego2global_rot = torch.Tensor(\n Quaternion(w, x, y, z).rotation_matrix)\n sweepego2global_tran = torch.Tensor(\n cam_info[cam]['ego_pose']['translation'])\n sweepego2global = sweepego2global_rot.new_zeros((4, 4))\n sweepego2global[3, 3] = 1\n sweepego2global[:3, :3] = sweepego2global_rot\n sweepego2global[:3, -1] = sweepego2global_tran\n\n # global sensor to cur ego\n w, x, y, z = key_info[cam]['ego_pose']['rotation']\n keyego2global_rot = torch.Tensor(\n Quaternion(w, x, y, z).rotation_matrix)\n keyego2global_tran = torch.Tensor(\n key_info[cam]['ego_pose']['translation'])\n keyego2global = keyego2global_rot.new_zeros((4, 4))\n keyego2global[3, 3] = 1\n keyego2global[:3, :3] = keyego2global_rot\n keyego2global[:3, -1] = keyego2global_tran\n global2keyego = keyego2global.inverse()\n\n # cur ego to sensor\n w, x, y, z = key_info[cam]['calibrated_sensor']['rotation']\n keysensor2keyego_rot = torch.Tensor(\n Quaternion(w, x, y, z).rotation_matrix)\n keysensor2keyego_tran = torch.Tensor(\n key_info[cam]['calibrated_sensor']['translation'])\n keysensor2keyego = keysensor2keyego_rot.new_zeros((4, 4))\n keysensor2keyego[3, 3] = 1\n keysensor2keyego[:3, :3] = keysensor2keyego_rot\n keysensor2keyego[:3, -1] = keysensor2keyego_tran\n sweepsensor2keyego = global2keyego @ sweepego2global @\\\n sweepsensor2sweepego\n sensor2ego_mats.append(sweepsensor2keyego)\n sweep_sensor2ego_mats.append(torch.stack(sensor2ego_mats))\n return torch.stack(sweep_sensor2ego_mats).permute(1, 0, 2, 3)\n\n def get_gt(self, info, cams, return_corners=False):\n \"\"\"Generate gt labels from info.\n\n Args:\n info(dict): Infos needed to generate gt labels.\n cams(list): Camera names.\n\n Returns:\n Tensor: GT bboxes.\n Tensor: GT labels.\n \"\"\"\n ego2global_rotation = np.mean(\n [info['cam_infos'][cam]['ego_pose']['rotation'] for cam in cams],\n 0)\n ego2global_translation = np.mean([\n info['cam_infos'][cam]['ego_pose']['translation'] for cam in cams\n ], 0)\n trans = -np.array(ego2global_translation)\n rot = Quaternion(ego2global_rotation).inverse\n gt_boxes = list()\n gt_labels = list()\n if return_corners: # for debugging and visualization\n gt_corners = list()\n else:\n gt_corners = None\n for ann_info in info['ann_infos']:\n # Use ego coordinate.\n if self.gt_for_radar_only:\n if ann_info['num_radar_pts'] == 0:\n continue\n if map_name_from_general_to_detection[ann_info['category_name']] not in self.classes:\n continue\n if ann_info['num_lidar_pts'] + ann_info['num_radar_pts'] == 0:\n continue\n\n box = Box(\n ann_info['translation'],\n ann_info['size'],\n Quaternion(ann_info['rotation']),\n velocity=ann_info['velocity'],\n )\n box.translate(trans)\n box.rotate(rot)\n box_xyz = np.array(box.center)\n box_dxdydz = np.array(box.wlh)[[1, 0, 2]]\n box_yaw = np.array([box.orientation.yaw_pitch_roll[0]])\n box_velo = np.array(box.velocity[:2])\n gt_box = np.concatenate([box_xyz, box_dxdydz, box_yaw, box_velo])\n gt_boxes.append(gt_box)\n gt_labels.append(\n self.classes.index(map_name_from_general_to_detection[\n ann_info['category_name']]))\n if return_corners: # for debugging and visualization\n gt_corners.append(box.corners())\n\n return torch.Tensor(gt_boxes), torch.tensor(gt_labels), gt_corners\n\n def choose_cams(self):\n \"\"\"Choose cameras randomly.\n\n Returns:\n list: Cameras to be used.\n \"\"\"\n if self.is_train and self.ida_aug_conf['Ncams'] < len(\n self.ida_aug_conf['cams']):\n cams = np.random.choice(self.ida_aug_conf['cams'],\n self.ida_aug_conf['Ncams'],\n replace=False)\n else:\n cams = self.ida_aug_conf['cams']\n return cams\n\n def __getitem__(self, idx):\n if self.use_cbgs:\n idx = self.sample_indices[idx]\n cam_infos = list()\n pts_infos = list()\n cams = self.choose_cams()\n for key_idx in self.key_idxes:\n cur_idx = key_idx + idx\n # Handle scenarios when current idx doesn't have previous key\n # frame or previous key frame is from another scene.\n while self.infos[cur_idx]['scene_token'] != self.infos[idx]['scene_token']:\n cur_idx += 1\n info = self.infos[cur_idx]\n cam_infos.append(info['cam_infos'])\n pts_infos.append([info['lidar_infos']] + info['lidar_sweeps'])\n for sweep_idx in self.sweeps_idx:\n if len(info['cam_sweeps']) == 0:\n cam_infos.append(info['cam_infos'])\n else:\n # Handle scenarios when current sweep doesn't have all cam keys.\n for i in range(min(len(info['cam_sweeps']) - 1, sweep_idx), -1,\n -1):\n if sum([cam in info['cam_sweeps'][i]\n for cam in cams]) == len(cams):\n cam_infos.append(info['cam_sweeps'][i])\n break\n\n if self.return_image or self.return_depth or self.return_radar_pv:\n image_data_list = self.get_image(cam_infos, cams)\n (\n sweep_imgs,\n sweep_sensor2ego_mats,\n sweep_intrins,\n sweep_ida_mats,\n sweep_sensor2sensor_mats,\n sweep_timestamps,\n ) = image_data_list[:6]\n else:\n (\n sweep_imgs,\n sweep_intrins,\n sweep_ida_mats,\n sweep_sensor2sensor_mats,\n sweep_timestamps,\n ) = None, None, None, None, None\n sweep_sensor2ego_mats = self.get_image_sensor2ego_mats(cam_infos, cams)\n\n img_metas = self.get_image_meta(cam_infos, cams)\n img_metas['token'] = self.infos[idx]['sample_token']\n gt_boxes_3d, gt_labels_3d, gt_corners = self.get_gt(self.infos[idx], cams, return_corners=False)\n\n rotate_bda, scale_bda, flip_dx, flip_dy = self.sample_bda_augmentation()\n gt_boxes_3d, bda_rot = bev_det_transform(gt_boxes_3d, rotate_bda, scale_bda, flip_dx, flip_dy)\n\n bda_mat = torch.zeros(4, 4, dtype=torch.float32)\n bda_mat[:3, :3] = bda_rot\n bda_mat[3, 3] = 1\n\n ret_list = [\n sweep_imgs,\n sweep_sensor2ego_mats,\n sweep_intrins,\n sweep_ida_mats,\n sweep_sensor2sensor_mats,\n bda_mat,\n sweep_timestamps,\n img_metas,\n gt_boxes_3d,\n gt_labels_3d,\n ]\n\n if self.return_depth:\n ret_list.append(image_data_list[6])\n else:\n ret_list.append(None)\n if self.return_radar_pv:\n ret_list.append(image_data_list[7])\n else:\n ret_list.append(None)\n\n return ret_list\n\n def __str__(self):\n return f\"\"\"NuscData: {len(self)} samples. Split: \\\n {\"train\" if self.is_train else \"val\"}.\n Augmentation Conf: {self.ida_aug_conf}\"\"\"\n\n def __len__(self):\n if self.use_cbgs:\n return len(self.sample_indices)\n else:\n return len(self.infos)"},{"identifier":"collate_fn","path":"datasets/nusc_det_dataset.py","snippet":"def collate_fn(data,\n is_return_image=True,\n is_return_depth=False,\n is_return_radar_pv=False):\n assert (is_return_image or is_return_depth or is_return_radar_pv) is True\n imgs_batch = list()\n sensor2ego_mats_batch = list()\n intrin_mats_batch = list()\n ida_mats_batch = list()\n sensor2sensor_mats_batch = list()\n bda_mat_batch = list()\n gt_boxes_3d_batch = list()\n gt_labels_3d_batch = list()\n img_metas_batch = list()\n depth_labels_batch = list()\n radar_pv_batch = list()\n\n for iter_data in data:\n (\n sweep_imgs,\n sweep_sensor2ego_mats,\n sweep_intrins,\n sweep_ida_mats,\n sweep_sensor2sensor_mats,\n bda_mat,\n sweep_timestamps,\n img_metas,\n gt_boxes,\n gt_labels,\n ) = iter_data[:10]\n if is_return_depth:\n gt_depth = iter_data[10]\n depth_labels_batch.append(gt_depth)\n if is_return_radar_pv:\n radar_pv = iter_data[11]\n radar_pv_batch.append(radar_pv)\n\n imgs_batch.append(sweep_imgs)\n sensor2ego_mats_batch.append(sweep_sensor2ego_mats)\n intrin_mats_batch.append(sweep_intrins)\n ida_mats_batch.append(sweep_ida_mats)\n sensor2sensor_mats_batch.append(sweep_sensor2sensor_mats)\n bda_mat_batch.append(bda_mat)\n img_metas_batch.append(img_metas)\n gt_boxes_3d_batch.append(gt_boxes)\n gt_labels_3d_batch.append(gt_labels)\n\n if is_return_image:\n mats_dict = dict()\n mats_dict['sensor2ego_mats'] = torch.stack(sensor2ego_mats_batch)\n mats_dict['intrin_mats'] = torch.stack(intrin_mats_batch)\n mats_dict['ida_mats'] = torch.stack(ida_mats_batch)\n mats_dict['sensor2sensor_mats'] = torch.stack(sensor2sensor_mats_batch)\n mats_dict['bda_mat'] = torch.stack(bda_mat_batch)\n ret_list = [\n torch.stack(imgs_batch),\n mats_dict,\n img_metas_batch,\n gt_boxes_3d_batch,\n gt_labels_3d_batch,\n None, # reserve for segmentation\n ]\n else:\n ret_list = [\n None,\n None,\n img_metas_batch,\n gt_boxes_3d_batch,\n gt_labels_3d_batch,\n None,\n ]\n if is_return_depth:\n ret_list.append(torch.stack(depth_labels_batch))\n else:\n ret_list.append(None)\n if is_return_radar_pv:\n ret_list.append(torch.stack(radar_pv_batch))\n else:\n ret_list.append(None)\n\n return ret_list"},{"identifier":"DetNuscEvaluator","path":"evaluators/det_evaluators.py","snippet":"class DetNuscEvaluator():\n ErrNameMapping = {\n 'trans_err': 'mATE',\n 'scale_err': 'mASE',\n 'orient_err': 'mAOE',\n 'vel_err': 'mAVE',\n 'attr_err': 'mAAE',\n }\n\n DefaultAttribute = {\n 'car': 'vehicle.parked',\n 'pedestrian': 'pedestrian.moving',\n 'trailer': 'vehicle.parked',\n 'truck': 'vehicle.parked',\n 'bus': 'vehicle.moving',\n 'motorcycle': 'cycle.without_rider',\n 'construction_vehicle': 'vehicle.parked',\n 'bicycle': 'cycle.without_rider',\n 'barrier': '',\n 'traffic_cone': '',\n }\n\n def __init__(\n self,\n class_names,\n eval_version='detection_cvpr_2019',\n data_root='./data/nuScenes',\n version='v1.0-trainval',\n modality=dict(use_lidar=False,\n use_camera=True,\n use_radar=True,\n use_map=False,\n use_external=False),\n output_dir=None,\n ) -> None:\n self.eval_version = eval_version\n self.data_root = data_root\n\n # Load config file and deserialize it.\n this_dir = osp.dirname(osp.abspath(__file__))\n with open(osp.join(this_dir, 'configs', '%s.json' % eval_version), 'r') as f:\n data = json.load(f)\n self.eval_detection_configs = DetectionConfig.deserialize(data)\n\n self.version = version\n self.class_names = class_names\n self.modality = modality\n self.output_dir = output_dir\n\n def _evaluate_single(self,\n result_path,\n logger=None,\n metric='bbox',\n result_name='pts_bbox'):\n \"\"\"Evaluation for a single model in nuScenes protocol.\n\n Args:\n result_path (str): Path of the result file.\n logger (logging.Logger | str | None): Logger used for printing\n related information during evaluation. Default: None.\n metric (str): Metric name used for evaluation. Default: 'bbox'.\n result_name (str): Result name in the metric prefix.\n Default: 'pts_bbox'.\n\n Returns:\n dict: Dictionary of evaluation details.\n \"\"\"\n from nuscenes import NuScenes\n from nuscenes.eval.detection.evaluate import NuScenesEval\n\n output_dir = osp.join(*osp.split(result_path)[:-1])\n nusc = NuScenes(version=self.version,\n dataroot=self.data_root,\n verbose=False)\n eval_set_map = {\n 'v1.0-mini': 'mini_val',\n 'v1.0-trainval': 'val',\n }\n nusc_eval = NuScenesEval(nusc,\n config=self.eval_detection_configs,\n result_path=result_path,\n eval_set=eval_set_map[self.version],\n output_dir=output_dir,\n verbose=False)\n nusc_eval.main(render_curves=False)\n # nusc_eval.main(render_curves=True, plot_examples=40)\n\n # record metrics\n metrics = mmcv.load(osp.join(output_dir, 'metrics_summary.json'))\n detail = dict()\n metric_prefix = f'{result_name}_NuScenes'\n for class_name in self.class_names:\n for k, v in metrics['label_aps'][class_name].items():\n val = float('{:.4f}'.format(v))\n detail['{}/{}_AP_dist_{}'.format(metric_prefix, class_name,\n k)] = val\n for k, v in metrics['label_tp_errors'][class_name].items():\n val = float('{:.4f}'.format(v))\n detail['{}/{}_{}'.format(metric_prefix, class_name, k)] = val\n for k, v in metrics['tp_errors'].items():\n val = float('{:.4f}'.format(v))\n detail['{}/{}'.format(metric_prefix,\n self.ErrNameMapping[k])] = val\n\n detail['{}/NDS'.format(metric_prefix)] = metrics['nd_score']\n detail['{}/mAP'.format(metric_prefix)] = metrics['mean_ap']\n return detail\n\n def format_results(self,\n results,\n img_metas,\n result_names=['img_bbox'],\n jsonfile_prefix=None,\n **kwargs):\n \"\"\"Format the results to json (standard format for COCO evaluation).\n\n Args:\n results (list[tuple | numpy.ndarray]): Testing results of the\n dataset.\n jsonfile_prefix (str | None): The prefix of json files. It includes\n the file path and the prefix of filename, e.g., \"a/b/prefix\".\n If not specified, a temp file will be created. Default: None.\n\n Returns:\n tuple: (result_files, tmp_dir), result_files is a dict containing \\\n the json filepaths, tmp_dir is the temporal directory created \\\n for saving json files when jsonfile_prefix is not specified.\n \"\"\"\n assert isinstance(results, list), 'results must be a list'\n\n if jsonfile_prefix is None:\n tmp_dir = tempfile.TemporaryDirectory()\n jsonfile_prefix = osp.join(tmp_dir.name, 'results')\n else:\n tmp_dir = None\n\n # currently the output prediction results could be in two formats\n # 1. list of dict('boxes_3d': ..., 'scores_3d': ..., 'labels_3d': ...)\n # 2. list of dict('pts_bbox' or 'img_bbox':\n # dict('boxes_3d': ..., 'scores_3d': ..., 'labels_3d': ...))\n # this is a workaround to enable evaluation of both formats on nuScenes\n # refer to https://github.com/open-mmlab/mmdetection3d/issues/449\n # should take the inner dict out of 'pts_bbox' or 'img_bbox' dict\n result_files = dict()\n # refactor this.\n for rasult_name in result_names:\n # not evaluate 2D predictions on nuScenes\n if '2d' in rasult_name:\n continue\n print(f'\\nFormating bboxes of {rasult_name}')\n tmp_file_ = osp.join(jsonfile_prefix, rasult_name)\n if self.output_dir:\n result_files.update({\n rasult_name:\n self._format_bbox(results, img_metas, self.output_dir)\n })\n else:\n result_files.update({\n rasult_name:\n self._format_bbox(results, img_metas, tmp_file_)\n })\n return result_files, tmp_dir\n\n def evaluate(\n self,\n results,\n img_metas,\n metric='bbox',\n logger=None,\n jsonfile_prefix=None,\n result_names=['img_bbox'],\n show=False,\n out_dir=None,\n pipeline=None,\n ):\n \"\"\"Evaluation in nuScenes protocol.\n\n Args:\n results (list[dict]): Testing results of the dataset.\n metric (str | list[str]): Metrics to be evaluated.\n logger (logging.Logger | str | None): Logger used for printing\n related information during evaluation. Default: None.\n jsonfile_prefix (str | None): The prefix of json files. It includes\n the file path and the prefix of filename, e.g., \"a/b/prefix\".\n If not specified, a temp file will be created. Default: None.\n show (bool): Whether to visualize.\n Default: False.\n out_dir (str): Path to save the visualization results.\n Default: None.\n pipeline (list[dict], optional): raw data loading for showing.\n Default: None.\n\n Returns:\n dict[str, float]: Results of each evaluation metric.\n \"\"\"\n result_files, tmp_dir = self.format_results(results, img_metas,\n result_names,\n jsonfile_prefix)\n if isinstance(result_files, dict):\n for name in result_names:\n print('Evaluating bboxes of {}'.format(name))\n print()\n self._evaluate_single(result_files[name])\n elif isinstance(result_files, str):\n self._evaluate_single(result_files)\n\n if tmp_dir is not None:\n tmp_dir.cleanup()\n\n def _format_bbox(self, results, img_metas, jsonfile_prefix=None):\n \"\"\"Convert the results to the standard format.\n\n Args:\n results (list[dict]): Testing results of the dataset.\n jsonfile_prefix (str): The prefix of the output jsonfile.\n You can specify the output directory/filename by\n modifying the jsonfile_prefix. Default: None.\n\n Returns:\n str: Path of the output json file.\n \"\"\"\n nusc_annos = {}\n mapped_class_names = self.class_names\n\n print('Start to convert detection format...')\n\n for sample_id, det in enumerate(mmcv.track_iter_progress(results)):\n boxes, scores, labels = det\n\n order = np.argsort(scores)[::-1]\n order = order[:500]\n\n boxes = boxes[order]\n scores = scores[order]\n labels = labels[order]\n\n sample_token = img_metas[sample_id]['token']\n trans = np.array(img_metas[sample_id]['ego2global_translation'])\n rot = Quaternion(img_metas[sample_id]['ego2global_rotation'])\n annos = list()\n for i, box in enumerate(boxes):\n name = mapped_class_names[labels[i]]\n center = box[:3]\n wlh = box[[4, 3, 5]]\n box_yaw = box[6]\n box_vel = box[7:].tolist()\n box_vel.append(0)\n quat = pyquaternion.Quaternion(axis=[0, 0, 1], radians=box_yaw)\n nusc_box = Box(center, wlh, quat, velocity=box_vel)\n nusc_box.rotate(rot)\n nusc_box.translate(trans)\n if np.sqrt(nusc_box.velocity[0]**2 +\n nusc_box.velocity[1]**2) > 0.2:\n if name in [\n 'car',\n 'construction_vehicle',\n 'bus',\n 'truck',\n 'trailer',\n ]:\n attr = 'vehicle.moving'\n elif name in ['bicycle', 'motorcycle']:\n attr = 'cycle.with_rider'\n else:\n attr = self.DefaultAttribute[name]\n else:\n if name in ['pedestrian']:\n attr = 'pedestrian.standing'\n elif name in ['bus']:\n attr = 'vehicle.stopped'\n else:\n attr = self.DefaultAttribute[name]\n nusc_anno = dict(\n sample_token=sample_token,\n translation=nusc_box.center.tolist(),\n size=nusc_box.wlh.tolist(),\n rotation=nusc_box.orientation.elements.tolist(),\n velocity=nusc_box.velocity[:2],\n detection_name=name,\n detection_score=float(scores[i]),\n attribute_name=attr,\n )\n annos.append(nusc_anno)\n # other views results of the same frame should be concatenated\n if sample_token in nusc_annos:\n nusc_annos[sample_token].extend(annos)\n else:\n nusc_annos[sample_token] = annos\n nusc_submissions = {\n 'meta': self.modality,\n 'results': nusc_annos,\n }\n mmcv.mkdir_or_exist(jsonfile_prefix)\n res_path = osp.join(jsonfile_prefix, 'results_nusc.json')\n print('Results writes to', res_path)\n mmcv.dump(nusc_submissions, res_path)\n return res_path"},{"identifier":"BaseBEVDepth","path":"models/base_bev_depth.py","snippet":"class BaseBEVDepth(nn.Module):\n \"\"\"Source code of `BEVDepth`, `https://arxiv.org/abs/2112.11790`.\n\n Args:\n backbone_conf (dict): Config of backbone.\n head_conf (dict): Config of head.\n \"\"\"\n\n def __init__(self, backbone_conf, head_conf):\n super(BaseBEVDepth, self).__init__()\n self.backbone_img = BaseLSSFPN(**backbone_conf)\n self.head = BEVDepthHead(**head_conf)\n\n # for inference time measurement\n self.idx = 0\n self.times_dict = {\n 'img': [],\n 'img_backbone': [],\n 'img_dep': [],\n 'img_transform': [],\n 'img_pool': [],\n\n 'head': [],\n 'head_backbone': [],\n 'head_head': [],\n }\n\n def forward(self,\n sweep_imgs,\n mats_dict,\n is_train=False\n ):\n \"\"\"Forward function for BEVDepth\n\n Args:\n sweep_imgs (Tensor): Input images.\n mats_dict(dict):\n sensor2ego_mats(Tensor): Transformation matrix from\n camera to ego with shape of (B, num_sweeps,\n num_cameras, 4, 4).\n intrin_mats(Tensor): Intrinsic matrix with shape\n of (B, num_sweeps, num_cameras, 4, 4).\n ida_mats(Tensor): Transformation matrix for ida with\n shape of (B, num_sweeps, num_cameras, 4, 4).\n sensor2sensor_mats(Tensor): Transformation matrix\n from key frame camera to sweep frame camera with\n shape of (B, num_sweeps, num_cameras, 4, 4).\n bda_mat(Tensor): Rotation matrix for bda with shape\n of (B, 4, 4).\n\n Returns:\n tuple(list[dict]): Output results for tasks.\n \"\"\"\n if is_train:\n self.time = None\n\n x, depth, _ = self.backbone_img(sweep_imgs, mats_dict,\n is_return_depth=True)\n preds, _ = self.head(x)\n return preds, depth\n else:\n if self.idx < 100: # skip few iterations for warmup\n self.times = None\n elif self.idx == 100:\n self.times = self.times_dict\n\n x, self.times = self.backbone_img(sweep_imgs, mats_dict,\n times=self.times)\n preds, self.times = self.head(x, times=self.times)\n\n if self.idx == 1000:\n time_mean = {}\n for k, v in self.times.items():\n time_mean[k] = sum(v) / len(v)\n print('img: %.2f' % time_mean['img'])\n print(' img_backbone: %.2f' % time_mean['img_backbone'])\n print(' img_dep: %.2f' % time_mean['img_dep'])\n print(' img_transform: %.2f' % time_mean['img_transform'])\n print(' img_pool: %.2f' % time_mean['img_pool'])\n print('head: %.2f' % time_mean['head'])\n print(' head_backbone: %.2f' % time_mean['head_backbone'])\n print(' head_head: %.2f' % time_mean['head_head'])\n total = time_mean['img'] + time_mean['head']\n print('total: %.2f' % total)\n print(' ')\n print('FPS: %.2f' % (1000/total))\n\n self.idx += 1\n return preds\n\n def get_targets(self, gt_boxes, gt_labels):\n \"\"\"Generate training targets for a single sample.\n\n Args:\n gt_bboxes_3d (:obj:`LiDARInstance3DBoxes`): Ground truth gt boxes.\n gt_labels_3d (torch.Tensor): Labels of boxes.\n\n Returns:\n tuple[list[torch.Tensor]]: Tuple of target including \\\n the following results in order.\n\n - list[torch.Tensor]: Heatmap scores.\n - list[torch.Tensor]: Ground truth boxes.\n - list[torch.Tensor]: Indexes indicating the position \\\n of the valid boxes.\n - list[torch.Tensor]: Masks indicating which boxes \\\n are valid.\n \"\"\"\n return self.head.get_targets(gt_boxes, gt_labels)\n\n def loss(self, targets, preds_dicts):\n \"\"\"Loss function for BEVDepth.\n\n Args:\n gt_bboxes_3d (list[:obj:`LiDARInstance3DBoxes`]): Ground\n truth gt boxes.\n gt_labels_3d (list[torch.Tensor]): Labels of boxes.\n preds_dicts (dict): Output of forward function.\n\n Returns:\n dict[str:torch.Tensor]: Loss of heatmap and bbox of each task.\n \"\"\"\n return self.head.loss(targets, preds_dicts)\n\n def get_bboxes(self, preds_dicts, img_metas=None, img=None, rescale=False):\n \"\"\"Generate bboxes from bbox head predictions.\n\n Args:\n preds_dicts (tuple[list[dict]]): Prediction results.\n img_metas (list[dict]): Point cloud and image's meta info.\n\n Returns:\n list[dict]: Decoded bbox, scores and labels after nms.\n \"\"\"\n return self.head.get_bboxes(preds_dicts, img_metas, img, rescale)"},{"identifier":"all_gather_object","path":"utils/torch_dist.py","snippet":"def all_gather_object(obj):\n world_size = get_world_size()\n if world_size < 2:\n return [obj]\n output = [None for _ in range(world_size)]\n dist.all_gather_object(output, obj)\n return output"},{"identifier":"synchronize","path":"utils/torch_dist.py","snippet":"def synchronize():\n \"\"\"Helper function to synchronize (barrier)\n among all processes when using distributed training\"\"\"\n if not dist.is_available():\n return\n if not dist.is_initialized():\n return\n current_world_size = dist.get_world_size()\n if current_world_size == 1:\n return\n dist.barrier()"}],"string":"[\n {\n \"identifier\": \"NuscDatasetRadarDet\",\n \"path\": \"datasets/nusc_det_dataset.py\",\n \"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 info_paths,\\n is_train,\\n load_interval=1,\\n num_sweeps=1,\\n img_conf=dict(img_mean=[123.675, 116.28, 103.53],\\n img_std=[58.395, 57.12, 57.375],\\n to_rgb=True),\\n img_backbone_conf=dict(\\n x_bound=[-51.2, 51.2, 0.8],\\n y_bound=[-51.2, 51.2, 0.8],\\n z_bound=[-5, 3, 8],\\n d_bound=[2.0, 58.0, 0.5]\\n ),\\n drop_aug_conf=None,\\n return_image=True,\\n return_depth=False,\\n return_radar_pv=False,\\n depth_path='depth_gt',\\n radar_pv_path='radar_pv_filter',\\n remove_z_axis=False,\\n use_cbgs=False,\\n gt_for_radar_only=False,\\n sweep_idxes=list(),\\n key_idxes=list()):\\n \\\"\\\"\\\"Dataset used for bevdetection task.\\n Args:\\n ida_aug_conf (dict): Config for ida augmentation.\\n bda_aug_conf (dict): Config for bda augmentation.\\n classes (list): Class names.\\n use_cbgs (bool): Whether to use cbgs strategy,\\n Default: False.\\n num_sweeps (int): Number of sweeps to be used for each sample.\\n default: 1.\\n img_conf (dict): Config for image.\\n return_depth (bool): Whether to use depth gt.\\n default: False.\\n sweep_idxes (list): List of sweep idxes to be used.\\n default: list().\\n key_idxes (list): List of key idxes to be used.\\n default: list().\\n \\\"\\\"\\\"\\n super().__init__()\\n if isinstance(info_paths, list):\\n self.infos = list()\\n for info_path in info_paths:\\n self.infos.extend(mmcv.load(info_path))\\n else:\\n self.infos = mmcv.load(info_paths)\\n self.is_train = is_train\\n self.ida_aug_conf = ida_aug_conf\\n self.bda_aug_conf = bda_aug_conf\\n self.rda_aug_conf = rda_aug_conf\\n self.drop_aug_conf = drop_aug_conf\\n self.data_root = data_root\\n self.classes = classes\\n self.use_cbgs = use_cbgs\\n if self.use_cbgs:\\n self.cat2id = {name: i for i, name in enumerate(self.classes)}\\n self.sample_indices = self._get_sample_indices()\\n self.num_sweeps = num_sweeps\\n self.img_mean = np.array(img_conf['img_mean'], np.float32)\\n self.img_std = np.array(img_conf['img_std'], np.float32)\\n self.to_rgb = img_conf['to_rgb']\\n self.img_backbone_conf = img_backbone_conf\\n\\n self.return_image = return_image\\n self.return_depth = return_depth\\n self.return_radar_pv = return_radar_pv\\n\\n self.remove_z_axis = remove_z_axis\\n self.gt_for_radar_only = gt_for_radar_only\\n\\n assert sum([sweep_idx >= 0 for sweep_idx in sweep_idxes]) \\\\\\n == len(sweep_idxes), 'All `sweep_idxes` must greater \\\\\\n than or equal to 0.'\\n\\n self.sweeps_idx = sweep_idxes\\n assert sum([key_idx < 0 for key_idx in key_idxes]) == len(key_idxes),\\\\\\n 'All `key_idxes` must less than 0.'\\n self.key_idxes = [0] + key_idxes\\n if load_interval > 1:\\n self.infos = self.infos[::load_interval]\\n self.depth_path = depth_path\\n self.radar_pv_path = radar_pv_path\\n\\n self.max_radar_points_pv = 1536\\n self.max_distance_pv = self.img_backbone_conf['d_bound'][1]\\n\\n def _get_sample_indices(self):\\n \\\"\\\"\\\"Load annotations from ann_file.\\n\\n Args:\\n ann_file (str): Path of the annotation file.\\n\\n Returns:\\n list[dict]: List of annotations after class sampling.\\n \\\"\\\"\\\"\\n class_sample_idxs = {cat_id: [] for cat_id in self.cat2id.values()}\\n for idx, info in enumerate(self.infos):\\n gt_names = set(\\n [ann_info['category_name'] for ann_info in info['ann_infos']])\\n for gt_name in gt_names:\\n gt_name = map_name_from_general_to_detection[gt_name]\\n if gt_name not in self.classes:\\n continue\\n class_sample_idxs[self.cat2id[gt_name]].append(idx)\\n duplicated_samples = sum(\\n [len(v) for _, v in class_sample_idxs.items()])\\n class_distribution = {\\n k: len(v) / duplicated_samples\\n for k, v in class_sample_idxs.items()\\n }\\n\\n sample_indices = []\\n\\n frac = 1.0 / len(self.classes)\\n ratios = [frac / v for v in class_distribution.values()]\\n for cls_inds, ratio in zip(list(class_sample_idxs.values()), ratios):\\n sample_indices += np.random.choice(cls_inds,\\n int(len(cls_inds) *\\n ratio)).tolist()\\n return sample_indices\\n\\n def sample_ida_augmentation(self):\\n \\\"\\\"\\\"Generate ida augmentation values based on ida_config.\\\"\\\"\\\"\\n H, W = self.ida_aug_conf['H'], self.ida_aug_conf['W']\\n fH, fW = self.ida_aug_conf['final_dim']\\n if self.is_train:\\n resize = np.random.uniform(*self.ida_aug_conf['resize_lim'])\\n resize_dims = (int(W * resize), int(H * resize))\\n newW, newH = resize_dims\\n crop_h = int(\\n (1 - np.random.uniform(*self.ida_aug_conf['bot_pct_lim'])) *\\n newH) - fH\\n crop_w = int(np.random.uniform(0, max(0, newW - fW)))\\n crop = (crop_w, crop_h, crop_w + fW, crop_h + fH)\\n flip = False\\n if self.ida_aug_conf['rand_flip'] and np.random.choice([0, 1]):\\n flip = True\\n rotate_ida = np.random.uniform(*self.ida_aug_conf['rot_lim'])\\n else:\\n resize = max(fH / H, fW / W)\\n resize_dims = (int(W * resize), int(H * resize))\\n newW, newH = resize_dims\\n crop_h = int(\\n (1 - np.mean(self.ida_aug_conf['bot_pct_lim'])) * newH) - fH\\n crop_w = int(max(0, newW - fW) / 2)\\n crop = (crop_w, crop_h, crop_w + fW, crop_h + fH)\\n flip = False\\n rotate_ida = 0\\n return resize, resize_dims, crop, flip, rotate_ida\\n\\n def sample_bda_augmentation(self):\\n \\\"\\\"\\\"Generate bda augmentation values based on bda_config.\\\"\\\"\\\"\\n if self.is_train:\\n if np.random.uniform() < self.bda_aug_conf['rot_ratio']:\\n rotate_bda = np.random.uniform(*self.bda_aug_conf['rot_lim'])\\n else:\\n rotate_bda = 0\\n scale_bda = np.random.uniform(*self.bda_aug_conf['scale_lim'])\\n flip_dx = np.random.uniform() < self.bda_aug_conf['flip_dx_ratio']\\n flip_dy = np.random.uniform() < self.bda_aug_conf['flip_dy_ratio']\\n else:\\n rotate_bda = 0\\n scale_bda = 1.0\\n flip_dx = False\\n flip_dy = False\\n return rotate_bda, scale_bda, flip_dx, flip_dy\\n\\n def sample_radar_augmentation(self):\\n \\\"\\\"\\\"Generate bda augmentation values based on bda_config.\\\"\\\"\\\"\\n if self.is_train:\\n radar_idx = np.random.choice(self.rda_aug_conf['N_sweeps'],\\n self.rda_aug_conf['N_use'],\\n replace=False)\\n else:\\n radar_idx = np.arange(self.rda_aug_conf['N_sweeps'])\\n return radar_idx\\n\\n def transform_radar_pv(self, points, resize, resize_dims, crop, flip, rotate, radar_idx):\\n points = points[points[:, 2] < self.max_distance_pv, :]\\n\\n H, W = resize_dims\\n points[:, :2] = points[:, :2] * resize\\n points[:, 0] -= crop[0]\\n points[:, 1] -= crop[1]\\n if flip:\\n points[:, 0] = resize_dims[1] - points[:, 0]\\n\\n points[:, 0] -= W / 2.0\\n points[:, 1] -= H / 2.0\\n\\n h = rotate / 180 * np.pi\\n rot_matrix = [\\n [np.cos(h), np.sin(h)],\\n [-np.sin(h), np.cos(h)],\\n ]\\n points[:, :2] = np.matmul(rot_matrix, points[:, :2].T).T\\n\\n points[:, 0] += W / 2.0\\n points[:, 1] += H / 2.0\\n\\n depth_coords = points[:, :2].astype(np.int16)\\n\\n valid_mask = ((depth_coords[:, 1] < resize_dims[0])\\n & (depth_coords[:, 0] < resize_dims[1])\\n & (depth_coords[:, 1] >= 0)\\n & (depth_coords[:, 0] >= 0))\\n\\n points = torch.Tensor(points[valid_mask])\\n\\n if self.remove_z_axis:\\n points[:, 1] = 1. # dummy height value\\n\\n points_save = []\\n for i in radar_idx:\\n points_save.append(points[points[:, 6] == i])\\n points = torch.cat(points_save, dim=0)\\n\\n # mean, std of rcs and speed are from train set\\n points[:, 3] = (points[:, 3] - 4.783) / 7.576\\n points[:, 4] = (torch.norm(points[:, 4:6], dim=1) - 0.677) / 1.976\\n\\n if self.is_train:\\n drop_idx = np.random.uniform(size=points.shape[0]) # randomly drop points\\n points = points[drop_idx > self.rda_aug_conf['drop_ratio']]\\n\\n num_points, num_feat = points.shape\\n if num_points > self.max_radar_points_pv:\\n choices = np.random.choice(num_points, self.max_radar_points_pv, replace=False)\\n points = points[choices]\\n else:\\n num_append = self.max_radar_points_pv - num_points\\n points = torch.cat([points, -999*torch.ones(num_append, num_feat)], dim=0)\\n\\n if num_points == 0:\\n points[0, :] = points.new_tensor([0.1, 0.1, self.max_distance_pv-1, 0, 0, 0, 0])\\n\\n points[..., [0, 1, 2]] = points[..., [0, 2, 1]] # convert [w, h, d] to [w, d, h]\\n\\n return points[..., :5]\\n\\n def depth_transform(self, cam_depth, resize, resize_dims, crop, flip, rotate):\\n \\\"\\\"\\\"Transform depth based on ida augmentation configuration.\\n\\n Args:\\n cam_depth (np array): Nx3, 3: x,y,d.\\n resize (float): Resize factor.\\n resize_dims (tuple): Final dimension.\\n crop (tuple): x1, y1, x2, y2\\n flip (bool): Whether to flip.\\n rotate (float): Rotation value.\\n\\n Returns:\\n np array: [h/down_ratio, w/down_ratio, d]\\n \\\"\\\"\\\"\\n valid_depth = cam_depth[:, 2] < self.img_backbone_conf['d_bound'][1]\\n cam_depth = cam_depth[valid_depth, :]\\n\\n H, W = resize_dims\\n cam_depth[:, :2] = cam_depth[:, :2] * resize\\n cam_depth[:, 0] -= crop[0]\\n cam_depth[:, 1] -= crop[1]\\n if flip:\\n cam_depth[:, 0] = resize_dims[1] - cam_depth[:, 0]\\n\\n cam_depth[:, 0] -= W / 2.0\\n cam_depth[:, 1] -= H / 2.0\\n\\n h = rotate / 180 * np.pi\\n rot_matrix = [\\n [np.cos(h), np.sin(h)],\\n [-np.sin(h), np.cos(h)],\\n ]\\n cam_depth[:, :2] = np.matmul(rot_matrix, cam_depth[:, :2].T).T\\n\\n cam_depth[:, 0] += W / 2.0\\n cam_depth[:, 1] += H / 2.0\\n\\n depth_coords = cam_depth[:, :2].astype(np.int16)\\n\\n depth_map = np.zeros(resize_dims)\\n valid_mask = ((depth_coords[:, 1] < resize_dims[0])\\n & (depth_coords[:, 0] < resize_dims[1])\\n & (depth_coords[:, 1] >= 0)\\n & (depth_coords[:, 0] >= 0))\\n depth_map[depth_coords[valid_mask, 1],\\n depth_coords[valid_mask, 0]] = cam_depth[valid_mask, 2]\\n\\n return torch.Tensor(depth_map)\\n\\n def get_image(self, cam_infos, cams):\\n \\\"\\\"\\\"Given data and cam_names, return image data needed.\\n\\n Args:\\n sweeps_data (list): Raw data used to generate the data we needed.\\n cams (list): Camera names.\\n\\n Returns:\\n Tensor: Image data after processing.\\n Tensor: Transformation matrix from camera to ego.\\n Tensor: Intrinsic matrix.\\n Tensor: Transformation matrix for ida.\\n Tensor: Transformation matrix from key\\n frame camera to sweep frame camera.\\n Tensor: timestamps.\\n dict: meta infos needed for evaluation.\\n \\\"\\\"\\\"\\n assert len(cam_infos) > 0\\n sweep_imgs = list()\\n sweep_sensor2ego_mats = list()\\n sweep_intrin_mats = list()\\n sweep_ida_mats = list()\\n sweep_sensor2sensor_mats = list()\\n sweep_timestamps = list()\\n sweep_gt_depths = list()\\n sweep_radar_points = list()\\n for cam in cams:\\n imgs = list()\\n sensor2ego_mats = list()\\n intrin_mats = list()\\n ida_mats = list()\\n sensor2sensor_mats = list()\\n timestamps = list()\\n gt_depths = list()\\n radar_points = list()\\n key_info = cam_infos[0]\\n resize, resize_dims, crop, flip, \\\\\\n rotate_ida = self.sample_ida_augmentation()\\n radar_idx = self.sample_radar_augmentation()\\n\\n for sweep_idx, cam_info in enumerate(cam_infos):\\n img = Image.open(\\n os.path.join(self.data_root, cam_info[cam]['filename']))\\n\\n w, x, y, z = cam_info[cam]['calibrated_sensor']['rotation']\\n # sweep sensor to sweep ego\\n sweepsensor2sweepego_rot = torch.Tensor(\\n Quaternion(w, x, y, z).rotation_matrix)\\n sweepsensor2sweepego_tran = torch.Tensor(\\n cam_info[cam]['calibrated_sensor']['translation'])\\n sweepsensor2sweepego = sweepsensor2sweepego_rot.new_zeros(\\n (4, 4))\\n sweepsensor2sweepego[3, 3] = 1\\n sweepsensor2sweepego[:3, :3] = sweepsensor2sweepego_rot\\n sweepsensor2sweepego[:3, -1] = sweepsensor2sweepego_tran\\n # sweep ego to global\\n w, x, y, z = cam_info[cam]['ego_pose']['rotation']\\n sweepego2global_rot = torch.Tensor(\\n Quaternion(w, x, y, z).rotation_matrix)\\n sweepego2global_tran = torch.Tensor(\\n cam_info[cam]['ego_pose']['translation'])\\n sweepego2global = sweepego2global_rot.new_zeros((4, 4))\\n sweepego2global[3, 3] = 1\\n sweepego2global[:3, :3] = sweepego2global_rot\\n sweepego2global[:3, -1] = sweepego2global_tran\\n\\n # global sensor to cur ego\\n w, x, y, z = key_info[cam]['ego_pose']['rotation']\\n keyego2global_rot = torch.Tensor(\\n Quaternion(w, x, y, z).rotation_matrix)\\n keyego2global_tran = torch.Tensor(\\n key_info[cam]['ego_pose']['translation'])\\n keyego2global = keyego2global_rot.new_zeros((4, 4))\\n keyego2global[3, 3] = 1\\n keyego2global[:3, :3] = keyego2global_rot\\n keyego2global[:3, -1] = keyego2global_tran\\n global2keyego = keyego2global.inverse()\\n\\n # cur ego to sensor\\n w, x, y, z = key_info[cam]['calibrated_sensor']['rotation']\\n keysensor2keyego_rot = torch.Tensor(\\n Quaternion(w, x, y, z).rotation_matrix)\\n keysensor2keyego_tran = torch.Tensor(\\n key_info[cam]['calibrated_sensor']['translation'])\\n keysensor2keyego = keysensor2keyego_rot.new_zeros((4, 4))\\n keysensor2keyego[3, 3] = 1\\n keysensor2keyego[:3, :3] = keysensor2keyego_rot\\n keysensor2keyego[:3, -1] = keysensor2keyego_tran\\n keyego2keysensor = keysensor2keyego.inverse()\\n keysensor2sweepsensor = (\\n keyego2keysensor @ global2keyego @ sweepego2global\\n @ sweepsensor2sweepego).inverse()\\n sweepsensor2keyego = global2keyego @ sweepego2global @\\\\\\n sweepsensor2sweepego\\n sensor2ego_mats.append(sweepsensor2keyego)\\n sensor2sensor_mats.append(keysensor2sweepsensor)\\n intrin_mat = torch.zeros((4, 4))\\n intrin_mat[3, 3] = 1\\n intrin_mat[:3, :3] = torch.Tensor(\\n cam_info[cam]['calibrated_sensor']['camera_intrinsic'])\\n\\n file_name = os.path.split(cam_info[cam]['filename'])[-1]\\n if self.return_depth:\\n point_depth = np.fromfile(os.path.join(\\n self.data_root, self.depth_path, f'{file_name}.bin'),\\n dtype=np.float32,\\n count=-1)\\n point_depth = point_depth.reshape(-1, 3)\\n point_depth_augmented = self.depth_transform(\\n point_depth, resize, self.ida_aug_conf['final_dim'],\\n crop, flip, rotate_ida)\\n gt_depths.append(point_depth_augmented)\\n\\n if self.return_radar_pv:\\n radar_point = np.fromfile(os.path.join(\\n self.data_root, self.radar_pv_path, f'{file_name}.bin'),\\n dtype=np.float32,\\n count=-1).reshape(-1, 7)\\n radar_point_augmented = self.transform_radar_pv(\\n radar_point, resize, self.ida_aug_conf['final_dim'],\\n crop, flip, rotate_ida, radar_idx)\\n radar_points.append(radar_point_augmented)\\n\\n img, ida_mat = img_transform(\\n img,\\n resize=resize,\\n resize_dims=resize_dims,\\n crop=crop,\\n flip=flip,\\n rotate=rotate_ida,\\n )\\n ida_mats.append(ida_mat)\\n img = mmcv.imnormalize(np.array(img), self.img_mean,\\n self.img_std, self.to_rgb)\\n img = torch.from_numpy(img).permute(2, 0, 1)\\n imgs.append(img)\\n intrin_mats.append(intrin_mat)\\n timestamps.append(cam_info[cam]['timestamp'])\\n sweep_imgs.append(torch.stack(imgs))\\n sweep_sensor2ego_mats.append(torch.stack(sensor2ego_mats))\\n sweep_intrin_mats.append(torch.stack(intrin_mats))\\n sweep_ida_mats.append(torch.stack(ida_mats))\\n sweep_sensor2sensor_mats.append(torch.stack(sensor2sensor_mats))\\n sweep_timestamps.append(torch.tensor(timestamps))\\n if self.return_depth:\\n sweep_gt_depths.append(torch.stack(gt_depths))\\n if self.return_radar_pv:\\n sweep_radar_points.append(torch.stack(radar_points))\\n\\n ret_list = [\\n torch.stack(sweep_imgs).permute(1, 0, 2, 3, 4),\\n torch.stack(sweep_sensor2ego_mats).permute(1, 0, 2, 3),\\n torch.stack(sweep_intrin_mats).permute(1, 0, 2, 3),\\n torch.stack(sweep_ida_mats).permute(1, 0, 2, 3),\\n torch.stack(sweep_sensor2sensor_mats).permute(1, 0, 2, 3),\\n torch.stack(sweep_timestamps).permute(1, 0),\\n ]\\n if self.return_depth:\\n ret_list.append(torch.stack(sweep_gt_depths).permute(1, 0, 2, 3),)\\n else:\\n ret_list.append(None)\\n if self.return_radar_pv:\\n ret_list.append(torch.stack(sweep_radar_points).permute(1, 0, 2, 3),)\\n else:\\n ret_list.append(None)\\n return ret_list\\n\\n def get_image_meta(self, cam_infos, cams):\\n key_info = cam_infos[0]\\n\\n # Get mean pose of all cams.\\n ego2global_rotation = np.mean(\\n [key_info[cam]['ego_pose']['rotation'] for cam in cams], 0)\\n ego2global_translation = np.mean(\\n [key_info[cam]['ego_pose']['translation'] for cam in cams], 0)\\n img_metas = dict(\\n box_type_3d=LiDARInstance3DBoxes,\\n ego2global_translation=ego2global_translation,\\n ego2global_rotation=ego2global_rotation,\\n )\\n return img_metas\\n\\n def get_image_sensor2ego_mats(self, cam_infos, cams):\\n sweep_sensor2ego_mats = list()\\n for cam in cams:\\n sensor2ego_mats = list()\\n key_info = cam_infos[0]\\n for sweep_idx, cam_info in enumerate(cam_infos):\\n w, x, y, z = cam_info[cam]['calibrated_sensor']['rotation']\\n # sweep sensor to sweep ego\\n sweepsensor2sweepego_rot = torch.Tensor(\\n Quaternion(w, x, y, z).rotation_matrix)\\n sweepsensor2sweepego_tran = torch.Tensor(\\n cam_info[cam]['calibrated_sensor']['translation'])\\n sweepsensor2sweepego = sweepsensor2sweepego_rot.new_zeros(\\n (4, 4))\\n sweepsensor2sweepego[3, 3] = 1\\n sweepsensor2sweepego[:3, :3] = sweepsensor2sweepego_rot\\n sweepsensor2sweepego[:3, -1] = sweepsensor2sweepego_tran\\n # sweep ego to global\\n w, x, y, z = cam_info[cam]['ego_pose']['rotation']\\n sweepego2global_rot = torch.Tensor(\\n Quaternion(w, x, y, z).rotation_matrix)\\n sweepego2global_tran = torch.Tensor(\\n cam_info[cam]['ego_pose']['translation'])\\n sweepego2global = sweepego2global_rot.new_zeros((4, 4))\\n sweepego2global[3, 3] = 1\\n sweepego2global[:3, :3] = sweepego2global_rot\\n sweepego2global[:3, -1] = sweepego2global_tran\\n\\n # global sensor to cur ego\\n w, x, y, z = key_info[cam]['ego_pose']['rotation']\\n keyego2global_rot = torch.Tensor(\\n Quaternion(w, x, y, z).rotation_matrix)\\n keyego2global_tran = torch.Tensor(\\n key_info[cam]['ego_pose']['translation'])\\n keyego2global = keyego2global_rot.new_zeros((4, 4))\\n keyego2global[3, 3] = 1\\n keyego2global[:3, :3] = keyego2global_rot\\n keyego2global[:3, -1] = keyego2global_tran\\n global2keyego = keyego2global.inverse()\\n\\n # cur ego to sensor\\n w, x, y, z = key_info[cam]['calibrated_sensor']['rotation']\\n keysensor2keyego_rot = torch.Tensor(\\n Quaternion(w, x, y, z).rotation_matrix)\\n keysensor2keyego_tran = torch.Tensor(\\n key_info[cam]['calibrated_sensor']['translation'])\\n keysensor2keyego = keysensor2keyego_rot.new_zeros((4, 4))\\n keysensor2keyego[3, 3] = 1\\n keysensor2keyego[:3, :3] = keysensor2keyego_rot\\n keysensor2keyego[:3, -1] = keysensor2keyego_tran\\n sweepsensor2keyego = global2keyego @ sweepego2global @\\\\\\n sweepsensor2sweepego\\n sensor2ego_mats.append(sweepsensor2keyego)\\n sweep_sensor2ego_mats.append(torch.stack(sensor2ego_mats))\\n return torch.stack(sweep_sensor2ego_mats).permute(1, 0, 2, 3)\\n\\n def get_gt(self, info, cams, return_corners=False):\\n \\\"\\\"\\\"Generate gt labels from info.\\n\\n Args:\\n info(dict): Infos needed to generate gt labels.\\n cams(list): Camera names.\\n\\n Returns:\\n Tensor: GT bboxes.\\n Tensor: GT labels.\\n \\\"\\\"\\\"\\n ego2global_rotation = np.mean(\\n [info['cam_infos'][cam]['ego_pose']['rotation'] for cam in cams],\\n 0)\\n ego2global_translation = np.mean([\\n info['cam_infos'][cam]['ego_pose']['translation'] for cam in cams\\n ], 0)\\n trans = -np.array(ego2global_translation)\\n rot = Quaternion(ego2global_rotation).inverse\\n gt_boxes = list()\\n gt_labels = list()\\n if return_corners: # for debugging and visualization\\n gt_corners = list()\\n else:\\n gt_corners = None\\n for ann_info in info['ann_infos']:\\n # Use ego coordinate.\\n if self.gt_for_radar_only:\\n if ann_info['num_radar_pts'] == 0:\\n continue\\n if map_name_from_general_to_detection[ann_info['category_name']] not in self.classes:\\n continue\\n if ann_info['num_lidar_pts'] + ann_info['num_radar_pts'] == 0:\\n continue\\n\\n box = Box(\\n ann_info['translation'],\\n ann_info['size'],\\n Quaternion(ann_info['rotation']),\\n velocity=ann_info['velocity'],\\n )\\n box.translate(trans)\\n box.rotate(rot)\\n box_xyz = np.array(box.center)\\n box_dxdydz = np.array(box.wlh)[[1, 0, 2]]\\n box_yaw = np.array([box.orientation.yaw_pitch_roll[0]])\\n box_velo = np.array(box.velocity[:2])\\n gt_box = np.concatenate([box_xyz, box_dxdydz, box_yaw, box_velo])\\n gt_boxes.append(gt_box)\\n gt_labels.append(\\n self.classes.index(map_name_from_general_to_detection[\\n ann_info['category_name']]))\\n if return_corners: # for debugging and visualization\\n gt_corners.append(box.corners())\\n\\n return torch.Tensor(gt_boxes), torch.tensor(gt_labels), gt_corners\\n\\n def choose_cams(self):\\n \\\"\\\"\\\"Choose cameras randomly.\\n\\n Returns:\\n list: Cameras to be used.\\n \\\"\\\"\\\"\\n if self.is_train and self.ida_aug_conf['Ncams'] < len(\\n self.ida_aug_conf['cams']):\\n cams = np.random.choice(self.ida_aug_conf['cams'],\\n self.ida_aug_conf['Ncams'],\\n replace=False)\\n else:\\n cams = self.ida_aug_conf['cams']\\n return cams\\n\\n def __getitem__(self, idx):\\n if self.use_cbgs:\\n idx = self.sample_indices[idx]\\n cam_infos = list()\\n pts_infos = list()\\n cams = self.choose_cams()\\n for key_idx in self.key_idxes:\\n cur_idx = key_idx + idx\\n # Handle scenarios when current idx doesn't have previous key\\n # frame or previous key frame is from another scene.\\n while self.infos[cur_idx]['scene_token'] != self.infos[idx]['scene_token']:\\n cur_idx += 1\\n info = self.infos[cur_idx]\\n cam_infos.append(info['cam_infos'])\\n pts_infos.append([info['lidar_infos']] + info['lidar_sweeps'])\\n for sweep_idx in self.sweeps_idx:\\n if len(info['cam_sweeps']) == 0:\\n cam_infos.append(info['cam_infos'])\\n else:\\n # Handle scenarios when current sweep doesn't have all cam keys.\\n for i in range(min(len(info['cam_sweeps']) - 1, sweep_idx), -1,\\n -1):\\n if sum([cam in info['cam_sweeps'][i]\\n for cam in cams]) == len(cams):\\n cam_infos.append(info['cam_sweeps'][i])\\n break\\n\\n if self.return_image or self.return_depth or self.return_radar_pv:\\n image_data_list = self.get_image(cam_infos, cams)\\n (\\n sweep_imgs,\\n sweep_sensor2ego_mats,\\n sweep_intrins,\\n sweep_ida_mats,\\n sweep_sensor2sensor_mats,\\n sweep_timestamps,\\n ) = image_data_list[:6]\\n else:\\n (\\n sweep_imgs,\\n sweep_intrins,\\n sweep_ida_mats,\\n sweep_sensor2sensor_mats,\\n sweep_timestamps,\\n ) = None, None, None, None, None\\n sweep_sensor2ego_mats = self.get_image_sensor2ego_mats(cam_infos, cams)\\n\\n img_metas = self.get_image_meta(cam_infos, cams)\\n img_metas['token'] = self.infos[idx]['sample_token']\\n gt_boxes_3d, gt_labels_3d, gt_corners = self.get_gt(self.infos[idx], cams, return_corners=False)\\n\\n rotate_bda, scale_bda, flip_dx, flip_dy = self.sample_bda_augmentation()\\n gt_boxes_3d, bda_rot = bev_det_transform(gt_boxes_3d, rotate_bda, scale_bda, flip_dx, flip_dy)\\n\\n bda_mat = torch.zeros(4, 4, dtype=torch.float32)\\n bda_mat[:3, :3] = bda_rot\\n bda_mat[3, 3] = 1\\n\\n ret_list = [\\n sweep_imgs,\\n sweep_sensor2ego_mats,\\n sweep_intrins,\\n sweep_ida_mats,\\n sweep_sensor2sensor_mats,\\n bda_mat,\\n sweep_timestamps,\\n img_metas,\\n gt_boxes_3d,\\n gt_labels_3d,\\n ]\\n\\n if self.return_depth:\\n ret_list.append(image_data_list[6])\\n else:\\n ret_list.append(None)\\n if self.return_radar_pv:\\n ret_list.append(image_data_list[7])\\n else:\\n ret_list.append(None)\\n\\n return ret_list\\n\\n def __str__(self):\\n return f\\\"\\\"\\\"NuscData: {len(self)} samples. Split: \\\\\\n {\\\"train\\\" if self.is_train else \\\"val\\\"}.\\n Augmentation Conf: {self.ida_aug_conf}\\\"\\\"\\\"\\n\\n def __len__(self):\\n if self.use_cbgs:\\n return len(self.sample_indices)\\n else:\\n return len(self.infos)\"\n },\n {\n \"identifier\": \"collate_fn\",\n \"path\": \"datasets/nusc_det_dataset.py\",\n \"snippet\": \"def collate_fn(data,\\n is_return_image=True,\\n is_return_depth=False,\\n is_return_radar_pv=False):\\n assert (is_return_image or is_return_depth or is_return_radar_pv) is True\\n imgs_batch = list()\\n sensor2ego_mats_batch = list()\\n intrin_mats_batch = list()\\n ida_mats_batch = list()\\n sensor2sensor_mats_batch = list()\\n bda_mat_batch = list()\\n gt_boxes_3d_batch = list()\\n gt_labels_3d_batch = list()\\n img_metas_batch = list()\\n depth_labels_batch = list()\\n radar_pv_batch = list()\\n\\n for iter_data in data:\\n (\\n sweep_imgs,\\n sweep_sensor2ego_mats,\\n sweep_intrins,\\n sweep_ida_mats,\\n sweep_sensor2sensor_mats,\\n bda_mat,\\n sweep_timestamps,\\n img_metas,\\n gt_boxes,\\n gt_labels,\\n ) = iter_data[:10]\\n if is_return_depth:\\n gt_depth = iter_data[10]\\n depth_labels_batch.append(gt_depth)\\n if is_return_radar_pv:\\n radar_pv = iter_data[11]\\n radar_pv_batch.append(radar_pv)\\n\\n imgs_batch.append(sweep_imgs)\\n sensor2ego_mats_batch.append(sweep_sensor2ego_mats)\\n intrin_mats_batch.append(sweep_intrins)\\n ida_mats_batch.append(sweep_ida_mats)\\n sensor2sensor_mats_batch.append(sweep_sensor2sensor_mats)\\n bda_mat_batch.append(bda_mat)\\n img_metas_batch.append(img_metas)\\n gt_boxes_3d_batch.append(gt_boxes)\\n gt_labels_3d_batch.append(gt_labels)\\n\\n if is_return_image:\\n mats_dict = dict()\\n mats_dict['sensor2ego_mats'] = torch.stack(sensor2ego_mats_batch)\\n mats_dict['intrin_mats'] = torch.stack(intrin_mats_batch)\\n mats_dict['ida_mats'] = torch.stack(ida_mats_batch)\\n mats_dict['sensor2sensor_mats'] = torch.stack(sensor2sensor_mats_batch)\\n mats_dict['bda_mat'] = torch.stack(bda_mat_batch)\\n ret_list = [\\n torch.stack(imgs_batch),\\n mats_dict,\\n img_metas_batch,\\n gt_boxes_3d_batch,\\n gt_labels_3d_batch,\\n None, # reserve for segmentation\\n ]\\n else:\\n ret_list = [\\n None,\\n None,\\n img_metas_batch,\\n gt_boxes_3d_batch,\\n gt_labels_3d_batch,\\n None,\\n ]\\n if is_return_depth:\\n ret_list.append(torch.stack(depth_labels_batch))\\n else:\\n ret_list.append(None)\\n if is_return_radar_pv:\\n ret_list.append(torch.stack(radar_pv_batch))\\n else:\\n ret_list.append(None)\\n\\n return ret_list\"\n },\n {\n \"identifier\": \"DetNuscEvaluator\",\n \"path\": \"evaluators/det_evaluators.py\",\n \"snippet\": \"class DetNuscEvaluator():\\n ErrNameMapping = {\\n 'trans_err': 'mATE',\\n 'scale_err': 'mASE',\\n 'orient_err': 'mAOE',\\n 'vel_err': 'mAVE',\\n 'attr_err': 'mAAE',\\n }\\n\\n DefaultAttribute = {\\n 'car': 'vehicle.parked',\\n 'pedestrian': 'pedestrian.moving',\\n 'trailer': 'vehicle.parked',\\n 'truck': 'vehicle.parked',\\n 'bus': 'vehicle.moving',\\n 'motorcycle': 'cycle.without_rider',\\n 'construction_vehicle': 'vehicle.parked',\\n 'bicycle': 'cycle.without_rider',\\n 'barrier': '',\\n 'traffic_cone': '',\\n }\\n\\n def __init__(\\n self,\\n class_names,\\n eval_version='detection_cvpr_2019',\\n data_root='./data/nuScenes',\\n version='v1.0-trainval',\\n modality=dict(use_lidar=False,\\n use_camera=True,\\n use_radar=True,\\n use_map=False,\\n use_external=False),\\n output_dir=None,\\n ) -> None:\\n self.eval_version = eval_version\\n self.data_root = data_root\\n\\n # Load config file and deserialize it.\\n this_dir = osp.dirname(osp.abspath(__file__))\\n with open(osp.join(this_dir, 'configs', '%s.json' % eval_version), 'r') as f:\\n data = json.load(f)\\n self.eval_detection_configs = DetectionConfig.deserialize(data)\\n\\n self.version = version\\n self.class_names = class_names\\n self.modality = modality\\n self.output_dir = output_dir\\n\\n def _evaluate_single(self,\\n result_path,\\n logger=None,\\n metric='bbox',\\n result_name='pts_bbox'):\\n \\\"\\\"\\\"Evaluation for a single model in nuScenes protocol.\\n\\n Args:\\n result_path (str): Path of the result file.\\n logger (logging.Logger | str | None): Logger used for printing\\n related information during evaluation. Default: None.\\n metric (str): Metric name used for evaluation. Default: 'bbox'.\\n result_name (str): Result name in the metric prefix.\\n Default: 'pts_bbox'.\\n\\n Returns:\\n dict: Dictionary of evaluation details.\\n \\\"\\\"\\\"\\n from nuscenes import NuScenes\\n from nuscenes.eval.detection.evaluate import NuScenesEval\\n\\n output_dir = osp.join(*osp.split(result_path)[:-1])\\n nusc = NuScenes(version=self.version,\\n dataroot=self.data_root,\\n verbose=False)\\n eval_set_map = {\\n 'v1.0-mini': 'mini_val',\\n 'v1.0-trainval': 'val',\\n }\\n nusc_eval = NuScenesEval(nusc,\\n config=self.eval_detection_configs,\\n result_path=result_path,\\n eval_set=eval_set_map[self.version],\\n output_dir=output_dir,\\n verbose=False)\\n nusc_eval.main(render_curves=False)\\n # nusc_eval.main(render_curves=True, plot_examples=40)\\n\\n # record metrics\\n metrics = mmcv.load(osp.join(output_dir, 'metrics_summary.json'))\\n detail = dict()\\n metric_prefix = f'{result_name}_NuScenes'\\n for class_name in self.class_names:\\n for k, v in metrics['label_aps'][class_name].items():\\n val = float('{:.4f}'.format(v))\\n detail['{}/{}_AP_dist_{}'.format(metric_prefix, class_name,\\n k)] = val\\n for k, v in metrics['label_tp_errors'][class_name].items():\\n val = float('{:.4f}'.format(v))\\n detail['{}/{}_{}'.format(metric_prefix, class_name, k)] = val\\n for k, v in metrics['tp_errors'].items():\\n val = float('{:.4f}'.format(v))\\n detail['{}/{}'.format(metric_prefix,\\n self.ErrNameMapping[k])] = val\\n\\n detail['{}/NDS'.format(metric_prefix)] = metrics['nd_score']\\n detail['{}/mAP'.format(metric_prefix)] = metrics['mean_ap']\\n return detail\\n\\n def format_results(self,\\n results,\\n img_metas,\\n result_names=['img_bbox'],\\n jsonfile_prefix=None,\\n **kwargs):\\n \\\"\\\"\\\"Format the results to json (standard format for COCO evaluation).\\n\\n Args:\\n results (list[tuple | numpy.ndarray]): Testing results of the\\n dataset.\\n jsonfile_prefix (str | None): The prefix of json files. It includes\\n the file path and the prefix of filename, e.g., \\\"a/b/prefix\\\".\\n If not specified, a temp file will be created. Default: None.\\n\\n Returns:\\n tuple: (result_files, tmp_dir), result_files is a dict containing \\\\\\n the json filepaths, tmp_dir is the temporal directory created \\\\\\n for saving json files when jsonfile_prefix is not specified.\\n \\\"\\\"\\\"\\n assert isinstance(results, list), 'results must be a list'\\n\\n if jsonfile_prefix is None:\\n tmp_dir = tempfile.TemporaryDirectory()\\n jsonfile_prefix = osp.join(tmp_dir.name, 'results')\\n else:\\n tmp_dir = None\\n\\n # currently the output prediction results could be in two formats\\n # 1. list of dict('boxes_3d': ..., 'scores_3d': ..., 'labels_3d': ...)\\n # 2. list of dict('pts_bbox' or 'img_bbox':\\n # dict('boxes_3d': ..., 'scores_3d': ..., 'labels_3d': ...))\\n # this is a workaround to enable evaluation of both formats on nuScenes\\n # refer to https://github.com/open-mmlab/mmdetection3d/issues/449\\n # should take the inner dict out of 'pts_bbox' or 'img_bbox' dict\\n result_files = dict()\\n # refactor this.\\n for rasult_name in result_names:\\n # not evaluate 2D predictions on nuScenes\\n if '2d' in rasult_name:\\n continue\\n print(f'\\\\nFormating bboxes of {rasult_name}')\\n tmp_file_ = osp.join(jsonfile_prefix, rasult_name)\\n if self.output_dir:\\n result_files.update({\\n rasult_name:\\n self._format_bbox(results, img_metas, self.output_dir)\\n })\\n else:\\n result_files.update({\\n rasult_name:\\n self._format_bbox(results, img_metas, tmp_file_)\\n })\\n return result_files, tmp_dir\\n\\n def evaluate(\\n self,\\n results,\\n img_metas,\\n metric='bbox',\\n logger=None,\\n jsonfile_prefix=None,\\n result_names=['img_bbox'],\\n show=False,\\n out_dir=None,\\n pipeline=None,\\n ):\\n \\\"\\\"\\\"Evaluation in nuScenes protocol.\\n\\n Args:\\n results (list[dict]): Testing results of the dataset.\\n metric (str | list[str]): Metrics to be evaluated.\\n logger (logging.Logger | str | None): Logger used for printing\\n related information during evaluation. Default: None.\\n jsonfile_prefix (str | None): The prefix of json files. It includes\\n the file path and the prefix of filename, e.g., \\\"a/b/prefix\\\".\\n If not specified, a temp file will be created. Default: None.\\n show (bool): Whether to visualize.\\n Default: False.\\n out_dir (str): Path to save the visualization results.\\n Default: None.\\n pipeline (list[dict], optional): raw data loading for showing.\\n Default: None.\\n\\n Returns:\\n dict[str, float]: Results of each evaluation metric.\\n \\\"\\\"\\\"\\n result_files, tmp_dir = self.format_results(results, img_metas,\\n result_names,\\n jsonfile_prefix)\\n if isinstance(result_files, dict):\\n for name in result_names:\\n print('Evaluating bboxes of {}'.format(name))\\n print()\\n self._evaluate_single(result_files[name])\\n elif isinstance(result_files, str):\\n self._evaluate_single(result_files)\\n\\n if tmp_dir is not None:\\n tmp_dir.cleanup()\\n\\n def _format_bbox(self, results, img_metas, jsonfile_prefix=None):\\n \\\"\\\"\\\"Convert the results to the standard format.\\n\\n Args:\\n results (list[dict]): Testing results of the dataset.\\n jsonfile_prefix (str): The prefix of the output jsonfile.\\n You can specify the output directory/filename by\\n modifying the jsonfile_prefix. Default: None.\\n\\n Returns:\\n str: Path of the output json file.\\n \\\"\\\"\\\"\\n nusc_annos = {}\\n mapped_class_names = self.class_names\\n\\n print('Start to convert detection format...')\\n\\n for sample_id, det in enumerate(mmcv.track_iter_progress(results)):\\n boxes, scores, labels = det\\n\\n order = np.argsort(scores)[::-1]\\n order = order[:500]\\n\\n boxes = boxes[order]\\n scores = scores[order]\\n labels = labels[order]\\n\\n sample_token = img_metas[sample_id]['token']\\n trans = np.array(img_metas[sample_id]['ego2global_translation'])\\n rot = Quaternion(img_metas[sample_id]['ego2global_rotation'])\\n annos = list()\\n for i, box in enumerate(boxes):\\n name = mapped_class_names[labels[i]]\\n center = box[:3]\\n wlh = box[[4, 3, 5]]\\n box_yaw = box[6]\\n box_vel = box[7:].tolist()\\n box_vel.append(0)\\n quat = pyquaternion.Quaternion(axis=[0, 0, 1], radians=box_yaw)\\n nusc_box = Box(center, wlh, quat, velocity=box_vel)\\n nusc_box.rotate(rot)\\n nusc_box.translate(trans)\\n if np.sqrt(nusc_box.velocity[0]**2 +\\n nusc_box.velocity[1]**2) > 0.2:\\n if name in [\\n 'car',\\n 'construction_vehicle',\\n 'bus',\\n 'truck',\\n 'trailer',\\n ]:\\n attr = 'vehicle.moving'\\n elif name in ['bicycle', 'motorcycle']:\\n attr = 'cycle.with_rider'\\n else:\\n attr = self.DefaultAttribute[name]\\n else:\\n if name in ['pedestrian']:\\n attr = 'pedestrian.standing'\\n elif name in ['bus']:\\n attr = 'vehicle.stopped'\\n else:\\n attr = self.DefaultAttribute[name]\\n nusc_anno = dict(\\n sample_token=sample_token,\\n translation=nusc_box.center.tolist(),\\n size=nusc_box.wlh.tolist(),\\n rotation=nusc_box.orientation.elements.tolist(),\\n velocity=nusc_box.velocity[:2],\\n detection_name=name,\\n detection_score=float(scores[i]),\\n attribute_name=attr,\\n )\\n annos.append(nusc_anno)\\n # other views results of the same frame should be concatenated\\n if sample_token in nusc_annos:\\n nusc_annos[sample_token].extend(annos)\\n else:\\n nusc_annos[sample_token] = annos\\n nusc_submissions = {\\n 'meta': self.modality,\\n 'results': nusc_annos,\\n }\\n mmcv.mkdir_or_exist(jsonfile_prefix)\\n res_path = osp.join(jsonfile_prefix, 'results_nusc.json')\\n print('Results writes to', res_path)\\n mmcv.dump(nusc_submissions, res_path)\\n return res_path\"\n },\n {\n \"identifier\": \"BaseBEVDepth\",\n \"path\": \"models/base_bev_depth.py\",\n \"snippet\": \"class BaseBEVDepth(nn.Module):\\n \\\"\\\"\\\"Source code of `BEVDepth`, `https://arxiv.org/abs/2112.11790`.\\n\\n Args:\\n backbone_conf (dict): Config of backbone.\\n head_conf (dict): Config of head.\\n \\\"\\\"\\\"\\n\\n def __init__(self, backbone_conf, head_conf):\\n super(BaseBEVDepth, self).__init__()\\n self.backbone_img = BaseLSSFPN(**backbone_conf)\\n self.head = BEVDepthHead(**head_conf)\\n\\n # for inference time measurement\\n self.idx = 0\\n self.times_dict = {\\n 'img': [],\\n 'img_backbone': [],\\n 'img_dep': [],\\n 'img_transform': [],\\n 'img_pool': [],\\n\\n 'head': [],\\n 'head_backbone': [],\\n 'head_head': [],\\n }\\n\\n def forward(self,\\n sweep_imgs,\\n mats_dict,\\n is_train=False\\n ):\\n \\\"\\\"\\\"Forward function for BEVDepth\\n\\n Args:\\n sweep_imgs (Tensor): Input images.\\n mats_dict(dict):\\n sensor2ego_mats(Tensor): Transformation matrix from\\n camera to ego with shape of (B, num_sweeps,\\n num_cameras, 4, 4).\\n intrin_mats(Tensor): Intrinsic matrix with shape\\n of (B, num_sweeps, num_cameras, 4, 4).\\n ida_mats(Tensor): Transformation matrix for ida with\\n shape of (B, num_sweeps, num_cameras, 4, 4).\\n sensor2sensor_mats(Tensor): Transformation matrix\\n from key frame camera to sweep frame camera with\\n shape of (B, num_sweeps, num_cameras, 4, 4).\\n bda_mat(Tensor): Rotation matrix for bda with shape\\n of (B, 4, 4).\\n\\n Returns:\\n tuple(list[dict]): Output results for tasks.\\n \\\"\\\"\\\"\\n if is_train:\\n self.time = None\\n\\n x, depth, _ = self.backbone_img(sweep_imgs, mats_dict,\\n is_return_depth=True)\\n preds, _ = self.head(x)\\n return preds, depth\\n else:\\n if self.idx < 100: # skip few iterations for warmup\\n self.times = None\\n elif self.idx == 100:\\n self.times = self.times_dict\\n\\n x, self.times = self.backbone_img(sweep_imgs, mats_dict,\\n times=self.times)\\n preds, self.times = self.head(x, times=self.times)\\n\\n if self.idx == 1000:\\n time_mean = {}\\n for k, v in self.times.items():\\n time_mean[k] = sum(v) / len(v)\\n print('img: %.2f' % time_mean['img'])\\n print(' img_backbone: %.2f' % time_mean['img_backbone'])\\n print(' img_dep: %.2f' % time_mean['img_dep'])\\n print(' img_transform: %.2f' % time_mean['img_transform'])\\n print(' img_pool: %.2f' % time_mean['img_pool'])\\n print('head: %.2f' % time_mean['head'])\\n print(' head_backbone: %.2f' % time_mean['head_backbone'])\\n print(' head_head: %.2f' % time_mean['head_head'])\\n total = time_mean['img'] + time_mean['head']\\n print('total: %.2f' % total)\\n print(' ')\\n print('FPS: %.2f' % (1000/total))\\n\\n self.idx += 1\\n return preds\\n\\n def get_targets(self, gt_boxes, gt_labels):\\n \\\"\\\"\\\"Generate training targets for a single sample.\\n\\n Args:\\n gt_bboxes_3d (:obj:`LiDARInstance3DBoxes`): Ground truth gt boxes.\\n gt_labels_3d (torch.Tensor): Labels of boxes.\\n\\n Returns:\\n tuple[list[torch.Tensor]]: Tuple of target including \\\\\\n the following results in order.\\n\\n - list[torch.Tensor]: Heatmap scores.\\n - list[torch.Tensor]: Ground truth boxes.\\n - list[torch.Tensor]: Indexes indicating the position \\\\\\n of the valid boxes.\\n - list[torch.Tensor]: Masks indicating which boxes \\\\\\n are valid.\\n \\\"\\\"\\\"\\n return self.head.get_targets(gt_boxes, gt_labels)\\n\\n def loss(self, targets, preds_dicts):\\n \\\"\\\"\\\"Loss function for BEVDepth.\\n\\n Args:\\n gt_bboxes_3d (list[:obj:`LiDARInstance3DBoxes`]): Ground\\n truth gt boxes.\\n gt_labels_3d (list[torch.Tensor]): Labels of boxes.\\n preds_dicts (dict): Output of forward function.\\n\\n Returns:\\n dict[str:torch.Tensor]: Loss of heatmap and bbox of each task.\\n \\\"\\\"\\\"\\n return self.head.loss(targets, preds_dicts)\\n\\n def get_bboxes(self, preds_dicts, img_metas=None, img=None, rescale=False):\\n \\\"\\\"\\\"Generate bboxes from bbox head predictions.\\n\\n Args:\\n preds_dicts (tuple[list[dict]]): Prediction results.\\n img_metas (list[dict]): Point cloud and image's meta info.\\n\\n Returns:\\n list[dict]: Decoded bbox, scores and labels after nms.\\n \\\"\\\"\\\"\\n return self.head.get_bboxes(preds_dicts, img_metas, img, rescale)\"\n },\n {\n \"identifier\": \"all_gather_object\",\n \"path\": \"utils/torch_dist.py\",\n \"snippet\": \"def all_gather_object(obj):\\n world_size = get_world_size()\\n if world_size < 2:\\n return [obj]\\n output = [None for _ in range(world_size)]\\n dist.all_gather_object(output, obj)\\n return output\"\n },\n {\n \"identifier\": \"synchronize\",\n \"path\": \"utils/torch_dist.py\",\n \"snippet\": \"def synchronize():\\n \\\"\\\"\\\"Helper function to synchronize (barrier)\\n among all processes when using distributed training\\\"\\\"\\\"\\n if not dist.is_available():\\n return\\n if not dist.is_initialized():\\n return\\n current_world_size = dist.get_world_size()\\n if current_world_size == 1:\\n return\\n dist.barrier()\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from functools import partial\nfrom pytorch_lightning.core import LightningModule\nfrom torch.cuda.amp.autocast_mode import autocast\nfrom torch.optim.lr_scheduler import MultiStepLR\nfrom mmcv.runner import build_optimizer\nfrom datasets.nusc_det_dataset import NuscDatasetRadarDet, collate_fn\nfrom evaluators.det_evaluators import DetNuscEvaluator\nfrom models.base_bev_depth import BaseBEVDepth\nfrom utils.torch_dist import all_gather_object, synchronize\nimport mmcv\nimport torch\nimport torch.nn.functional as F\nimport torch.nn.parallel\nimport torch.utils.data\nimport torch.utils.data.distributed\nimport torchvision.models as models"},"token_num":{"kind":"number","value":16010,"string":"16,010"},"cropped_code":{"kind":"string","value":" -1, self.depth_channels + 1)[:, 1:]\n return gt_depths.float()\n\n def eval_step(self, batch, batch_idx, prefix: str):\n (sweep_imgs, mats, img_metas, _, _, _, _, pts_pv) = batch\n if torch.cuda.is_available():\n if self.return_image:\n sweep_imgs = sweep_imgs.cuda()\n for key, value in mats.items():\n mats[key] = value.cuda()\n if self.return_radar_pv:\n pts_pv = pts_pv.cuda()\n preds = self(sweep_imgs, mats,\n pts_pv=pts_pv,\n is_train=False)\n if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):\n results = self.model.module.get_bboxes(preds, img_metas)\n else:\n results = self.model.get_bboxes(preds, img_metas)\n for i in range(len(results)):\n results[i][0] = results[i][0].tensor.detach().cpu().numpy()\n results[i][1] = results[i][1].detach().cpu().numpy()\n results[i][2] = results[i][2].detach().cpu().numpy()\n results[i].append(img_metas[i])\n return results\n\n def validation_epoch_end(self, validation_step_outputs):\n detection_losses = list()\n heatmap_losses = list()\n bbox_losses = list()\n depth_losses = list()\n for validation_step_output in validation_step_outputs:\n detection_losses.append(validation_step_output[0])\n heatmap_losses.append(validation_step_output[1])\n bbox_losses.append(validation_step_output[2])\n depth_losses.append(validation_step_output[3])\n synchronize()\n\n self.log('val/detection', torch.mean(torch.stack(detection_losses)), on_epoch=True)\n self.log('val/heatmap', torch.mean(torch.stack(heatmap_losses)), on_epoch=True)\n self.log('val/bbox', torch.mean(torch.stack(bbox_losses)), on_epoch=True)\n self.log('val/depth', torch.mean(torch.stack(depth_losses)), on_epoch=True)\n\n def validation_step(self, batch, batch_idx):\n (sweep_imgs, mats, _, gt_boxes_3d, gt_labels_3d, _, depth_labels, pts_pv) = batch\n if torch.cuda.is_available():\n if self.return_image:\n sweep_imgs = sweep_imgs.cuda()\n for key, value in mats.items():\n mats[key] = value.cuda()\n if self.return_radar_pv:\n pts_pv = pts_pv.cuda()\n gt_boxes_3d = [gt_box.cuda() for gt_box in gt_boxes_3d]\n gt_labels_3d = [gt_label.cuda() for gt_label in gt_labels_3d]\n with torch.no_grad():\n preds, depth_preds = self(sweep_imgs, mats,\n pts_pv=pts_pv,\n is_train=True)\n targets = self.model.get_targets(gt_boxes_3d, gt_labels_3d)\n loss_detection, loss_heatmap, loss_bbox = self.model.loss(targets, preds)\n\n if len(depth_labels.shape) == 5:\n # only key-frame will calculate depth loss\n depth_labels = depth_labels[:, 0, ...].contiguous()\n loss_depth = self.get_depth_loss(depth_labels.cuda(), depth_preds, weight=3.)\n return loss_detection, loss_heatmap, loss_bbox, loss_depth\n\n def test_epoch_end(self, test_step_outputs):\n all_pred_results = list()\n all_img_metas = list()\n for test_step_output in test_step_outputs:\n for i in range(len(test_step_output)):\n all_pred_results.append(test_step_output[i][:3])\n all_img_metas.append(test_step_output[i][3])\n synchronize()\n # TODO: Change another way.\n dataset_length = len(self.val_dataloader().dataset)\n all_pred_results = sum(\n map(list, zip(*all_gather_object(all_pred_results))),\n [])[:dataset_length]\n all_img_metas = sum(map(list, zip(*all_gather_object(all_img_metas))),\n [])[:dataset_length]\n if self.global_rank == 0:\n self.evaluator.evaluate(all_pred_results, all_img_metas)\n\n def configure_optimizers(self):\n optimizer = build_optimizer(self.model, self.optimizer_config)\n scheduler = MultiStepLR(optimizer, [19, 23])\n return [[optimizer], [scheduler]]\n\n def train_dataloader(self):\n train_dataset = NuscDatasetRadarDet(\n ida_aug_conf=self.ida_aug_conf,\n bda_aug_conf=self.bda_aug_conf,\n rda_aug_conf=self.rda_aug_conf,\n img_backbone_conf=self.backbone_img_conf,\n classes=self.class_names,\n data_root=self.data_root,\n info_paths=self.train_info_paths,\n is_train=True,\n use_cbgs=self.data_use_cbgs,\n img_conf=self.img_conf,\n load_interval=self.load_interval,\n num_sweeps=self.num_sweeps,\n sweep_idxes=self.sweep_idxes,\n key_idxes=self.key_idxes,\n return_image=self.return_image,\n return_depth=self.return_depth,\n return_radar_pv=self.return_radar_pv,\n remove_z_axis=self.remove_z_axis,\n depth_path='depth_gt',\n radar_pv_path='radar_pv_filter'\n )\n\n train_loader = torch.utils.data.DataLoader(\n train_dataset,\n batch_size=self.batch_size_per_device,\n num_workers=4,\n drop_last=True,\n shuffle=False,\n"},"all_code":{"kind":"string","value":"# Copyright (c) Megvii Inc. All rights reserved.\n\n\n\npretrain_config = dict(\n img_model_path=None,\n img_load_key=[],\n img_freeze_key=None,\n pts_model_path=None,\n pts_load_key=[])\n\noptimizer_config = dict(\n type='AdamW',\n lr=2e-4,\n weight_decay=1e-2)\n\nH = 900\nW = 1600\nfinal_dim = (256, 704)\nimg_conf = dict(img_mean=[123.675, 116.28, 103.53],\n img_std=[58.395, 57.12, 57.375],\n to_rgb=True)\n\nida_aug_conf = {\n 'resize_lim': (0.386, 0.55),\n 'final_dim': final_dim,\n 'rot_lim': (-5.4, 5.4),\n 'H': 900,\n 'W': 1600,\n 'rand_flip': True,\n 'bot_pct_lim': (0.0, 0.0),\n 'cams': ['CAM_FRONT_LEFT', 'CAM_FRONT', 'CAM_FRONT_RIGHT',\n 'CAM_BACK_LEFT', 'CAM_BACK', 'CAM_BACK_RIGHT'],\n 'Ncams': 6,\n}\nbda_aug_conf = {\n 'rot_ratio': 1.0,\n 'rot_lim': (-22.5, 22.5),\n 'scale_lim': (0.95, 1.05),\n 'flip_dx_ratio': 0.5,\n 'flip_dy_ratio': 0.5\n}\nrda_aug_conf = {\n 'N_sweeps': 6,\n 'N_use': 5,\n 'drop_ratio': 0.1,\n}\n\nbackbone_img_conf = {\n 'x_bound': [-51.2, 51.2, 0.8],\n 'y_bound': [-51.2, 51.2, 0.8],\n 'z_bound': [-5, 3, 8],\n 'd_bound': [2.0, 58.0, 0.8],\n 'final_dim': final_dim,\n 'output_channels': 80,\n 'downsample_factor': 16,\n 'img_backbone_conf': dict(\n type='ResNet',\n depth=50,\n frozen_stages=0,\n out_indices=[0, 1, 2, 3],\n norm_eval=False,\n init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),\n ),\n 'img_neck_conf': dict(\n type='SECONDFPN',\n in_channels=[256, 512, 1024, 2048],\n upsample_strides=[0.25, 0.5, 1, 2],\n out_channels=[128, 128, 128, 128],\n ),\n 'depth_net_conf':\n dict(in_channels=512, mid_channels=512),\n 'camera_aware': True\n}\n\nCLASSES = [\n 'car', 'truck', 'construction_vehicle', 'bus', 'trailer',\n 'barrier', 'motorcycle', 'bicycle', 'pedestrian', 'traffic_cone',\n]\n\nhead_conf = {\n 'bev_backbone_conf': dict(\n type='ResNet',\n in_channels=80,\n depth=18,\n num_stages=3,\n strides=(1, 2, 2),\n dilations=(1, 1, 1),\n out_indices=[0, 1, 2],\n norm_eval=False,\n base_channels=160),\n 'bev_neck_conf': dict(\n type='SECONDFPN',\n in_channels=[80, 160, 320, 640],\n upsample_strides=[1, 2, 4, 8],\n out_channels=[64, 64, 64, 64]),\n 'tasks': [\n dict(num_class=1, class_names=['car']),\n dict(num_class=2, class_names=['truck', 'construction_vehicle']),\n dict(num_class=2, class_names=['bus', 'trailer']),\n dict(num_class=1, class_names=['barrier']),\n dict(num_class=2, class_names=['motorcycle', 'bicycle']),\n dict(num_class=2, class_names=['pedestrian', 'traffic_cone']),],\n 'common_heads': dict(\n reg=(2, 2), height=(1, 2), dim=(3, 2), rot=(2, 2), vel=(2, 2)),\n 'bbox_coder': dict(\n type='CenterPointBBoxCoder',\n post_center_range=[-61.2, -61.2, -10.0, 61.2, 61.2, 10.0],\n max_num=500,\n score_threshold=0.1,\n out_size_factor=4,\n voxel_size=[0.2, 0.2, 8],\n pc_range=[-51.2, -51.2, -5, 51.2, 51.2, 3],\n code_size=9),\n 'train_cfg': dict(\n point_cloud_range=[-51.2, -51.2, -5, 51.2, 51.2, 3],\n grid_size=[512, 512, 1],\n voxel_size=[0.2, 0.2, 8],\n out_size_factor=4,\n dense_reg=1,\n gaussian_overlap=0.1,\n max_objs=500,\n min_radius=2,\n code_weights=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5, 0.5]),\n 'test_cfg': dict(\n post_center_limit_range=[-61.2, -61.2, -10.0, 61.2, 61.2, 10.0],\n max_per_img=500,\n max_pool_nms=False,\n min_radius=[4, 12, 10, 1, 0.85, 0.175],\n score_threshold=0.1,\n out_size_factor=4,\n voxel_size=[0.2, 0.2, 8],\n nms_type='circle',\n pre_max_size=1000,\n post_max_size=83,\n nms_thr=0.2),\n 'in_channels': 256, # Equal to bev_neck output_channels.\n 'loss_cls': dict(type='GaussianFocalLoss', reduction='mean'),\n 'loss_bbox': dict(type='L1Loss', reduction='mean', loss_weight=0.25),\n 'gaussian_overlap': 0.1,\n 'min_radius': 2,\n}\n\n\nclass BEVDepthLightningModel(LightningModule):\n MODEL_NAMES = sorted(name for name in models.__dict__\n if name.islower() and not name.startswith('__')\n and callable(models.__dict__[name]))\n\n def __init__(self,\n gpus: int = 1,\n data_root='data/nuScenes',\n eval_interval=1,\n batch_size_per_device=8,\n class_names=CLASSES,\n backbone_img_conf=backbone_img_conf,\n head_conf=head_conf,\n ida_aug_conf=ida_aug_conf,\n bda_aug_conf=bda_aug_conf,\n rda_aug_conf=rda_aug_conf,\n default_root_dir='./outputs/',\n **kwargs):\n super().__init__()\n self.save_hyperparameters()\n self.gpus = gpus\n self.optimizer_config = optimizer_config\n self.pretrain_config = pretrain_config\n self.eval_interval = eval_interval\n self.batch_size_per_device = batch_size_per_device\n self.data_root = data_root\n self.class_names = class_names\n self.backbone_img_conf = backbone_img_conf\n self.head_conf = head_conf\n self.ida_aug_conf = ida_aug_conf\n self.bda_aug_conf = bda_aug_conf\n self.rda_aug_conf = rda_aug_conf\n mmcv.mkdir_or_exist(default_root_dir)\n self.default_root_dir = default_root_dir\n self.evaluator = DetNuscEvaluator(class_names=self.class_names,\n output_dir=self.default_root_dir)\n self.model = BaseBEVDepth(self.backbone_img_conf,\n self.head_conf)\n self.mode = 'valid'\n self.img_conf = img_conf\n self.data_use_cbgs = False\n self.load_interval = 1\n self.num_sweeps = 1\n self.sweep_idxes = list()\n self.key_idxes = list()\n self.data_return_depth = True\n self.downsample_factor = self.backbone_img_conf['downsample_factor']\n self.dbound = self.backbone_img_conf['d_bound']\n self.depth_channels = int(\n (self.dbound[1] - self.dbound[0]) / self.dbound[2])\n self.use_fusion = False\n self.train_info_paths = 'data/nuScenes/nuscenes_infos_train.pkl'\n self.val_info_paths = 'data/nuScenes/nuscenes_infos_val.pkl'\n self.predict_info_paths = 'data/nuScenes/nuscenes_infos_test.pkl'\n\n self.return_image = True\n self.return_depth = True\n self.return_radar_pv = False\n\n self.remove_z_axis = True\n\n def forward(self, sweep_imgs, mats, is_train=False, **inputs):\n return self.model(sweep_imgs, mats, is_train=is_train)\n\n def training_step(self, batch):\n if self.global_rank == 0:\n for pg in self.trainer.optimizers[0].param_groups:\n self.log('learning_rate', pg[\"lr\"])\n\n (sweep_imgs, mats, _, gt_boxes_3d, gt_labels_3d, _, depth_labels, pts_pv) = batch\n if torch.cuda.is_available():\n if self.return_image:\n sweep_imgs = sweep_imgs.cuda()\n for key, value in mats.items():\n mats[key] = value.cuda()\n if self.return_radar_pv:\n pts_pv = pts_pv.cuda()\n gt_boxes_3d = [gt_box.cuda() for gt_box in gt_boxes_3d]\n gt_labels_3d = [gt_label.cuda() for gt_label in gt_labels_3d]\n preds, depth_preds = self(sweep_imgs, mats,\n pts_pv=pts_pv,\n is_train=True)\n targets = self.model.get_targets(gt_boxes_3d, gt_labels_3d)\n loss_detection, loss_heatmap, loss_bbox = self.model.loss(targets, preds)\n\n if len(depth_labels.shape) == 5:\n # only key-frame will calculate depth loss\n depth_labels = depth_labels[:, 0, ...].contiguous()\n loss_depth = self.get_depth_loss(depth_labels.cuda(), depth_preds)\n self.log('train/detection', loss_detection)\n self.log('train/heatmap', loss_heatmap)\n self.log('train/bbox', loss_bbox)\n self.log('train/depth', loss_depth)\n\n return loss_detection + loss_depth\n\n def get_depth_loss(self, depth_labels, depth_preds, weight=3.):\n depth_labels = self.get_downsampled_gt_depth(depth_labels)\n depth_preds = depth_preds.permute(0, 2, 3, 1).contiguous().view(\n -1, self.depth_channels)\n fg_mask = torch.max(depth_labels, dim=1).values > 0.0\n\n with autocast(enabled=False):\n loss_depth = (F.binary_cross_entropy(\n depth_preds[fg_mask],\n depth_labels[fg_mask],\n reduction='none',\n ).sum() / max(1.0, fg_mask.sum()))\n\n return weight * loss_depth\n\n def get_downsampled_gt_depth(self, gt_depths):\n \"\"\"\n Input:\n gt_depths: [B, N, H, W]\n Output:\n gt_depths: [B*N*h*w, d]\n \"\"\"\n B, N, H, W = gt_depths.shape\n gt_depths = gt_depths.view(\n B * N,\n H // self.downsample_factor,\n self.downsample_factor,\n W // self.downsample_factor,\n self.downsample_factor,\n 1,\n )\n gt_depths = gt_depths.permute(0, 1, 3, 5, 2, 4).contiguous()\n gt_depths = gt_depths.view(\n -1, self.downsample_factor * self.downsample_factor)\n gt_depths_tmp = torch.where(gt_depths == 0.0,\n 1e5 * torch.ones_like(gt_depths),\n gt_depths)\n gt_depths = torch.min(gt_depths_tmp, dim=-1).values\n gt_depths = gt_depths.view(B * N, H // self.downsample_factor,\n W // self.downsample_factor)\n\n gt_depths = (gt_depths -\n (self.dbound[0] - self.dbound[2])) / self.dbound[2]\n gt_depths = torch.where(\n (gt_depths < self.depth_channels + 1) & (gt_depths > 0.),\n gt_depths, torch.zeros_like(gt_depths))\n gt_depths = F.one_hot(gt_depths.long(),\n num_classes=self.depth_channels + 1).view(\n -1, self.depth_channels + 1)[:, 1:]\n return gt_depths.float()\n\n def eval_step(self, batch, batch_idx, prefix: str):\n (sweep_imgs, mats, img_metas, _, _, _, _, pts_pv) = batch\n if torch.cuda.is_available():\n if self.return_image:\n sweep_imgs = sweep_imgs.cuda()\n for key, value in mats.items():\n mats[key] = value.cuda()\n if self.return_radar_pv:\n pts_pv = pts_pv.cuda()\n preds = self(sweep_imgs, mats,\n pts_pv=pts_pv,\n is_train=False)\n if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):\n results = self.model.module.get_bboxes(preds, img_metas)\n else:\n results = self.model.get_bboxes(preds, img_metas)\n for i in range(len(results)):\n results[i][0] = results[i][0].tensor.detach().cpu().numpy()\n results[i][1] = results[i][1].detach().cpu().numpy()\n results[i][2] = results[i][2].detach().cpu().numpy()\n results[i].append(img_metas[i])\n return results\n\n def validation_epoch_end(self, validation_step_outputs):\n detection_losses = list()\n heatmap_losses = list()\n bbox_losses = list()\n depth_losses = list()\n for validation_step_output in validation_step_outputs:\n detection_losses.append(validation_step_output[0])\n heatmap_losses.append(validation_step_output[1])\n bbox_losses.append(validation_step_output[2])\n depth_losses.append(validation_step_output[3])\n synchronize()\n\n self.log('val/detection', torch.mean(torch.stack(detection_losses)), on_epoch=True)\n self.log('val/heatmap', torch.mean(torch.stack(heatmap_losses)), on_epoch=True)\n self.log('val/bbox', torch.mean(torch.stack(bbox_losses)), on_epoch=True)\n self.log('val/depth', torch.mean(torch.stack(depth_losses)), on_epoch=True)\n\n def validation_step(self, batch, batch_idx):\n (sweep_imgs, mats, _, gt_boxes_3d, gt_labels_3d, _, depth_labels, pts_pv) = batch\n if torch.cuda.is_available():\n if self.return_image:\n sweep_imgs = sweep_imgs.cuda()\n for key, value in mats.items():\n mats[key] = value.cuda()\n if self.return_radar_pv:\n pts_pv = pts_pv.cuda()\n gt_boxes_3d = [gt_box.cuda() for gt_box in gt_boxes_3d]\n gt_labels_3d = [gt_label.cuda() for gt_label in gt_labels_3d]\n with torch.no_grad():\n preds, depth_preds = self(sweep_imgs, mats,\n pts_pv=pts_pv,\n is_train=True)\n targets = self.model.get_targets(gt_boxes_3d, gt_labels_3d)\n loss_detection, loss_heatmap, loss_bbox = self.model.loss(targets, preds)\n\n if len(depth_labels.shape) == 5:\n # only key-frame will calculate depth loss\n depth_labels = depth_labels[:, 0, ...].contiguous()\n loss_depth = self.get_depth_loss(depth_labels.cuda(), depth_preds, weight=3.)\n return loss_detection, loss_heatmap, loss_bbox, loss_depth\n\n def test_epoch_end(self, test_step_outputs):\n all_pred_results = list()\n all_img_metas = list()\n for test_step_output in test_step_outputs:\n for i in range(len(test_step_output)):\n all_pred_results.append(test_step_output[i][:3])\n all_img_metas.append(test_step_output[i][3])\n synchronize()\n # TODO: Change another way.\n dataset_length = len(self.val_dataloader().dataset)\n all_pred_results = sum(\n map(list, zip(*all_gather_object(all_pred_results))),\n [])[:dataset_length]\n all_img_metas = sum(map(list, zip(*all_gather_object(all_img_metas))),\n [])[:dataset_length]\n if self.global_rank == 0:\n self.evaluator.evaluate(all_pred_results, all_img_metas)\n\n def configure_optimizers(self):\n optimizer = build_optimizer(self.model, self.optimizer_config)\n scheduler = MultiStepLR(optimizer, [19, 23])\n return [[optimizer], [scheduler]]\n\n def train_dataloader(self):\n train_dataset = NuscDatasetRadarDet(\n ida_aug_conf=self.ida_aug_conf,\n bda_aug_conf=self.bda_aug_conf,\n rda_aug_conf=self.rda_aug_conf,\n img_backbone_conf=self.backbone_img_conf,\n classes=self.class_names,\n data_root=self.data_root,\n info_paths=self.train_info_paths,\n is_train=True,\n use_cbgs=self.data_use_cbgs,\n img_conf=self.img_conf,\n load_interval=self.load_interval,\n num_sweeps=self.num_sweeps,\n sweep_idxes=self.sweep_idxes,\n key_idxes=self.key_idxes,\n return_image=self.return_image,\n return_depth=self.return_depth,\n return_radar_pv=self.return_radar_pv,\n remove_z_axis=self.remove_z_axis,\n depth_path='depth_gt',\n radar_pv_path='radar_pv_filter'\n )\n\n train_loader = torch.utils.data.DataLoader(\n train_dataset,\n batch_size=self.batch_size_per_device,\n num_workers=4,\n drop_last=True,\n shuffle=False,"},"next_line":{"kind":"string","value":" collate_fn=partial(collate_fn,"},"gold_snippet_index":{"kind":"number","value":1,"string":"1"},"created_at":{"kind":"string","value":"2023-12-06 14:57:49+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5974,"cells":{"repo_name":{"kind":"string","value":"qitan/devops-backend-lite"},"file_path":{"kind":"string","value":"common/ext_fun.py"},"context":{"kind":"list like","value":[{"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 _tbindex.settings(number_of_shards=3, number_of_replicas=1)\n _fields = Mapping().generate_data_mapping(table)\n docu = type(index_name, (CustomDocument,), _fields)\n return _tbindex.document(docu)"},{"identifier":"Search","path":"common/utils/ElasticSearchAPI.py","snippet":"class Search(BaseSearch):\n def __init__(self, prefix=False, **kwargs):\n if kwargs.get('index', None) and prefix:\n if isinstance(kwargs['index'], string_types):\n kwargs['index'] = f\"{ELASTICSEARCH_PREFIX}{kwargs['index']}\"\n elif isinstance(kwargs['index'], list):\n kwargs['index'] = [\n f\"{ELASTICSEARCH_PREFIX}{i}\" for i in kwargs['index']]\n elif isinstance(kwargs['index'], tuple):\n kwargs['index'] = tuple(\n f\"{ELASTICSEARCH_PREFIX}{i}\" for i in kwargs['index'])\n else:\n raise Exception('索引名称格式错误!')\n super(Search, self).__init__(**kwargs)"},{"identifier":"GitLabAPI","path":"common/utils/GitLabAPI.py","snippet":"class GitLabAPI(object):\n def __init__(self, url, user=None, password=None, token=None, oauth=False):\n self.__url = url\n if token:\n self.__token = token\n if oauth:\n params = {'oauth_token': self.__token}\n else:\n params = {'private_token': self.__token}\n self.__gl = gitlab.Gitlab(self.__url, **params)\n else:\n self.__gl = gitlab.Gitlab(\n self.__url, http_username=user, http_password=password)\n self.__gl.auth()\n\n def get_gl(self):\n return self.__gl\n\n def list_projects(self, get_all=False, key=None, per_page=20, page=1):\n params = {'per_page': per_page, 'page': page}\n if get_all:\n params = {'get_all': True, 'per_page': per_page}\n if key:\n params['search'] = key\n projects = self.__gl.projects.list(**params)\n return projects\n\n def get_project(self, project_id=None, project_name_with_namespace=None):\n if any([project_id, project_name_with_namespace]) is False:\n raise Exception('缺少参数，project_id或project_name_with_namespace必选其一.')\n condition = project_id or project_name_with_namespace\n try:\n project = self.__gl.projects.get(condition)\n return project\n except BaseException as e:\n logger.info(e)\n return None\n\n def create_project(self, name, namespace_id=None, initialize_with_readme=False):\n payload = {'name': name, 'path': name,\n 'initialize_with_readme': initialize_with_readme}\n if namespace_id:\n payload['namespace_id'] = namespace_id\n try:\n ret = self.__gl.projects.create(payload)\n return True, ret\n except BaseException as e:\n logger.exception(f'创建分支请求异常，原因：{e.__dict__}')\n return False, e\n\n def get_commit(self, commit_id, project_id=None, project_name_with_namespace=None):\n try:\n commit = self.get_project(\n project_id, project_name_with_namespace).get(commit_id)\n return commit\n except BaseException as e:\n logger.info(e)\n return None\n\n def list_groups(self, get_all=False, key=None, per_page=20, page=1):\n params = {'per_page': per_page, 'page': page}\n if get_all:\n params = {'get_all': True, 'all': True, 'per_page': per_page}\n if key:\n params['search'] = key\n groups = self.__gl.groups.list(**params)\n return [{'id': i.id, 'name': i.name, 'description': i.description} for i in groups if not i.parent_id]\n\n def create_group(self, name, path=None, desc=None, parent=None):\n \"\"\"\n 创建组\n \"\"\"\n payload = {'name': name, 'path': path or name,\n 'description': desc or ''}\n if parent:\n payload['parent_id'] = parent\n try:\n group = self.__gl.groups.create(payload)\n return True, group\n except BaseException as e:\n logger.info(e)\n return False, e\n\n def create_branch(self, project, src_branch, target_branch):\n payload = {'branch': target_branch,\n 'ref': src_branch}\n if isinstance(project, (int,)):\n project = self.get_project(project)\n try:\n ret = project.branches.create(payload)\n return True, ret\n except BaseException as e:\n logger.exception(f'创建分支请求异常，原因：{e.__dict__}')\n return False, e\n\n def list_branches(self, project_id=None, project_name_with_namespace=None, get_all=False, key=None, per_page=20,\n page=1, protected='0', *args, **kwargs):\n params = {'per_page': per_page, 'page': page}\n if not protected:\n protected = '0'\n if get_all:\n params = {'get_all': True, 'per_page': per_page}\n if key:\n params['search'] = key\n params.update(kwargs)\n branches = self.get_project(project_id=project_id,\n project_name_with_namespace=project_name_with_namespace).branches.list(**params)\n branches = [{'uid': f\"{G_COMMIT[0][0]}:{i.name}\", 'name': i.name, 'commit': i.commit, 'label': G_COMMIT[0][0], 'protected': i.protected}\n for i in branches]\n if protected != '0':\n # 过滤受保护分支\n _map = {'1': True, '2': False}\n branches = [i for i in branches if i['protected']\n == _map[protected]]\n return branches\n\n def list_protected_branches(self, project_id=None, project_name_with_namespace=None, get_all=False, key=None, per_page=20,\n page=1, *args, **kwargs):\n params = {'per_page': per_page, 'page': page}\n if get_all:\n params = {'get_all': True, 'per_page': per_page}\n if key:\n params['search'] = key\n params.update(kwargs)\n branches = self.get_project(project_id=project_id,\n project_name_with_namespace=project_name_with_namespace).protectedbranches.list(**params)\n branches = [{'uid': f\"{G_COMMIT[0][0]}:{i.name}\", 'name': i.name, 'commit': i.commit, 'label': G_COMMIT[0][0], 'protected': i.protected}\n for i in branches]\n return branches\n\n def list_tags(self, project_id=None, project_name_with_namespace=None, get_all=False, key=None, per_page=20,\n page=1):\n params = {'per_page': per_page, 'page': page}\n if get_all:\n params = {'get_all': True, 'per_page': per_page}\n if key:\n params['search'] = key\n tags = self.get_project(\n project_id, project_name_with_namespace).tags.list(**params)\n tags = [{'uid': f\"{G_COMMIT[1][0]}:{i.name}\", 'name': i.name, 'message': i.message, 'commit': i.commit,\n 'label': G_COMMIT[1][0]} for i in tags]\n return tags\n\n def list_commits(self, project_id=None, project_name_with_namespace=None, get_all=False, key=None, per_page=20,\n page=1, ref_name=None, since=None):\n params = {'per_page': per_page, 'page': page}\n if get_all:\n params = {'get_all': True, 'per_page': per_page}\n if key:\n params['search'] = key\n if ref_name:\n params['ref_name'] = ref_name\n if since:\n params['since'] = since\n commits = self.get_project(\n project_id, project_name_with_namespace).commits.list(**params)\n commits = [\n {'title': i.title, 'short_id': i.short_id, 'author_name': i.author_name, 'committer_name': i.committer_name,\n 'committed_date': i.committed_date, 'message': i.message, 'web_url': i.web_url} for i in commits]\n return commits\n\n def repo_checkout(self, repo):\n import subprocess\n git_url = repo.split('//')\n subprocess.call(\n ['git', 'clone', f\"{git_url[0]}//oauth2:{self.__token}@{git_url[1]}\"])\n\n def get_user_id(self, username):\n user_list = self.__gl.users.list(username=username)\n if user_list:\n return user_list[0].id\n else:\n return None\n\n def get_project_from_name(self, project_name):\n projects = self.__gl.projects.list(search=project_name)\n for p in projects:\n if p.name == project_name:\n return p\n return None\n\n def add_project_member(self, project, user_id, access_level):\n try:\n project.members.create(\n {'user_id': user_id, 'access_level': access_level})\n return True, '成功'\n except Exception as error:\n return False, error\n\n def del_project_member(self, project, user_id):\n try:\n project.members.delete(user_id)\n return True, '成功'\n except Exception as error:\n return False, error"},{"identifier":"HarborAPI","path":"common/utils/HarborAPI.py","snippet":"class HarborAPI(object):\n def __init__(self, url, username, password):\n self.__url = url.rstrip('/')\n self.__user = username\n self.__password = password\n self.__token = base64.b64encode(\n bytes('%s:%s' % (self.__user, self.__password), encoding='utf-8'))\n self.__headers = dict()\n self.__headers[\"Accept\"] = \"application/json\"\n self.__headers['authorization'] = 'Basic %s' % str(\n self.__token, encoding='utf-8')\n\n def request(self, method, obj=None, prefix='/'):\n try:\n if method == 'get':\n req = requests.request(method, '%s%s' % (self.__url, prefix), params=obj, headers=self.__headers,\n verify=False)\n if req.status_code > 399:\n return {'ecode': req.status_code, 'message': f'{req.content}\\n{req.reason}'}\n res = {'ecode': req.status_code, 'data': req.json(), 'count': req.headers.get('X-Total-Count', None),\n 'next': req.headers.get('Link', None)}\n if method == 'delete':\n req = requests.request(method, '%s%s' % (\n self.__url, prefix), headers=self.__headers, verify=False)\n if req.status_code > 399:\n return {'ecode': req.status_code, 'message': f'{req.content}\\n{req.reason}'}\n res = {'ecode': req.status_code, 'data': req.content}\n if method in ['put', 'post']:\n req = requests.request(method, '%s%s' % (self.__url, prefix), json=obj, headers=self.__headers,\n verify=False)\n if req.status_code > 399:\n return {'ecode': req.status_code, 'message': f'{req.content}\\n{req.reason}'}\n res = {'ecode': req.status_code, 'data': req.content}\n if method == 'head':\n req = requests.request(method, '%s%s' % (\n self.__url, prefix), headers=self.__headers, verify=False)\n if req.status_code > 399:\n return {'ecode': req.status_code, 'message': f'{req.content}\\n{req.reason}'}\n res = {'ecode': req.status_code, 'data': req.content}\n except BaseException as e:\n raise e\n return res\n\n def systeminfo(self):\n res = self.request('get', prefix='/systeminfo')\n return res\n\n def get_users(self):\n res = self.request('get', prefix='/users')\n return res\n\n def get_projects(self, project_name=None, page=1, page_size=20):\n \"\"\"\n :project_name: The name of project\n :page: default is 1.\n :page_size: default is 10, maximum is 100.\n \"\"\"\n params = {'page': page, 'page_size': page_size}\n if project_name:\n params['name'] = project_name\n try:\n res = self.request('get', params, prefix='/projects')\n return res\n except BaseException as e:\n return {'ecode': 500, 'message': e}\n\n def get_repositories(self, project_id, page=1, page_size=20, repo=None):\n params = {'project_id': project_id,\n 'page': page, 'page_size': page_size}\n if repo:\n params['q'] = repo\n try:\n res = self.request('get', params, '/repositories')\n return res\n except BaseException as e:\n return {'ecode': 500, 'message': e}\n\n def get_tags(self, repo):\n try:\n res = self.request('get', prefix='/repositories/%s/tags' % repo)\n tags = [\n {'name': i['name'], 'created': i['created'], 'push_time': i.get(\n 'push_time', None), 'size': i['size']}\n for i in\n res['data']]\n tags.sort(key=lambda k: (k.get('created')), reverse=True)\n return {'ecode': 200, 'data': tags, 'count': len(tags)}\n except BaseException as e:\n return {'ecode': 500, 'message': e}\n\n def fetch_project(self, project_id):\n \"\"\"\n 获取项目信息\n \"\"\"\n try:\n res = self.request(\n 'get', {'project_id': project_id}, prefix=f'/projects/{project_id}')\n return res\n except BaseException as e:\n return {'ecode': 500, 'message': e}\n\n def fetch_tag(self, repo, tag):\n \"\"\"\n 获取指定镜像标签\n \"\"\"\n try:\n res = self.request(\n 'get', prefix=f'/repositories/{repo}/tags/{tag}')\n return res\n except BaseException as e:\n return {'ecode': 500, 'message': e}\n\n def create_project(self, project_name, public=True):\n \"\"\"\n 创建仓库项目\n \"\"\"\n try:\n data = {'project_name': project_name, 'metadata': {\n 'public': 'true' if public else 'false'}}\n res = self.request('post', obj=data, prefix='/projects')\n return res\n except BaseException as e:\n return {'ecode': 500, 'message': e}\n\n def update_project(self, project_id, *args, **kwargs):\n \"\"\"\n 更新仓库项目\n \"\"\"\n try:\n res = self.request('put', obj=kwargs,\n prefix=f'/projects/{project_id}')\n return res\n except BaseException as e:\n return {'ecode': 500, 'message': e}\n\n def project_exists(self, project_name):\n \"\"\"\n 查询项目是否存在\n \"\"\"\n try:\n res = self.request(\n 'head', prefix=f'/projects?project_name={project_name}')\n return res\n except BaseException as e:\n return {'ecode': 500, 'message': e}\n\n def patch_tag(self, repo, src_image, tag_name):\n \"\"\"\n 镜像打标签\n \"\"\"\n try:\n try:\n # 创建仓库项目\n res = self.create_project(repo.split('/')[0])\n except BaseException as e:\n pass\n data = {'tag': tag_name, 'src_image': src_image, 'override': True}\n res = self.request(\n 'post', obj=data, prefix='/repositories/%s/tags' % repo)\n return res\n except BaseException as e:\n return {'ecode': 500, 'message': e}\n\n def delete_tag(self, repo, tag):\n \"\"\"\n 删除标签\n \"\"\"\n try:\n res = self.request(\n 'delete', prefix=f'/repositories/{repo}/tags/{tag}')\n return res\n except BaseException as e:\n logger.ex\n return {'ecode': 500, 'message': e}\n\n def search(self, query):\n \"\"\"\n 搜索\n \"\"\"\n try:\n res = self.request('get', {'q': query}, prefix='/search')\n return res\n except BaseException as e:\n logger.exception(e)\n return {'ecode': 500, 'message': e}"},{"identifier":"GlueJenkins","path":"common/utils/JenkinsAPI.py","snippet":"class GlueJenkins(Jenkins):\n\n def __init__(self, url=None, username=None, password=None):\n self.__url = url\n self.__username = username\n self.__password = password\n super(GlueJenkins, self).__init__(\n self.__url, self.__username, self.__password)\n\n def _get_encoded_params(self, params):\n for k, v in params.items():\n if k in [\"name\", \"msg\", \"short_name\", \"from_short_name\",\n \"to_short_name\", \"folder_url\", \"from_folder_url\", \"to_folder_url\"]:\n params[k] = quote(v.encode('utf8'))\n return params\n\n def _build_url(self, format_spec, variables=None):\n\n if variables:\n url_path = format_spec % self._get_encoded_params(variables)\n else:\n url_path = format_spec\n return str(urljoin(self.server, url_path))\n\n def assert_credential_exists(self, name, folder_name=None, domain_name='_',\n exception_message='credential[%s] does not exist.'):\n '''Raise an exception if credential does not exist in domain of folder\n\n :param name: Name of credential, ``str``\n :param folder_name: Folder name, ``str``\n :param domain_name: Domain name, default is '_', ``str``\n :param exception_message: Message to use for the exception.\n Formatted with ``name``, ``domain_name``,\n and ``folder_name``\n :throws: :class:`JenkinsException` whenever the credentail\n does not exist in domain of folder\n '''\n if not self.credential_exists(name, folder_name, domain_name):\n raise JenkinsException(exception_message\n % name)\n\n def get_credential_global_config(self, name, domain_name='_'):\n '''Get configuration of credential in domain of folder.\n :param name: Name of credentail, ``str``\n :param domain_name: Domain name, default is '_', ``str``\n :returns: Credential configuration (XML format)\n '''\n return self.jenkins_open(requests.Request(\n 'GET', self._build_url(CONFIG_CREDENTIAL_GLOBAL, locals())\n ))\n\n def get_credential_info(self, name, folder_name=None, domain_name='_'):\n '''Get credential information dictionary in domain of folder\n\n :param name: Name of credentail, ``str``\n :param folder_name: folder_name, ``str``\n :param domain_name: Domain name, default is '_', ``str``\n :returns: Dictionary of credential info, ``dict``\n '''\n try:\n response = self.jenkins_open(requests.Request(\n 'GET', self._build_url(CREDENTIAL_INFO_GLOBAL, locals())\n ))\n if response:\n return json.loads(response)\n else:\n raise JenkinsException('credential[%s] does not exist.' % name)\n except (req_exc.HTTPError, NotFoundException):\n raise JenkinsException('credential[%s] does not exist.' % name)\n except ValueError:\n raise JenkinsException(\n 'Could not parse JSON info for credential[%s].' % name\n )\n\n def credential_exists(self, name, folder_name=None, domain_name='_'):\n '''Check whether a credentail exists in domain of folder\n\n :param name: Name of credentail, ``str``\n :param folder_name: Folder name, ``str``\n :param domain_name: Domain name, default is '_', ``str``\n :returns: ``True`` if credentail exists, ``False`` otherwise\n '''\n try:\n return self.get_credential_info(name)['id'] == name\n except JenkinsException:\n return False\n\n def create_credential_global(self, name=None, user=None, password=None, secret=None, comment=None, domain_name='_'):\n '''Create credentail in domain of folder\n\n :param name: username\n :param password: password\n :param comment: comment, ``str``\n :param config_xml: New XML configuration, ``str``\n :param domain_name: Domain name, default is '_', ``str``\n '''\n st = shortuuid.ShortUUID()\n st.set_alphabet(\n f\"0123456789{''.join([chr(i) for i in range(ord('a'), ord('z') + 1)])}\")\n if name is None:\n name = '-'.join(['api', st.random(length=8),\n st.random(length=4), st.random(length=12)])\n config_xml = '''<com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl>\n <scope>GLOBAL</scope>\n <id>%s</id>\n <description>[%s] Created by DevOps Platform</description>\n <username>%s</username>\n <password>%s</password>\n</com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl>''' % (name, comment, user, password)\n if user is None:\n config_xml = '''<org.jenkinsci.plugins.plaincredentials.impl.StringCredentialsImpl>\n <scope>GLOBAL</scope>\n <id>%s</id>\n <description>[%s] Created by DevOps Platform</description>\n <secret>%s</secret>\n</org.jenkinsci.plugins.plaincredentials.impl.StringCredentialsImpl>''' % (name, comment, secret)\n if self.credential_exists(name):\n raise JenkinsException('credential[%s] already exists.' % name)\n\n self.jenkins_open(requests.Request(\n 'POST', self._build_url(CREATE_CREDENTIAL_GLOBAL, locals()),\n data=config_xml.encode('utf-8'),\n headers=DEFAULT_HEADERS\n ))\n self.assert_credential_exists(\n name, exception_message='create credential[%s] failed.')\n return {'status': 0, 'data': name}\n\n def reconfig_credential_global(self, name, user=None, password=None, secret=None, comment=None, domain_name='_'):\n \"\"\"\n Reconfig credential with new config in domain of folder\n :param name: name, ``str``\n :param user:\n :param password:\n :param secret:\n :param comment:\n :param domain_name: Domain name, default is '_', ``str``\n :return:\n \"\"\"\n reconfig_url = self._build_url(CONFIG_CREDENTIAL_GLOBAL, locals())\n config_xml = self.get_credential_global_config(name)\n xml_dict = xmltodict.parse(config_xml)\n if user is None:\n xml_dict['org.jenkinsci.plugins.plaincredentials.impl.StringCredentialsImpl']['secret'] = secret\n if comment:\n xml_dict['org.jenkinsci.plugins.plaincredentials.impl.StringCredentialsImpl']['description'] = comment\n else:\n xml_dict['com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl']['username'] = user\n xml_dict['com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl']['password'] = password\n if comment:\n xml_dict['com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl'][\n 'description'] = comment\n config_xml = xmltodict.unparse(xml_dict, pretty=True)\n self.jenkins_open(requests.Request(\n 'POST', reconfig_url,\n data=config_xml.encode('utf-8'),\n headers=DEFAULT_HEADERS\n ))\n\n def create_job(self, name, config_xml):\n '''Create a new Jenkins job\n\n :param name: Name of Jenkins job, ``str``\n :param config_xml: config file text, ``str``\n '''\n folder_url, short_name = self._get_job_folder(name)\n if self.job_exists(name):\n raise JenkinsException('job[%s] already exists' % (name))\n\n try:\n self.jenkins_open(requests.Request(\n 'POST', self._build_url(CREATE_JOB, locals()),\n data=config_xml.encode('utf-8'),\n headers=DEFAULT_HEADERS\n ))\n except NotFoundException:\n raise JenkinsException('Cannot create job[%s] because folder '\n 'for the job does not exist' % (name))\n self.assert_job_exists(name, 'create[%s] failed')\n\n def reconfig_job(self, name, config_xml):\n '''Change configuration of existing Jenkins job.\n\n To create a new job, see :meth:`Jenkins.create_job`.\n\n :param name: Name of Jenkins job, ``str``\n :param config_xml: New XML configuration, ``str``\n '''\n folder_url, short_name = self._get_job_folder(name)\n reconfig_url = self._build_url(CONFIG_JOB, locals())\n self.jenkins_open(requests.Request(\n 'POST', reconfig_url,\n data=config_xml.encode('utf-8'),\n headers=DEFAULT_HEADERS\n ))\n\n def get_stage_describe(self, name, number, node_number):\n \"\"\" 获取 单个stage 详情 \"\"\"\n folder_url, short_name = self._get_job_folder(name)\n try:\n response = self.jenkins_open(requests.Request(\n 'GET', self._build_url(STAGE_DES, locals())\n ))\n\n if response:\n return json.loads(response)\n else:\n raise JenkinsException('job[%s] number[%d] does not exist'\n % (name, number))\n except (req_exc.HTTPError, NotFoundException):\n raise JenkinsException('job[%s] number[%d] does not exist'\n % (name, number))\n except ValueError:\n raise JenkinsException(\n 'Could not parse JSON info for job[%s] number[%d]'\n % (name, number)\n )\n\n def get_stage_logs(self, name, number, node_number):\n \"\"\" 获取 stage 执行日志\"\"\"\n folder_url, short_name = self._get_job_folder(name)\n try:\n response = self.jenkins_open(requests.Request(\n 'GET', self._build_url(STAGE_LOG, locals())\n ))\n if response:\n return json.loads(response)\n else:\n raise JenkinsException('job[%s] number[%d] does not exist'\n % (name, number))\n except (req_exc.HTTPError, NotFoundException):\n raise JenkinsException('job[%s] number[%d] does not exist'\n % (name, number))\n except ValueError:\n raise JenkinsException(\n 'Could not parse JSON info for job[%s] number[%d]'\n % (name, number)\n )\n\n def get_stage_info(self, name, number, depth=0):\n\n folder_url, short_name = self._get_job_folder(name)\n try:\n response = self.jenkins_open(requests.Request(\n 'GET', self._build_url(STAGE_INFO, locals())\n ))\n if response:\n return json.loads(response)\n else:\n raise JenkinsException('job[%s] number[%d] does not exist'\n % (name, number))\n except (req_exc.HTTPError, NotFoundException):\n raise JenkinsException('job[%s] number[%d] does not exist'\n % (name, number))\n except ValueError:\n raise JenkinsException(\n 'Could not parse JSON info for job[%s] number[%d]'\n % (name, number)\n )\n\n def get_flow_detail(self, job_name, build_number):\n stage_data = self.get_stage_info(name=job_name, number=build_number)\n stages = stage_data.get('stages')\n for i in stages:\n logs = ''\n try:\n # 获取stage返回信息\n response = self.jenkins_open(requests.Request(\n 'GET', self._build_url(\n unquote(i['_links']['self']['href']), locals())\n ))\n if response:\n res = json.loads(response)\n for j in res['stageFlowNodes']:\n response = self.jenkins_open(requests.Request(\n 'GET', self._build_url(\n unquote(j['_links']['log']['href']), locals())\n ))\n res = json.loads(response)\n try:\n # 移除href html信息，保留链接文字\n import re\n pat = re.compile('<a href[^>]*>')\n logs = logs + '\\n' + \\\n pat.sub('', res['text'].replace('</a>', ''))\n except:\n pass\n else:\n raise JenkinsException('job[%s] number[%d] does not exist'\n % (job_name, build_number))\n except (req_exc.HTTPError, NotFoundException):\n raise JenkinsException('job[%s] number[%d] does not exist'\n % (job_name, build_number))\n except ValueError:\n raise JenkinsException(\n 'Could not parse JSON info for job[%s] number[%d]'\n % (job_name, build_number)\n )\n\n stage_data[\"stages\"][stages.index(i)]['logs'] = logs\n return stage_data\n\n def get_queue_item(self, number, depth=0):\n '''Get information about a queued item (to-be-created job).\n\n The returned dict will have a \"why\" key if the queued item is still\n waiting for an executor.\n\n The returned dict will have an \"executable\" key if the queued item is\n running on an executor, or has completed running. Use this to\n determine the job number / URL.\n\n :param name: queue number, ``int``\n :returns: dictionary of queued information, ``dict``\n '''\n url = self._build_url(Q_ITEM, locals())\n try:\n response = self.jenkins_open(requests.Request('GET', url))\n if response:\n return json.loads(response)\n else:\n raise JenkinsException('queue number[%d] does not exist'\n % number)\n except (req_exc.HTTPError, NotFoundException):\n raise JenkinsException('queue number[%d] does not exist' % number)\n except ValueError:\n raise JenkinsException(\n 'Could not parse JSON info for queue number[%d]' % number\n )\n\n def build_job(self, name, parameters=None, token=None):\n '''Trigger build job.\n\n This method returns a queue item number that you can pass to\n :meth:`Jenkins.get_queue_item`. Note that this queue number is only\n valid for about five minutes after the job completes, so you should\n get/poll the queue information as soon as possible to determine the\n job's URL.\n\n :param name: name of job\n :param parameters: parameters for job, or ``None``, ``dict``\n :param token: Jenkins API token\n :returns: ``int`` queue item\n '''\n response = self.jenkins_request(requests.Request(\n 'POST', self.build_job_url(name, parameters, token)))\n\n if 'Location' not in response.headers:\n raise EmptyResponseException(\n \"Header 'Location' not found in \"\n \"response from server[%s]\" % self.server)\n\n location = response.headers['Location']\n if location.endswith('/'):\n location = location[:-1]\n parts = location.split('/')\n number = int(parts[-1])\n return number\n\n def get_job_config(self, name):\n '''Get configuration of existing Jenkins job.\n\n :param name: Name of Jenkins job, ``str``\n :returns: job configuration (XML format)\n '''\n folder_url, short_name = self._get_job_folder(name)\n request = requests.Request(\n 'GET', self._build_url(CONFIG_JOB, locals()))\n return self.jenkins_open(request)\n\n def get_job_info(self, name, depth=0, fetch_all_builds=False):\n '''Get job information dictionary.\n\n :param name: Job name, ``str``\n :param depth: JSON depth, ``int``\n :param fetch_all_builds: If true, all builds will be retrieved\n from Jenkins. Otherwise, Jenkins will\n only return the most recent 100\n builds. This comes at the expense of\n an additional API call which may\n return significant amounts of\n data. ``bool``\n :returns: dictionary of job information\n '''\n folder_url, short_name = self._get_job_folder(name)\n try:\n response = self.jenkins_open(requests.Request(\n 'GET', self._build_url(JOB_INFO, locals())\n ))\n if response:\n if fetch_all_builds:\n return self._add_missing_builds(json.loads(response))\n else:\n return json.loads(response)\n else:\n raise JenkinsException('job[%s] does not exist' % name)\n except (req_exc.HTTPError, NotFoundException):\n raise JenkinsException('job[%s] does not exist' % name)\n except ValueError:\n raise JenkinsException(\n \"Could not parse JSON info for job[%s]\" % name)"},{"identifier":"convert_xml_to_str_with_pipeline","path":"common/custom_format.py","snippet":"def convert_xml_to_str_with_pipeline(xml, url, secret, desc, jenkinsfile, scm=True):\n \"\"\"\n scm\n True: jenkinsfile为指定的git地址\n False: jenkinsfile为具体的pipeline\n \"\"\"\n xml_dict = xmltodict.parse(xml)\n if scm:\n xml_dict['flow-definition']['definition']['@class'] = 'org.jenkinsci.plugins.workflow.cps.CpsScmFlowDefinition'\n xml_dict['flow-definition']['definition']['scm']['userRemoteConfigs']['hudson.plugins.git.UserRemoteConfig'][\n 'url'] = url\n xml_dict['flow-definition']['definition']['scm']['userRemoteConfigs']['hudson.plugins.git.UserRemoteConfig'][\n 'credentialsId'] = secret\n xml_dict['flow-definition']['definition']['scriptPath'] = jenkinsfile\n else:\n xml_dict['flow-definition']['definition']['@class'] = 'org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition'\n xml_dict['flow-definition']['definition']['script'] = jenkinsfile\n xml_dict['flow-definition']['definition']['sandbox'] = 'true'\n xml_dict['flow-definition']['description'] = desc\n result = xmltodict.unparse(\n xml_dict, short_empty_elements=True, pretty=True)\n return result"},{"identifier":"DASHBOARD_TIME_FORMAT","path":"common/variables.py","snippet":"DASHBOARD_TIME_FORMAT = {'year_only': '%Y', 'years': '%Y-%m', 'months': '%Y-%m-%d', 'days': '%Y-%m-%d %H:00:00',\n 'hours': '%Y-%m-%d %H:%M:00', 'minutes': '%Y-%m-%d %H:%M:%S'}"},{"identifier":"DASHBOARD_TIME_FORMAT_T","path":"common/variables.py","snippet":"DASHBOARD_TIME_FORMAT_T = {'years': '%Y', 'months': '%Y-%m', 'days': '%Y-%m-%d', 'hours': \"%Y-%m-%d %H:00:00\",\n 'minutes': \"%Y-%m-%d %H:%M:00\", 'seconds': \"%Y-%m-%d %H:%M:%S\"}"},{"identifier":"DASHBOARD_TIME_FREQNAMES","path":"common/variables.py","snippet":"DASHBOARD_TIME_FREQNAMES = {'year_only': YEARLY, 'years': MONTHLY, 'months': DAILY, 'days': HOURLY, 'hours': MINUTELY,\n 'minutes': SECONDLY}"},{"identifier":"DASHBOARD_TIME_FREQNAMES_T","path":"common/variables.py","snippet":"DASHBOARD_TIME_FREQNAMES_T = {'years': YEARLY, 'months': MONTHLY, 'days': DAILY, 'hours': HOURLY, 'minutes': MINUTELY,\n 'seconds': SECONDLY}"},{"identifier":"SENSITIVE_KEYS","path":"common/variables.py","snippet":"SENSITIVE_KEYS = ['password', 'token', 'access',\n 'refresh', 'AUTHORIZATION', 'COOKIE']"},{"identifier":"JENKINS_CALLBACK_KEY","path":"common/variables.py","snippet":"JENKINS_CALLBACK_KEY = 'jenkins_callback_flag::'"},{"identifier":"JENKINS_STATUS_MAP","path":"common/variables.py","snippet":"JENKINS_STATUS_MAP = {'IN_PROGRESS': 3, 'SUCCESS': 1, 'FAILED': 2, 'ABORTED': 4, 'FAILURE': 2, 'NOT_EXECUTED': 5,\n 'NOT_EXEC_TIMEOUT': 5}"},{"identifier":"DEV_LANGUAGE_KEY","path":"common/variables.py","snippet":"DEV_LANGUAGE_KEY = 'devlanguage:'"},{"identifier":"AppInfo","path":"dbapp/models.py","snippet":""},{"identifier":"K8sAPI","path":"common/utils/K8sAPI.py","snippet":"class K8sAPI(object):\n def __init__(self, host=None, username=None, password=None, api_key=None, api_key_prefix='Bearer', verify_ssl=False,\n k8s_config=None,\n config_file=None, eks=None):\n \"\"\"\n elk: aws kubernetes\n \"\"\"\n self.__host = host\n self.__username = username\n self.__password = password\n self.__api_key = api_key\n self.__api_key_prefix = api_key_prefix\n self.__verify_ssl = verify_ssl\n if k8s_config is not None:\n config.kube_config.load_kube_config_from_dict(k8s_config)\n self.__client0 = client.CoreApi()\n self.__client = client.CoreV1Api()\n elif config_file is not None:\n config.kube_config.load_kube_config(config_file=config_file)\n self.__client0 = client.CoreApi()\n self.__client = client.CoreV1Api()\n elif self.__host:\n if self.__username and self.__password:\n self.__client = self.get_api()\n else:\n raise Exception('Please input username/password or api_key')\n else:\n raise Exception('Cannot find k8s config')\n self.client = self.__client\n\n def get_token(self):\n pass\n\n def get_api(self):\n configuration = client.Configuration()\n configuration.host = self.__host\n if self.__verify_ssl is False:\n configuration.verify_ssl = False\n configuration.username = self.__username\n configuration.password = self.__password\n basic_auth_token = configuration.get_basic_auth_token()\n api = core_v1_api.CoreV1Api(api_client.ApiClient(configuration=configuration, header_name=\"authorization\",\n header_value=basic_auth_token))\n return api\n\n def get_client(self):\n return self.__client\n\n def set_client(self, obj):\n self.__client = getattr(client, obj)()\n\n def get_apis(self):\n print(\"Supported APIs (* is preferred version):\")\n self.__client2 = client.ApisApi(self.__client0.api_client)\n for api in self.__client2.get_api_versions().groups:\n versions = []\n for v in api.versions:\n name = \"\"\n if v.version == api.preferred_version.version and len(\n api.versions) > 1:\n name += \"*\"\n name += v.version\n versions.append(name)\n\n def get_nodes(self, **kwargs):\n ret = self.__client.list_node(**kwargs)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def get_node_info(self, name):\n ret = self.__client.read_node_status(name)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def get_namespaces(self, **kwargs):\n ret = self.__client.list_namespace(**kwargs)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def create_namespace(self, name):\n payload = {\n \"apiVersion\": \"v1\",\n \"kind\": \"Namespace\",\n \"metadata\": {\n \"name\": name,\n }\n }\n ret = self.__client.create_namespace(body=payload)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n print(rs)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def get_services(self, namespace='default', **kwargs):\n ret = self.__client.list_namespaced_service(namespace, **kwargs)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def fetch_service(self, name, namespace='default', api_version='apps/v1'):\n try:\n ret = self.__client.read_namespaced_service(name, namespace)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n print('reason', e.reason)\n return {'ecode': e.status, 'message': e.body}\n except BaseException as e:\n print('reason', e.reason)\n return {'ecode': e.status, 'message': e.body}\n\n def create_namespace_service(self, name, app=None, targets=list, namespace='default', service_type='NodePort',\n svc_yaml=None):\n \"\"\"\n 目前只支持NodePort类型，对外服务端口随机生成（如手动生成，需配置node_port和endpoints）\n :param name: service name\n :param app: app name\n :param targets: [{port, target_port, protocol, node_port}]\n :param namespace:\n :param service_type:\n :return:\n \"\"\"\n ports = []\n if svc_yaml:\n if isinstance(svc_yaml, str):\n body = yaml.safe_load(svc_yaml)\n else:\n body = svc_yaml\n else:\n for index, target in enumerate(targets):\n port_body = {'name': f\"{name}-{index}\", 'port': target['port'], 'target_port': target['port'],\n 'protocol': target['protocol']}\n if target['node_port'] > 30000:\n port_body['node_port'] = target['node_port']\n ports.append(client.V1ServicePort(**port_body))\n body = client.V1Service(\n api_version=\"v1\",\n kind=\"Service\",\n metadata=client.V1ObjectMeta(\n name=name\n ),\n spec=client.V1ServiceSpec(\n selector={\"app\": app},\n type=service_type,\n ports=ports\n )\n )\n try:\n ret = self.__client.create_namespaced_service(namespace=namespace, body=body,\n **{'_return_http_data_only': False})\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n logger.error('reason', e)\n return {'error': True, 'message': str(e)}\n except ApiException as e:\n if e.status == 409:\n logger.error('reason', e.reason)\n return {'error': True, 'ecode': e.status, 'message': e.body}\n except BaseException as e:\n return {'error': True, 'message': str(e)}\n\n def update_namespace_service(self, name, app=None, targets=Type[list], namespace='default', service_type='NodePort',\n svc_yaml=None):\n ports = []\n if svc_yaml:\n if isinstance(svc_yaml, str):\n body = yaml.safe_load(svc_yaml)\n else:\n body = svc_yaml\n logger.debug(f'svc_yaml body == {body}')\n func = self.__client.replace_namespaced_service\n else:\n for index, target in enumerate(targets):\n port_body = {'name': target['name'], 'port': target['port'], 'target_port': target['port'],\n 'protocol': target['protocol']}\n if target['node_port'] > 30000:\n port_body['node_port'] = target['node_port']\n ports.append(client.V1ServicePort(**port_body))\n body = client.V1Service(\n api_version=\"v1\",\n kind=\"Service\",\n metadata=client.V1ObjectMeta(\n name=name\n ),\n spec=client.V1ServiceSpec(\n selector={\"app\": name},\n type=service_type,\n ports=ports\n )\n )\n func = self.__client.patch_namespaced_service\n try:\n ret = func(\n name, namespace, body=body,\n **{'_return_http_data_only': False}\n )\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n logger.error(f'ApiClient sanitize_for_serialization 异常： {e}', )\n return {'error': True, 'message': str(e)}\n except ApiException as e:\n if e.status == 409:\n logger.error(f'ApiException 异常 409 资源冲突： {e} {e.reason}', )\n return {'error': True, 'ecode': e.status, 'message': e.body}\n except BaseException as e:\n logger.error(f'patch_namespaced_service 异常： {e}', )\n return {'error': True, 'message': str(e)}\n\n def delete_namespace_service(self, name, namespace='default', api_version='apps/v1'):\n try:\n ret = self.__client.delete_namespaced_service(name, namespace)\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n return {'error': True, 'message': str(e)}\n\n def get_configmaps(self, namespace='default', **kwargs):\n ret = self.__client.list_namespaced_config_map(namespace, **kwargs)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'error': True, 'message': str(e)}\n\n def get_configmap(self, name, namespace='default', **kwargs):\n \"\"\"\n get configmap content\n \"\"\"\n try:\n ret = self.__client.read_namespaced_config_map(\n name, namespace, **kwargs)\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'error': True, 'message': str(e)}\n\n def create_namespace_configmap(self, svc_yaml, namespace='default', **kwargs):\n if isinstance(svc_yaml, str):\n body = yaml.safe_load(svc_yaml)\n else:\n body = svc_yaml\n try:\n ret = self.__client.create_namespaced_config_map(\n namespace, body, **kwargs)\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n return {'error': True, 'message': str(e)}\n\n def update_namespace_configmap(self, name, svc_yaml, namespace='default', **kwargs):\n if isinstance(svc_yaml, str):\n body = yaml.safe_load(svc_yaml)\n else:\n body = svc_yaml\n try:\n ret = self.__client.patch_namespaced_config_map(\n name, namespace, body, **kwargs)\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n return {'error': True, 'message': str(e)}\n\n def delete_namespace_configmap(self, name, namespace='default', api_version='apps/v1'):\n try:\n ret = self.__client.delete_namespaced_config_map(name, namespace)\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n return {'error': True, 'message': str(e)}\n\n def get_namespace_deployment(self, namespace='default', api_version='apps/v1', **kwargs):\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\n self.__client.api_client)(client)\n ret = self.__client2.list_namespaced_deployment(namespace, **kwargs)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def create_namespace_deployment(self, name, image=None, port=list, replicas=1, deploy_yaml=None,\n pod_type='Deployment', namespace='default'):\n \"\"\"\n\n :param name:\n :param image:\n :param port: [{containerPort: 8080, protocol: 'TCP'}]\n :param replicas:\n :param pod_type:\n :param namespace:\n :return:\n \"\"\"\n payload = {'kind': pod_type, 'spec': {'replicas': replicas, 'template': {\n 'spec': {'containers': [{'image': image, 'name': name, 'ports': port}]},\n 'metadata': {'labels': {'app': name}}},\n 'selector': {'matchLabels': {'app': name}}},\n 'apiVersion': 'apps/v1beta2',\n 'metadata': {'labels': {'app': name}, 'namespace': namespace,\n 'name': name}}\n if deploy_yaml is not None:\n payload = yaml.safe_load(deploy_yaml)\n payload['metadata'].pop('resourceVersion', None)\n self.__client2 = operator.methodcaller(\n ''.join([i.capitalize() for i in payload.get(\n 'apiVersion', 'apps/v1beta2').split('/')]) + 'Api',\n self.__client.api_client)(client)\n try:\n ret = self.__client2.create_namespaced_deployment(\n namespace=namespace, body=payload)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n return {'ecode': e.status, 'message': e.body}\n except ApiException as e:\n return {'ecode': e.status, 'message': e.body}\n\n def delete_namespace_deployment(self, name, namespace='default', api_version='apps/v1'):\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\n self.__client.api_client)(client)\n ret = self.__client2.delete_namespaced_deployment(name, namespace,\n body=client.V1DeleteOptions(grace_period_seconds=0,\n propagation_policy='Foreground'))\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def update_deployment(self, name, replicas=None, image=None, envs=None, deploy_yaml=None, namespace='default',\n api_version='apps/v1', force=False):\n \"\"\"\n force: 强制更新\n \"\"\"\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\n self.__client.api_client)(client)\n payload = {'spec': {'replicas': replicas, 'template': {}}}\n if replicas is None and image is None and deploy_yaml is None:\n return {'err': '缺少参数'}\n if replicas is not None:\n payload['spec']['replicas'] = replicas\n if image is not None:\n payload['spec']['template'] = {\n 'spec': {'containers': [{'image': image, 'name': name}]}}\n\n if envs is not None:\n payload['spec']['template'] = {\n 'spec': {'containers': [{'env': envs}]}}\n\n if deploy_yaml is not None:\n payload = yaml.safe_load(deploy_yaml)\n payload['metadata'].pop('resourceVersion', None)\n try:\n if force:\n ret = self.__client2.replace_namespaced_deployment(\n name, namespace, body=payload)\n else:\n ret = self.__client2.patch_namespaced_deployment(\n name, namespace, body=payload)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n return {'ecode': e.status, 'message': e.body}\n except ApiException as e:\n return {'ecode': e.status, 'message': e.body}\n\n def update_deployment_replica(self, name, replicas, namespace='default', api_version='apps/v1'):\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\n self.__client.api_client)(client)\n payload = {'spec': {'replicas': replicas}}\n ret = self.__client2.patch_namespaced_deployment_scale(\n name, namespace, body=payload)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def update_deployment_image(self, name, image, namespace='default', api_version='apps/v1'):\n deploy = self.fetch_deployment(name, namespace)\n if deploy.get('ecode', 200) > 399:\n return deploy\n payload = {'spec': deploy['message']['spec']}\n payload['spec']['template']['spec']['containers'][0]['image'] = image\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\n self.__client.api_client)(client)\n try:\n ret = self.__client2.patch_namespaced_deployment(name, namespace, body=payload,\n **{'_return_http_data_only': False})\n except ApiException as e:\n return {'ecode': e.status, 'message': e.body}\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n return {'ecode': e.status, 'message': e.body}\n\n def update_deployment_resource(self, name, envs, image_policy, namespace='default', api_version='apps/v1',\n **kwargs):\n payload = {'spec': {'template': {'spec': {'containers': [\n {'name': name, 'env': envs, 'imagePullPolicy': image_policy, 'resources': kwargs['resources']}]}}}}\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\n self.__client.api_client)(client)\n ret = self.__client2.patch_namespaced_deployment(\n name, namespace, body=payload)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def restart_deployment(self, name, namespace='default', api_version='apps/v1'):\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\n self.__client.api_client)(client)\n payload = {\n 'spec': {\n 'template': {\n 'spec': {\n 'containers': [\n {\n 'name': name,\n 'env': [\n {\n 'name': 'RESTART_',\n 'value': datetime.now().strftime('%Y%m%d%H%M%S')\n }\n ]\n }\n ]\n }\n }\n }\n }\n\n ret = self.__client2.patch_namespaced_deployment(\n name, namespace, body=payload)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'err': str(e)}\n\n def fetch_deployment(self, name, namespace='default', api_version='apps/v1'):\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\n self.__client.api_client)(client)\n try:\n ret = self.__client2.read_namespaced_deployment(name, namespace)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except ApiException as e:\n return {'ecode': e.status, 'message': e.body}\n except ApiException as e:\n return {'ecode': e.status, 'message': e.body}\n\n def get_replica(self, namespace='default', api_version='apps/v1', **kwargs):\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\n self.__client.api_client)(client)\n try:\n ret = self.__client2.list_namespaced_replica_set(\n namespace=namespace, **kwargs)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except ApiException as e:\n return {'ecode': e.status, 'message': e.body}\n except ApiException as e:\n return {'ecode': e.status, 'message': e.body}\n\n def get_pods(self, namespace=None, **kwargs):\n if namespace is None:\n return {}\n try:\n ret = self.__client.list_namespaced_pod(namespace, **kwargs)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n return {'ecode': e.status, 'message': e.body}\n except ApiException as e:\n return {'ecode': e.status, 'message': e.body}\n\n def fetch_pod(self, name, namespace='default'):\n try:\n ret = self.__client.read_namespaced_pod(\n name=name, namespace=namespace)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return {'ecode': 200, 'message': rs}\n except BaseException as e:\n return {'ecode': e.status, 'message': e.body}\n except BaseException as e:\n return {'ecode': e.status, 'message': e.body}\n\n def get_secrets(self, namespace='default', **kwargs):\n ret = self.__client.list_namespaced_secret(namespace, **kwargs)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'error': True, 'message': str(e)}\n\n def get_secret(self, name, namespace='default', **kwargs):\n \"\"\"\n get secret content\n \"\"\"\n ret = self.__client.read_namespaced_secret(name, namespace, **kwargs)\n try:\n ret = self.__client.read_namespaced_secret(\n name, namespace, **kwargs)\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'error': True, 'message': str(e)}\n\n def manage_secret(self, name, namespace='default', api_version='v1', **kwargs):\n payload = kwargs.pop('payload', {})\n body = kubernetes.client.V1Secret(api_version=api_version, **payload)\n ret = {}\n try:\n ret = self.__client.replace_namespaced_secret(\n name, namespace, body, **kwargs)\n except ApiException as e:\n if e.status == 404:\n ret = self.__client.create_namespaced_secret(namespace, body)\n try:\n rs = ApiClient().sanitize_for_serialization(ret)\n return rs\n except BaseException as e:\n return {'error': True, 'message': str(e)}"}],"string":"[\n {\n \"identifier\": \"generate_docu\",\n \"path\": \"common/utils/ElasticSearchAPI.py\",\n \"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 _tbindex.settings(number_of_shards=3, number_of_replicas=1)\\n _fields = Mapping().generate_data_mapping(table)\\n docu = type(index_name, (CustomDocument,), _fields)\\n return _tbindex.document(docu)\"\n },\n {\n \"identifier\": \"Search\",\n \"path\": \"common/utils/ElasticSearchAPI.py\",\n \"snippet\": \"class Search(BaseSearch):\\n def __init__(self, prefix=False, **kwargs):\\n if kwargs.get('index', None) and prefix:\\n if isinstance(kwargs['index'], string_types):\\n kwargs['index'] = f\\\"{ELASTICSEARCH_PREFIX}{kwargs['index']}\\\"\\n elif isinstance(kwargs['index'], list):\\n kwargs['index'] = [\\n f\\\"{ELASTICSEARCH_PREFIX}{i}\\\" for i in kwargs['index']]\\n elif isinstance(kwargs['index'], tuple):\\n kwargs['index'] = tuple(\\n f\\\"{ELASTICSEARCH_PREFIX}{i}\\\" for i in kwargs['index'])\\n else:\\n raise Exception('索引名称格式错误!')\\n super(Search, self).__init__(**kwargs)\"\n },\n {\n \"identifier\": \"GitLabAPI\",\n \"path\": \"common/utils/GitLabAPI.py\",\n \"snippet\": \"class GitLabAPI(object):\\n def __init__(self, url, user=None, password=None, token=None, oauth=False):\\n self.__url = url\\n if token:\\n self.__token = token\\n if oauth:\\n params = {'oauth_token': self.__token}\\n else:\\n params = {'private_token': self.__token}\\n self.__gl = gitlab.Gitlab(self.__url, **params)\\n else:\\n self.__gl = gitlab.Gitlab(\\n self.__url, http_username=user, http_password=password)\\n self.__gl.auth()\\n\\n def get_gl(self):\\n return self.__gl\\n\\n def list_projects(self, get_all=False, key=None, per_page=20, page=1):\\n params = {'per_page': per_page, 'page': page}\\n if get_all:\\n params = {'get_all': True, 'per_page': per_page}\\n if key:\\n params['search'] = key\\n projects = self.__gl.projects.list(**params)\\n return projects\\n\\n def get_project(self, project_id=None, project_name_with_namespace=None):\\n if any([project_id, project_name_with_namespace]) is False:\\n raise Exception('缺少参数，project_id或project_name_with_namespace必选其一.')\\n condition = project_id or project_name_with_namespace\\n try:\\n project = self.__gl.projects.get(condition)\\n return project\\n except BaseException as e:\\n logger.info(e)\\n return None\\n\\n def create_project(self, name, namespace_id=None, initialize_with_readme=False):\\n payload = {'name': name, 'path': name,\\n 'initialize_with_readme': initialize_with_readme}\\n if namespace_id:\\n payload['namespace_id'] = namespace_id\\n try:\\n ret = self.__gl.projects.create(payload)\\n return True, ret\\n except BaseException as e:\\n logger.exception(f'创建分支请求异常，原因：{e.__dict__}')\\n return False, e\\n\\n def get_commit(self, commit_id, project_id=None, project_name_with_namespace=None):\\n try:\\n commit = self.get_project(\\n project_id, project_name_with_namespace).get(commit_id)\\n return commit\\n except BaseException as e:\\n logger.info(e)\\n return None\\n\\n def list_groups(self, get_all=False, key=None, per_page=20, page=1):\\n params = {'per_page': per_page, 'page': page}\\n if get_all:\\n params = {'get_all': True, 'all': True, 'per_page': per_page}\\n if key:\\n params['search'] = key\\n groups = self.__gl.groups.list(**params)\\n return [{'id': i.id, 'name': i.name, 'description': i.description} for i in groups if not i.parent_id]\\n\\n def create_group(self, name, path=None, desc=None, parent=None):\\n \\\"\\\"\\\"\\n 创建组\\n \\\"\\\"\\\"\\n payload = {'name': name, 'path': path or name,\\n 'description': desc or ''}\\n if parent:\\n payload['parent_id'] = parent\\n try:\\n group = self.__gl.groups.create(payload)\\n return True, group\\n except BaseException as e:\\n logger.info(e)\\n return False, e\\n\\n def create_branch(self, project, src_branch, target_branch):\\n payload = {'branch': target_branch,\\n 'ref': src_branch}\\n if isinstance(project, (int,)):\\n project = self.get_project(project)\\n try:\\n ret = project.branches.create(payload)\\n return True, ret\\n except BaseException as e:\\n logger.exception(f'创建分支请求异常，原因：{e.__dict__}')\\n return False, e\\n\\n def list_branches(self, project_id=None, project_name_with_namespace=None, get_all=False, key=None, per_page=20,\\n page=1, protected='0', *args, **kwargs):\\n params = {'per_page': per_page, 'page': page}\\n if not protected:\\n protected = '0'\\n if get_all:\\n params = {'get_all': True, 'per_page': per_page}\\n if key:\\n params['search'] = key\\n params.update(kwargs)\\n branches = self.get_project(project_id=project_id,\\n project_name_with_namespace=project_name_with_namespace).branches.list(**params)\\n branches = [{'uid': f\\\"{G_COMMIT[0][0]}:{i.name}\\\", 'name': i.name, 'commit': i.commit, 'label': G_COMMIT[0][0], 'protected': i.protected}\\n for i in branches]\\n if protected != '0':\\n # 过滤受保护分支\\n _map = {'1': True, '2': False}\\n branches = [i for i in branches if i['protected']\\n == _map[protected]]\\n return branches\\n\\n def list_protected_branches(self, project_id=None, project_name_with_namespace=None, get_all=False, key=None, per_page=20,\\n page=1, *args, **kwargs):\\n params = {'per_page': per_page, 'page': page}\\n if get_all:\\n params = {'get_all': True, 'per_page': per_page}\\n if key:\\n params['search'] = key\\n params.update(kwargs)\\n branches = self.get_project(project_id=project_id,\\n project_name_with_namespace=project_name_with_namespace).protectedbranches.list(**params)\\n branches = [{'uid': f\\\"{G_COMMIT[0][0]}:{i.name}\\\", 'name': i.name, 'commit': i.commit, 'label': G_COMMIT[0][0], 'protected': i.protected}\\n for i in branches]\\n return branches\\n\\n def list_tags(self, project_id=None, project_name_with_namespace=None, get_all=False, key=None, per_page=20,\\n page=1):\\n params = {'per_page': per_page, 'page': page}\\n if get_all:\\n params = {'get_all': True, 'per_page': per_page}\\n if key:\\n params['search'] = key\\n tags = self.get_project(\\n project_id, project_name_with_namespace).tags.list(**params)\\n tags = [{'uid': f\\\"{G_COMMIT[1][0]}:{i.name}\\\", 'name': i.name, 'message': i.message, 'commit': i.commit,\\n 'label': G_COMMIT[1][0]} for i in tags]\\n return tags\\n\\n def list_commits(self, project_id=None, project_name_with_namespace=None, get_all=False, key=None, per_page=20,\\n page=1, ref_name=None, since=None):\\n params = {'per_page': per_page, 'page': page}\\n if get_all:\\n params = {'get_all': True, 'per_page': per_page}\\n if key:\\n params['search'] = key\\n if ref_name:\\n params['ref_name'] = ref_name\\n if since:\\n params['since'] = since\\n commits = self.get_project(\\n project_id, project_name_with_namespace).commits.list(**params)\\n commits = [\\n {'title': i.title, 'short_id': i.short_id, 'author_name': i.author_name, 'committer_name': i.committer_name,\\n 'committed_date': i.committed_date, 'message': i.message, 'web_url': i.web_url} for i in commits]\\n return commits\\n\\n def repo_checkout(self, repo):\\n import subprocess\\n git_url = repo.split('//')\\n subprocess.call(\\n ['git', 'clone', f\\\"{git_url[0]}//oauth2:{self.__token}@{git_url[1]}\\\"])\\n\\n def get_user_id(self, username):\\n user_list = self.__gl.users.list(username=username)\\n if user_list:\\n return user_list[0].id\\n else:\\n return None\\n\\n def get_project_from_name(self, project_name):\\n projects = self.__gl.projects.list(search=project_name)\\n for p in projects:\\n if p.name == project_name:\\n return p\\n return None\\n\\n def add_project_member(self, project, user_id, access_level):\\n try:\\n project.members.create(\\n {'user_id': user_id, 'access_level': access_level})\\n return True, '成功'\\n except Exception as error:\\n return False, error\\n\\n def del_project_member(self, project, user_id):\\n try:\\n project.members.delete(user_id)\\n return True, '成功'\\n except Exception as error:\\n return False, error\"\n },\n {\n \"identifier\": \"HarborAPI\",\n \"path\": \"common/utils/HarborAPI.py\",\n \"snippet\": \"class HarborAPI(object):\\n def __init__(self, url, username, password):\\n self.__url = url.rstrip('/')\\n self.__user = username\\n self.__password = password\\n self.__token = base64.b64encode(\\n bytes('%s:%s' % (self.__user, self.__password), encoding='utf-8'))\\n self.__headers = dict()\\n self.__headers[\\\"Accept\\\"] = \\\"application/json\\\"\\n self.__headers['authorization'] = 'Basic %s' % str(\\n self.__token, encoding='utf-8')\\n\\n def request(self, method, obj=None, prefix='/'):\\n try:\\n if method == 'get':\\n req = requests.request(method, '%s%s' % (self.__url, prefix), params=obj, headers=self.__headers,\\n verify=False)\\n if req.status_code > 399:\\n return {'ecode': req.status_code, 'message': f'{req.content}\\\\n{req.reason}'}\\n res = {'ecode': req.status_code, 'data': req.json(), 'count': req.headers.get('X-Total-Count', None),\\n 'next': req.headers.get('Link', None)}\\n if method == 'delete':\\n req = requests.request(method, '%s%s' % (\\n self.__url, prefix), headers=self.__headers, verify=False)\\n if req.status_code > 399:\\n return {'ecode': req.status_code, 'message': f'{req.content}\\\\n{req.reason}'}\\n res = {'ecode': req.status_code, 'data': req.content}\\n if method in ['put', 'post']:\\n req = requests.request(method, '%s%s' % (self.__url, prefix), json=obj, headers=self.__headers,\\n verify=False)\\n if req.status_code > 399:\\n return {'ecode': req.status_code, 'message': f'{req.content}\\\\n{req.reason}'}\\n res = {'ecode': req.status_code, 'data': req.content}\\n if method == 'head':\\n req = requests.request(method, '%s%s' % (\\n self.__url, prefix), headers=self.__headers, verify=False)\\n if req.status_code > 399:\\n return {'ecode': req.status_code, 'message': f'{req.content}\\\\n{req.reason}'}\\n res = {'ecode': req.status_code, 'data': req.content}\\n except BaseException as e:\\n raise e\\n return res\\n\\n def systeminfo(self):\\n res = self.request('get', prefix='/systeminfo')\\n return res\\n\\n def get_users(self):\\n res = self.request('get', prefix='/users')\\n return res\\n\\n def get_projects(self, project_name=None, page=1, page_size=20):\\n \\\"\\\"\\\"\\n :project_name: The name of project\\n :page: default is 1.\\n :page_size: default is 10, maximum is 100.\\n \\\"\\\"\\\"\\n params = {'page': page, 'page_size': page_size}\\n if project_name:\\n params['name'] = project_name\\n try:\\n res = self.request('get', params, prefix='/projects')\\n return res\\n except BaseException as e:\\n return {'ecode': 500, 'message': e}\\n\\n def get_repositories(self, project_id, page=1, page_size=20, repo=None):\\n params = {'project_id': project_id,\\n 'page': page, 'page_size': page_size}\\n if repo:\\n params['q'] = repo\\n try:\\n res = self.request('get', params, '/repositories')\\n return res\\n except BaseException as e:\\n return {'ecode': 500, 'message': e}\\n\\n def get_tags(self, repo):\\n try:\\n res = self.request('get', prefix='/repositories/%s/tags' % repo)\\n tags = [\\n {'name': i['name'], 'created': i['created'], 'push_time': i.get(\\n 'push_time', None), 'size': i['size']}\\n for i in\\n res['data']]\\n tags.sort(key=lambda k: (k.get('created')), reverse=True)\\n return {'ecode': 200, 'data': tags, 'count': len(tags)}\\n except BaseException as e:\\n return {'ecode': 500, 'message': e}\\n\\n def fetch_project(self, project_id):\\n \\\"\\\"\\\"\\n 获取项目信息\\n \\\"\\\"\\\"\\n try:\\n res = self.request(\\n 'get', {'project_id': project_id}, prefix=f'/projects/{project_id}')\\n return res\\n except BaseException as e:\\n return {'ecode': 500, 'message': e}\\n\\n def fetch_tag(self, repo, tag):\\n \\\"\\\"\\\"\\n 获取指定镜像标签\\n \\\"\\\"\\\"\\n try:\\n res = self.request(\\n 'get', prefix=f'/repositories/{repo}/tags/{tag}')\\n return res\\n except BaseException as e:\\n return {'ecode': 500, 'message': e}\\n\\n def create_project(self, project_name, public=True):\\n \\\"\\\"\\\"\\n 创建仓库项目\\n \\\"\\\"\\\"\\n try:\\n data = {'project_name': project_name, 'metadata': {\\n 'public': 'true' if public else 'false'}}\\n res = self.request('post', obj=data, prefix='/projects')\\n return res\\n except BaseException as e:\\n return {'ecode': 500, 'message': e}\\n\\n def update_project(self, project_id, *args, **kwargs):\\n \\\"\\\"\\\"\\n 更新仓库项目\\n \\\"\\\"\\\"\\n try:\\n res = self.request('put', obj=kwargs,\\n prefix=f'/projects/{project_id}')\\n return res\\n except BaseException as e:\\n return {'ecode': 500, 'message': e}\\n\\n def project_exists(self, project_name):\\n \\\"\\\"\\\"\\n 查询项目是否存在\\n \\\"\\\"\\\"\\n try:\\n res = self.request(\\n 'head', prefix=f'/projects?project_name={project_name}')\\n return res\\n except BaseException as e:\\n return {'ecode': 500, 'message': e}\\n\\n def patch_tag(self, repo, src_image, tag_name):\\n \\\"\\\"\\\"\\n 镜像打标签\\n \\\"\\\"\\\"\\n try:\\n try:\\n # 创建仓库项目\\n res = self.create_project(repo.split('/')[0])\\n except BaseException as e:\\n pass\\n data = {'tag': tag_name, 'src_image': src_image, 'override': True}\\n res = self.request(\\n 'post', obj=data, prefix='/repositories/%s/tags' % repo)\\n return res\\n except BaseException as e:\\n return {'ecode': 500, 'message': e}\\n\\n def delete_tag(self, repo, tag):\\n \\\"\\\"\\\"\\n 删除标签\\n \\\"\\\"\\\"\\n try:\\n res = self.request(\\n 'delete', prefix=f'/repositories/{repo}/tags/{tag}')\\n return res\\n except BaseException as e:\\n logger.ex\\n return {'ecode': 500, 'message': e}\\n\\n def search(self, query):\\n \\\"\\\"\\\"\\n 搜索\\n \\\"\\\"\\\"\\n try:\\n res = self.request('get', {'q': query}, prefix='/search')\\n return res\\n except BaseException as e:\\n logger.exception(e)\\n return {'ecode': 500, 'message': e}\"\n },\n {\n \"identifier\": \"GlueJenkins\",\n \"path\": \"common/utils/JenkinsAPI.py\",\n \"snippet\": \"class GlueJenkins(Jenkins):\\n\\n def __init__(self, url=None, username=None, password=None):\\n self.__url = url\\n self.__username = username\\n self.__password = password\\n super(GlueJenkins, self).__init__(\\n self.__url, self.__username, self.__password)\\n\\n def _get_encoded_params(self, params):\\n for k, v in params.items():\\n if k in [\\\"name\\\", \\\"msg\\\", \\\"short_name\\\", \\\"from_short_name\\\",\\n \\\"to_short_name\\\", \\\"folder_url\\\", \\\"from_folder_url\\\", \\\"to_folder_url\\\"]:\\n params[k] = quote(v.encode('utf8'))\\n return params\\n\\n def _build_url(self, format_spec, variables=None):\\n\\n if variables:\\n url_path = format_spec % self._get_encoded_params(variables)\\n else:\\n url_path = format_spec\\n return str(urljoin(self.server, url_path))\\n\\n def assert_credential_exists(self, name, folder_name=None, domain_name='_',\\n exception_message='credential[%s] does not exist.'):\\n '''Raise an exception if credential does not exist in domain of folder\\n\\n :param name: Name of credential, ``str``\\n :param folder_name: Folder name, ``str``\\n :param domain_name: Domain name, default is '_', ``str``\\n :param exception_message: Message to use for the exception.\\n Formatted with ``name``, ``domain_name``,\\n and ``folder_name``\\n :throws: :class:`JenkinsException` whenever the credentail\\n does not exist in domain of folder\\n '''\\n if not self.credential_exists(name, folder_name, domain_name):\\n raise JenkinsException(exception_message\\n % name)\\n\\n def get_credential_global_config(self, name, domain_name='_'):\\n '''Get configuration of credential in domain of folder.\\n :param name: Name of credentail, ``str``\\n :param domain_name: Domain name, default is '_', ``str``\\n :returns: Credential configuration (XML format)\\n '''\\n return self.jenkins_open(requests.Request(\\n 'GET', self._build_url(CONFIG_CREDENTIAL_GLOBAL, locals())\\n ))\\n\\n def get_credential_info(self, name, folder_name=None, domain_name='_'):\\n '''Get credential information dictionary in domain of folder\\n\\n :param name: Name of credentail, ``str``\\n :param folder_name: folder_name, ``str``\\n :param domain_name: Domain name, default is '_', ``str``\\n :returns: Dictionary of credential info, ``dict``\\n '''\\n try:\\n response = self.jenkins_open(requests.Request(\\n 'GET', self._build_url(CREDENTIAL_INFO_GLOBAL, locals())\\n ))\\n if response:\\n return json.loads(response)\\n else:\\n raise JenkinsException('credential[%s] does not exist.' % name)\\n except (req_exc.HTTPError, NotFoundException):\\n raise JenkinsException('credential[%s] does not exist.' % name)\\n except ValueError:\\n raise JenkinsException(\\n 'Could not parse JSON info for credential[%s].' % name\\n )\\n\\n def credential_exists(self, name, folder_name=None, domain_name='_'):\\n '''Check whether a credentail exists in domain of folder\\n\\n :param name: Name of credentail, ``str``\\n :param folder_name: Folder name, ``str``\\n :param domain_name: Domain name, default is '_', ``str``\\n :returns: ``True`` if credentail exists, ``False`` otherwise\\n '''\\n try:\\n return self.get_credential_info(name)['id'] == name\\n except JenkinsException:\\n return False\\n\\n def create_credential_global(self, name=None, user=None, password=None, secret=None, comment=None, domain_name='_'):\\n '''Create credentail in domain of folder\\n\\n :param name: username\\n :param password: password\\n :param comment: comment, ``str``\\n :param config_xml: New XML configuration, ``str``\\n :param domain_name: Domain name, default is '_', ``str``\\n '''\\n st = shortuuid.ShortUUID()\\n st.set_alphabet(\\n f\\\"0123456789{''.join([chr(i) for i in range(ord('a'), ord('z') + 1)])}\\\")\\n if name is None:\\n name = '-'.join(['api', st.random(length=8),\\n st.random(length=4), st.random(length=12)])\\n config_xml = '''<com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl>\\n <scope>GLOBAL</scope>\\n <id>%s</id>\\n <description>[%s] Created by DevOps Platform</description>\\n <username>%s</username>\\n <password>%s</password>\\n</com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl>''' % (name, comment, user, password)\\n if user is None:\\n config_xml = '''<org.jenkinsci.plugins.plaincredentials.impl.StringCredentialsImpl>\\n <scope>GLOBAL</scope>\\n <id>%s</id>\\n <description>[%s] Created by DevOps Platform</description>\\n <secret>%s</secret>\\n</org.jenkinsci.plugins.plaincredentials.impl.StringCredentialsImpl>''' % (name, comment, secret)\\n if self.credential_exists(name):\\n raise JenkinsException('credential[%s] already exists.' % name)\\n\\n self.jenkins_open(requests.Request(\\n 'POST', self._build_url(CREATE_CREDENTIAL_GLOBAL, locals()),\\n data=config_xml.encode('utf-8'),\\n headers=DEFAULT_HEADERS\\n ))\\n self.assert_credential_exists(\\n name, exception_message='create credential[%s] failed.')\\n return {'status': 0, 'data': name}\\n\\n def reconfig_credential_global(self, name, user=None, password=None, secret=None, comment=None, domain_name='_'):\\n \\\"\\\"\\\"\\n Reconfig credential with new config in domain of folder\\n :param name: name, ``str``\\n :param user:\\n :param password:\\n :param secret:\\n :param comment:\\n :param domain_name: Domain name, default is '_', ``str``\\n :return:\\n \\\"\\\"\\\"\\n reconfig_url = self._build_url(CONFIG_CREDENTIAL_GLOBAL, locals())\\n config_xml = self.get_credential_global_config(name)\\n xml_dict = xmltodict.parse(config_xml)\\n if user is None:\\n xml_dict['org.jenkinsci.plugins.plaincredentials.impl.StringCredentialsImpl']['secret'] = secret\\n if comment:\\n xml_dict['org.jenkinsci.plugins.plaincredentials.impl.StringCredentialsImpl']['description'] = comment\\n else:\\n xml_dict['com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl']['username'] = user\\n xml_dict['com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl']['password'] = password\\n if comment:\\n xml_dict['com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl'][\\n 'description'] = comment\\n config_xml = xmltodict.unparse(xml_dict, pretty=True)\\n self.jenkins_open(requests.Request(\\n 'POST', reconfig_url,\\n data=config_xml.encode('utf-8'),\\n headers=DEFAULT_HEADERS\\n ))\\n\\n def create_job(self, name, config_xml):\\n '''Create a new Jenkins job\\n\\n :param name: Name of Jenkins job, ``str``\\n :param config_xml: config file text, ``str``\\n '''\\n folder_url, short_name = self._get_job_folder(name)\\n if self.job_exists(name):\\n raise JenkinsException('job[%s] already exists' % (name))\\n\\n try:\\n self.jenkins_open(requests.Request(\\n 'POST', self._build_url(CREATE_JOB, locals()),\\n data=config_xml.encode('utf-8'),\\n headers=DEFAULT_HEADERS\\n ))\\n except NotFoundException:\\n raise JenkinsException('Cannot create job[%s] because folder '\\n 'for the job does not exist' % (name))\\n self.assert_job_exists(name, 'create[%s] failed')\\n\\n def reconfig_job(self, name, config_xml):\\n '''Change configuration of existing Jenkins job.\\n\\n To create a new job, see :meth:`Jenkins.create_job`.\\n\\n :param name: Name of Jenkins job, ``str``\\n :param config_xml: New XML configuration, ``str``\\n '''\\n folder_url, short_name = self._get_job_folder(name)\\n reconfig_url = self._build_url(CONFIG_JOB, locals())\\n self.jenkins_open(requests.Request(\\n 'POST', reconfig_url,\\n data=config_xml.encode('utf-8'),\\n headers=DEFAULT_HEADERS\\n ))\\n\\n def get_stage_describe(self, name, number, node_number):\\n \\\"\\\"\\\" 获取 单个stage 详情 \\\"\\\"\\\"\\n folder_url, short_name = self._get_job_folder(name)\\n try:\\n response = self.jenkins_open(requests.Request(\\n 'GET', self._build_url(STAGE_DES, locals())\\n ))\\n\\n if response:\\n return json.loads(response)\\n else:\\n raise JenkinsException('job[%s] number[%d] does not exist'\\n % (name, number))\\n except (req_exc.HTTPError, NotFoundException):\\n raise JenkinsException('job[%s] number[%d] does not exist'\\n % (name, number))\\n except ValueError:\\n raise JenkinsException(\\n 'Could not parse JSON info for job[%s] number[%d]'\\n % (name, number)\\n )\\n\\n def get_stage_logs(self, name, number, node_number):\\n \\\"\\\"\\\" 获取 stage 执行日志\\\"\\\"\\\"\\n folder_url, short_name = self._get_job_folder(name)\\n try:\\n response = self.jenkins_open(requests.Request(\\n 'GET', self._build_url(STAGE_LOG, locals())\\n ))\\n if response:\\n return json.loads(response)\\n else:\\n raise JenkinsException('job[%s] number[%d] does not exist'\\n % (name, number))\\n except (req_exc.HTTPError, NotFoundException):\\n raise JenkinsException('job[%s] number[%d] does not exist'\\n % (name, number))\\n except ValueError:\\n raise JenkinsException(\\n 'Could not parse JSON info for job[%s] number[%d]'\\n % (name, number)\\n )\\n\\n def get_stage_info(self, name, number, depth=0):\\n\\n folder_url, short_name = self._get_job_folder(name)\\n try:\\n response = self.jenkins_open(requests.Request(\\n 'GET', self._build_url(STAGE_INFO, locals())\\n ))\\n if response:\\n return json.loads(response)\\n else:\\n raise JenkinsException('job[%s] number[%d] does not exist'\\n % (name, number))\\n except (req_exc.HTTPError, NotFoundException):\\n raise JenkinsException('job[%s] number[%d] does not exist'\\n % (name, number))\\n except ValueError:\\n raise JenkinsException(\\n 'Could not parse JSON info for job[%s] number[%d]'\\n % (name, number)\\n )\\n\\n def get_flow_detail(self, job_name, build_number):\\n stage_data = self.get_stage_info(name=job_name, number=build_number)\\n stages = stage_data.get('stages')\\n for i in stages:\\n logs = ''\\n try:\\n # 获取stage返回信息\\n response = self.jenkins_open(requests.Request(\\n 'GET', self._build_url(\\n unquote(i['_links']['self']['href']), locals())\\n ))\\n if response:\\n res = json.loads(response)\\n for j in res['stageFlowNodes']:\\n response = self.jenkins_open(requests.Request(\\n 'GET', self._build_url(\\n unquote(j['_links']['log']['href']), locals())\\n ))\\n res = json.loads(response)\\n try:\\n # 移除href html信息，保留链接文字\\n import re\\n pat = re.compile('<a href[^>]*>')\\n logs = logs + '\\\\n' + \\\\\\n pat.sub('', res['text'].replace('</a>', ''))\\n except:\\n pass\\n else:\\n raise JenkinsException('job[%s] number[%d] does not exist'\\n % (job_name, build_number))\\n except (req_exc.HTTPError, NotFoundException):\\n raise JenkinsException('job[%s] number[%d] does not exist'\\n % (job_name, build_number))\\n except ValueError:\\n raise JenkinsException(\\n 'Could not parse JSON info for job[%s] number[%d]'\\n % (job_name, build_number)\\n )\\n\\n stage_data[\\\"stages\\\"][stages.index(i)]['logs'] = logs\\n return stage_data\\n\\n def get_queue_item(self, number, depth=0):\\n '''Get information about a queued item (to-be-created job).\\n\\n The returned dict will have a \\\"why\\\" key if the queued item is still\\n waiting for an executor.\\n\\n The returned dict will have an \\\"executable\\\" key if the queued item is\\n running on an executor, or has completed running. Use this to\\n determine the job number / URL.\\n\\n :param name: queue number, ``int``\\n :returns: dictionary of queued information, ``dict``\\n '''\\n url = self._build_url(Q_ITEM, locals())\\n try:\\n response = self.jenkins_open(requests.Request('GET', url))\\n if response:\\n return json.loads(response)\\n else:\\n raise JenkinsException('queue number[%d] does not exist'\\n % number)\\n except (req_exc.HTTPError, NotFoundException):\\n raise JenkinsException('queue number[%d] does not exist' % number)\\n except ValueError:\\n raise JenkinsException(\\n 'Could not parse JSON info for queue number[%d]' % number\\n )\\n\\n def build_job(self, name, parameters=None, token=None):\\n '''Trigger build job.\\n\\n This method returns a queue item number that you can pass to\\n :meth:`Jenkins.get_queue_item`. Note that this queue number is only\\n valid for about five minutes after the job completes, so you should\\n get/poll the queue information as soon as possible to determine the\\n job's URL.\\n\\n :param name: name of job\\n :param parameters: parameters for job, or ``None``, ``dict``\\n :param token: Jenkins API token\\n :returns: ``int`` queue item\\n '''\\n response = self.jenkins_request(requests.Request(\\n 'POST', self.build_job_url(name, parameters, token)))\\n\\n if 'Location' not in response.headers:\\n raise EmptyResponseException(\\n \\\"Header 'Location' not found in \\\"\\n \\\"response from server[%s]\\\" % self.server)\\n\\n location = response.headers['Location']\\n if location.endswith('/'):\\n location = location[:-1]\\n parts = location.split('/')\\n number = int(parts[-1])\\n return number\\n\\n def get_job_config(self, name):\\n '''Get configuration of existing Jenkins job.\\n\\n :param name: Name of Jenkins job, ``str``\\n :returns: job configuration (XML format)\\n '''\\n folder_url, short_name = self._get_job_folder(name)\\n request = requests.Request(\\n 'GET', self._build_url(CONFIG_JOB, locals()))\\n return self.jenkins_open(request)\\n\\n def get_job_info(self, name, depth=0, fetch_all_builds=False):\\n '''Get job information dictionary.\\n\\n :param name: Job name, ``str``\\n :param depth: JSON depth, ``int``\\n :param fetch_all_builds: If true, all builds will be retrieved\\n from Jenkins. Otherwise, Jenkins will\\n only return the most recent 100\\n builds. This comes at the expense of\\n an additional API call which may\\n return significant amounts of\\n data. ``bool``\\n :returns: dictionary of job information\\n '''\\n folder_url, short_name = self._get_job_folder(name)\\n try:\\n response = self.jenkins_open(requests.Request(\\n 'GET', self._build_url(JOB_INFO, locals())\\n ))\\n if response:\\n if fetch_all_builds:\\n return self._add_missing_builds(json.loads(response))\\n else:\\n return json.loads(response)\\n else:\\n raise JenkinsException('job[%s] does not exist' % name)\\n except (req_exc.HTTPError, NotFoundException):\\n raise JenkinsException('job[%s] does not exist' % name)\\n except ValueError:\\n raise JenkinsException(\\n \\\"Could not parse JSON info for job[%s]\\\" % name)\"\n },\n {\n \"identifier\": \"convert_xml_to_str_with_pipeline\",\n \"path\": \"common/custom_format.py\",\n \"snippet\": \"def convert_xml_to_str_with_pipeline(xml, url, secret, desc, jenkinsfile, scm=True):\\n \\\"\\\"\\\"\\n scm\\n True: jenkinsfile为指定的git地址\\n False: jenkinsfile为具体的pipeline\\n \\\"\\\"\\\"\\n xml_dict = xmltodict.parse(xml)\\n if scm:\\n xml_dict['flow-definition']['definition']['@class'] = 'org.jenkinsci.plugins.workflow.cps.CpsScmFlowDefinition'\\n xml_dict['flow-definition']['definition']['scm']['userRemoteConfigs']['hudson.plugins.git.UserRemoteConfig'][\\n 'url'] = url\\n xml_dict['flow-definition']['definition']['scm']['userRemoteConfigs']['hudson.plugins.git.UserRemoteConfig'][\\n 'credentialsId'] = secret\\n xml_dict['flow-definition']['definition']['scriptPath'] = jenkinsfile\\n else:\\n xml_dict['flow-definition']['definition']['@class'] = 'org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition'\\n xml_dict['flow-definition']['definition']['script'] = jenkinsfile\\n xml_dict['flow-definition']['definition']['sandbox'] = 'true'\\n xml_dict['flow-definition']['description'] = desc\\n result = xmltodict.unparse(\\n xml_dict, short_empty_elements=True, pretty=True)\\n return result\"\n },\n {\n \"identifier\": \"DASHBOARD_TIME_FORMAT\",\n \"path\": \"common/variables.py\",\n \"snippet\": \"DASHBOARD_TIME_FORMAT = {'year_only': '%Y', 'years': '%Y-%m', 'months': '%Y-%m-%d', 'days': '%Y-%m-%d %H:00:00',\\n 'hours': '%Y-%m-%d %H:%M:00', 'minutes': '%Y-%m-%d %H:%M:%S'}\"\n },\n {\n \"identifier\": \"DASHBOARD_TIME_FORMAT_T\",\n \"path\": \"common/variables.py\",\n \"snippet\": \"DASHBOARD_TIME_FORMAT_T = {'years': '%Y', 'months': '%Y-%m', 'days': '%Y-%m-%d', 'hours': \\\"%Y-%m-%d %H:00:00\\\",\\n 'minutes': \\\"%Y-%m-%d %H:%M:00\\\", 'seconds': \\\"%Y-%m-%d %H:%M:%S\\\"}\"\n },\n {\n \"identifier\": \"DASHBOARD_TIME_FREQNAMES\",\n \"path\": \"common/variables.py\",\n \"snippet\": \"DASHBOARD_TIME_FREQNAMES = {'year_only': YEARLY, 'years': MONTHLY, 'months': DAILY, 'days': HOURLY, 'hours': MINUTELY,\\n 'minutes': SECONDLY}\"\n },\n {\n \"identifier\": \"DASHBOARD_TIME_FREQNAMES_T\",\n \"path\": \"common/variables.py\",\n \"snippet\": \"DASHBOARD_TIME_FREQNAMES_T = {'years': YEARLY, 'months': MONTHLY, 'days': DAILY, 'hours': HOURLY, 'minutes': MINUTELY,\\n 'seconds': SECONDLY}\"\n },\n {\n \"identifier\": \"SENSITIVE_KEYS\",\n \"path\": \"common/variables.py\",\n \"snippet\": \"SENSITIVE_KEYS = ['password', 'token', 'access',\\n 'refresh', 'AUTHORIZATION', 'COOKIE']\"\n },\n {\n \"identifier\": \"JENKINS_CALLBACK_KEY\",\n \"path\": \"common/variables.py\",\n \"snippet\": \"JENKINS_CALLBACK_KEY = 'jenkins_callback_flag::'\"\n },\n {\n \"identifier\": \"JENKINS_STATUS_MAP\",\n \"path\": \"common/variables.py\",\n \"snippet\": \"JENKINS_STATUS_MAP = {'IN_PROGRESS': 3, 'SUCCESS': 1, 'FAILED': 2, 'ABORTED': 4, 'FAILURE': 2, 'NOT_EXECUTED': 5,\\n 'NOT_EXEC_TIMEOUT': 5}\"\n },\n {\n \"identifier\": \"DEV_LANGUAGE_KEY\",\n \"path\": \"common/variables.py\",\n \"snippet\": \"DEV_LANGUAGE_KEY = 'devlanguage:'\"\n },\n {\n \"identifier\": \"AppInfo\",\n \"path\": \"dbapp/models.py\",\n \"snippet\": \"\"\n },\n {\n \"identifier\": \"K8sAPI\",\n \"path\": \"common/utils/K8sAPI.py\",\n \"snippet\": \"class K8sAPI(object):\\n def __init__(self, host=None, username=None, password=None, api_key=None, api_key_prefix='Bearer', verify_ssl=False,\\n k8s_config=None,\\n config_file=None, eks=None):\\n \\\"\\\"\\\"\\n elk: aws kubernetes\\n \\\"\\\"\\\"\\n self.__host = host\\n self.__username = username\\n self.__password = password\\n self.__api_key = api_key\\n self.__api_key_prefix = api_key_prefix\\n self.__verify_ssl = verify_ssl\\n if k8s_config is not None:\\n config.kube_config.load_kube_config_from_dict(k8s_config)\\n self.__client0 = client.CoreApi()\\n self.__client = client.CoreV1Api()\\n elif config_file is not None:\\n config.kube_config.load_kube_config(config_file=config_file)\\n self.__client0 = client.CoreApi()\\n self.__client = client.CoreV1Api()\\n elif self.__host:\\n if self.__username and self.__password:\\n self.__client = self.get_api()\\n else:\\n raise Exception('Please input username/password or api_key')\\n else:\\n raise Exception('Cannot find k8s config')\\n self.client = self.__client\\n\\n def get_token(self):\\n pass\\n\\n def get_api(self):\\n configuration = client.Configuration()\\n configuration.host = self.__host\\n if self.__verify_ssl is False:\\n configuration.verify_ssl = False\\n configuration.username = self.__username\\n configuration.password = self.__password\\n basic_auth_token = configuration.get_basic_auth_token()\\n api = core_v1_api.CoreV1Api(api_client.ApiClient(configuration=configuration, header_name=\\\"authorization\\\",\\n header_value=basic_auth_token))\\n return api\\n\\n def get_client(self):\\n return self.__client\\n\\n def set_client(self, obj):\\n self.__client = getattr(client, obj)()\\n\\n def get_apis(self):\\n print(\\\"Supported APIs (* is preferred version):\\\")\\n self.__client2 = client.ApisApi(self.__client0.api_client)\\n for api in self.__client2.get_api_versions().groups:\\n versions = []\\n for v in api.versions:\\n name = \\\"\\\"\\n if v.version == api.preferred_version.version and len(\\n api.versions) > 1:\\n name += \\\"*\\\"\\n name += v.version\\n versions.append(name)\\n\\n def get_nodes(self, **kwargs):\\n ret = self.__client.list_node(**kwargs)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def get_node_info(self, name):\\n ret = self.__client.read_node_status(name)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def get_namespaces(self, **kwargs):\\n ret = self.__client.list_namespace(**kwargs)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def create_namespace(self, name):\\n payload = {\\n \\\"apiVersion\\\": \\\"v1\\\",\\n \\\"kind\\\": \\\"Namespace\\\",\\n \\\"metadata\\\": {\\n \\\"name\\\": name,\\n }\\n }\\n ret = self.__client.create_namespace(body=payload)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n print(rs)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def get_services(self, namespace='default', **kwargs):\\n ret = self.__client.list_namespaced_service(namespace, **kwargs)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def fetch_service(self, name, namespace='default', api_version='apps/v1'):\\n try:\\n ret = self.__client.read_namespaced_service(name, namespace)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n print('reason', e.reason)\\n return {'ecode': e.status, 'message': e.body}\\n except BaseException as e:\\n print('reason', e.reason)\\n return {'ecode': e.status, 'message': e.body}\\n\\n def create_namespace_service(self, name, app=None, targets=list, namespace='default', service_type='NodePort',\\n svc_yaml=None):\\n \\\"\\\"\\\"\\n 目前只支持NodePort类型，对外服务端口随机生成（如手动生成，需配置node_port和endpoints）\\n :param name: service name\\n :param app: app name\\n :param targets: [{port, target_port, protocol, node_port}]\\n :param namespace:\\n :param service_type:\\n :return:\\n \\\"\\\"\\\"\\n ports = []\\n if svc_yaml:\\n if isinstance(svc_yaml, str):\\n body = yaml.safe_load(svc_yaml)\\n else:\\n body = svc_yaml\\n else:\\n for index, target in enumerate(targets):\\n port_body = {'name': f\\\"{name}-{index}\\\", 'port': target['port'], 'target_port': target['port'],\\n 'protocol': target['protocol']}\\n if target['node_port'] > 30000:\\n port_body['node_port'] = target['node_port']\\n ports.append(client.V1ServicePort(**port_body))\\n body = client.V1Service(\\n api_version=\\\"v1\\\",\\n kind=\\\"Service\\\",\\n metadata=client.V1ObjectMeta(\\n name=name\\n ),\\n spec=client.V1ServiceSpec(\\n selector={\\\"app\\\": app},\\n type=service_type,\\n ports=ports\\n )\\n )\\n try:\\n ret = self.__client.create_namespaced_service(namespace=namespace, body=body,\\n **{'_return_http_data_only': False})\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n logger.error('reason', e)\\n return {'error': True, 'message': str(e)}\\n except ApiException as e:\\n if e.status == 409:\\n logger.error('reason', e.reason)\\n return {'error': True, 'ecode': e.status, 'message': e.body}\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\\n\\n def update_namespace_service(self, name, app=None, targets=Type[list], namespace='default', service_type='NodePort',\\n svc_yaml=None):\\n ports = []\\n if svc_yaml:\\n if isinstance(svc_yaml, str):\\n body = yaml.safe_load(svc_yaml)\\n else:\\n body = svc_yaml\\n logger.debug(f'svc_yaml body == {body}')\\n func = self.__client.replace_namespaced_service\\n else:\\n for index, target in enumerate(targets):\\n port_body = {'name': target['name'], 'port': target['port'], 'target_port': target['port'],\\n 'protocol': target['protocol']}\\n if target['node_port'] > 30000:\\n port_body['node_port'] = target['node_port']\\n ports.append(client.V1ServicePort(**port_body))\\n body = client.V1Service(\\n api_version=\\\"v1\\\",\\n kind=\\\"Service\\\",\\n metadata=client.V1ObjectMeta(\\n name=name\\n ),\\n spec=client.V1ServiceSpec(\\n selector={\\\"app\\\": name},\\n type=service_type,\\n ports=ports\\n )\\n )\\n func = self.__client.patch_namespaced_service\\n try:\\n ret = func(\\n name, namespace, body=body,\\n **{'_return_http_data_only': False}\\n )\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n logger.error(f'ApiClient sanitize_for_serialization 异常： {e}', )\\n return {'error': True, 'message': str(e)}\\n except ApiException as e:\\n if e.status == 409:\\n logger.error(f'ApiException 异常 409 资源冲突： {e} {e.reason}', )\\n return {'error': True, 'ecode': e.status, 'message': e.body}\\n except BaseException as e:\\n logger.error(f'patch_namespaced_service 异常： {e}', )\\n return {'error': True, 'message': str(e)}\\n\\n def delete_namespace_service(self, name, namespace='default', api_version='apps/v1'):\\n try:\\n ret = self.__client.delete_namespaced_service(name, namespace)\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\\n\\n def get_configmaps(self, namespace='default', **kwargs):\\n ret = self.__client.list_namespaced_config_map(namespace, **kwargs)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\\n\\n def get_configmap(self, name, namespace='default', **kwargs):\\n \\\"\\\"\\\"\\n get configmap content\\n \\\"\\\"\\\"\\n try:\\n ret = self.__client.read_namespaced_config_map(\\n name, namespace, **kwargs)\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\\n\\n def create_namespace_configmap(self, svc_yaml, namespace='default', **kwargs):\\n if isinstance(svc_yaml, str):\\n body = yaml.safe_load(svc_yaml)\\n else:\\n body = svc_yaml\\n try:\\n ret = self.__client.create_namespaced_config_map(\\n namespace, body, **kwargs)\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\\n\\n def update_namespace_configmap(self, name, svc_yaml, namespace='default', **kwargs):\\n if isinstance(svc_yaml, str):\\n body = yaml.safe_load(svc_yaml)\\n else:\\n body = svc_yaml\\n try:\\n ret = self.__client.patch_namespaced_config_map(\\n name, namespace, body, **kwargs)\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\\n\\n def delete_namespace_configmap(self, name, namespace='default', api_version='apps/v1'):\\n try:\\n ret = self.__client.delete_namespaced_config_map(name, namespace)\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\\n\\n def get_namespace_deployment(self, namespace='default', api_version='apps/v1', **kwargs):\\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n ret = self.__client2.list_namespaced_deployment(namespace, **kwargs)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def create_namespace_deployment(self, name, image=None, port=list, replicas=1, deploy_yaml=None,\\n pod_type='Deployment', namespace='default'):\\n \\\"\\\"\\\"\\n\\n :param name:\\n :param image:\\n :param port: [{containerPort: 8080, protocol: 'TCP'}]\\n :param replicas:\\n :param pod_type:\\n :param namespace:\\n :return:\\n \\\"\\\"\\\"\\n payload = {'kind': pod_type, 'spec': {'replicas': replicas, 'template': {\\n 'spec': {'containers': [{'image': image, 'name': name, 'ports': port}]},\\n 'metadata': {'labels': {'app': name}}},\\n 'selector': {'matchLabels': {'app': name}}},\\n 'apiVersion': 'apps/v1beta2',\\n 'metadata': {'labels': {'app': name}, 'namespace': namespace,\\n 'name': name}}\\n if deploy_yaml is not None:\\n payload = yaml.safe_load(deploy_yaml)\\n payload['metadata'].pop('resourceVersion', None)\\n self.__client2 = operator.methodcaller(\\n ''.join([i.capitalize() for i in payload.get(\\n 'apiVersion', 'apps/v1beta2').split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n try:\\n ret = self.__client2.create_namespaced_deployment(\\n namespace=namespace, body=payload)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n return {'ecode': e.status, 'message': e.body}\\n except ApiException as e:\\n return {'ecode': e.status, 'message': e.body}\\n\\n def delete_namespace_deployment(self, name, namespace='default', api_version='apps/v1'):\\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n ret = self.__client2.delete_namespaced_deployment(name, namespace,\\n body=client.V1DeleteOptions(grace_period_seconds=0,\\n propagation_policy='Foreground'))\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def update_deployment(self, name, replicas=None, image=None, envs=None, deploy_yaml=None, namespace='default',\\n api_version='apps/v1', force=False):\\n \\\"\\\"\\\"\\n force: 强制更新\\n \\\"\\\"\\\"\\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n payload = {'spec': {'replicas': replicas, 'template': {}}}\\n if replicas is None and image is None and deploy_yaml is None:\\n return {'err': '缺少参数'}\\n if replicas is not None:\\n payload['spec']['replicas'] = replicas\\n if image is not None:\\n payload['spec']['template'] = {\\n 'spec': {'containers': [{'image': image, 'name': name}]}}\\n\\n if envs is not None:\\n payload['spec']['template'] = {\\n 'spec': {'containers': [{'env': envs}]}}\\n\\n if deploy_yaml is not None:\\n payload = yaml.safe_load(deploy_yaml)\\n payload['metadata'].pop('resourceVersion', None)\\n try:\\n if force:\\n ret = self.__client2.replace_namespaced_deployment(\\n name, namespace, body=payload)\\n else:\\n ret = self.__client2.patch_namespaced_deployment(\\n name, namespace, body=payload)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n return {'ecode': e.status, 'message': e.body}\\n except ApiException as e:\\n return {'ecode': e.status, 'message': e.body}\\n\\n def update_deployment_replica(self, name, replicas, namespace='default', api_version='apps/v1'):\\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n payload = {'spec': {'replicas': replicas}}\\n ret = self.__client2.patch_namespaced_deployment_scale(\\n name, namespace, body=payload)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def update_deployment_image(self, name, image, namespace='default', api_version='apps/v1'):\\n deploy = self.fetch_deployment(name, namespace)\\n if deploy.get('ecode', 200) > 399:\\n return deploy\\n payload = {'spec': deploy['message']['spec']}\\n payload['spec']['template']['spec']['containers'][0]['image'] = image\\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n try:\\n ret = self.__client2.patch_namespaced_deployment(name, namespace, body=payload,\\n **{'_return_http_data_only': False})\\n except ApiException as e:\\n return {'ecode': e.status, 'message': e.body}\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n return {'ecode': e.status, 'message': e.body}\\n\\n def update_deployment_resource(self, name, envs, image_policy, namespace='default', api_version='apps/v1',\\n **kwargs):\\n payload = {'spec': {'template': {'spec': {'containers': [\\n {'name': name, 'env': envs, 'imagePullPolicy': image_policy, 'resources': kwargs['resources']}]}}}}\\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n ret = self.__client2.patch_namespaced_deployment(\\n name, namespace, body=payload)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def restart_deployment(self, name, namespace='default', api_version='apps/v1'):\\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n payload = {\\n 'spec': {\\n 'template': {\\n 'spec': {\\n 'containers': [\\n {\\n 'name': name,\\n 'env': [\\n {\\n 'name': 'RESTART_',\\n 'value': datetime.now().strftime('%Y%m%d%H%M%S')\\n }\\n ]\\n }\\n ]\\n }\\n }\\n }\\n }\\n\\n ret = self.__client2.patch_namespaced_deployment(\\n name, namespace, body=payload)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'err': str(e)}\\n\\n def fetch_deployment(self, name, namespace='default', api_version='apps/v1'):\\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n try:\\n ret = self.__client2.read_namespaced_deployment(name, namespace)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except ApiException as e:\\n return {'ecode': e.status, 'message': e.body}\\n except ApiException as e:\\n return {'ecode': e.status, 'message': e.body}\\n\\n def get_replica(self, namespace='default', api_version='apps/v1', **kwargs):\\n self.__client2 = operator.methodcaller(''.join([i.capitalize() for i in api_version.split('/')]) + 'Api',\\n self.__client.api_client)(client)\\n try:\\n ret = self.__client2.list_namespaced_replica_set(\\n namespace=namespace, **kwargs)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except ApiException as e:\\n return {'ecode': e.status, 'message': e.body}\\n except ApiException as e:\\n return {'ecode': e.status, 'message': e.body}\\n\\n def get_pods(self, namespace=None, **kwargs):\\n if namespace is None:\\n return {}\\n try:\\n ret = self.__client.list_namespaced_pod(namespace, **kwargs)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n return {'ecode': e.status, 'message': e.body}\\n except ApiException as e:\\n return {'ecode': e.status, 'message': e.body}\\n\\n def fetch_pod(self, name, namespace='default'):\\n try:\\n ret = self.__client.read_namespaced_pod(\\n name=name, namespace=namespace)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return {'ecode': 200, 'message': rs}\\n except BaseException as e:\\n return {'ecode': e.status, 'message': e.body}\\n except BaseException as e:\\n return {'ecode': e.status, 'message': e.body}\\n\\n def get_secrets(self, namespace='default', **kwargs):\\n ret = self.__client.list_namespaced_secret(namespace, **kwargs)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\\n\\n def get_secret(self, name, namespace='default', **kwargs):\\n \\\"\\\"\\\"\\n get secret content\\n \\\"\\\"\\\"\\n ret = self.__client.read_namespaced_secret(name, namespace, **kwargs)\\n try:\\n ret = self.__client.read_namespaced_secret(\\n name, namespace, **kwargs)\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\\n\\n def manage_secret(self, name, namespace='default', api_version='v1', **kwargs):\\n payload = kwargs.pop('payload', {})\\n body = kubernetes.client.V1Secret(api_version=api_version, **payload)\\n ret = {}\\n try:\\n ret = self.__client.replace_namespaced_secret(\\n name, namespace, body, **kwargs)\\n except ApiException as e:\\n if e.status == 404:\\n ret = self.__client.create_namespaced_secret(namespace, body)\\n try:\\n rs = ApiClient().sanitize_for_serialization(ret)\\n return rs\\n except BaseException as e:\\n return {'error': True, 'message': str(e)}\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from gitlab.exceptions import GitlabGetError\nfrom functools import reduce\nfrom common.utils.ElasticSearchAPI import generate_docu, Search\nfrom common.utils.GitLabAPI import GitLabAPI\nfrom common.utils.HarborAPI import HarborAPI\nfrom common.utils.JenkinsAPI import GlueJenkins\nfrom common.custom_format import convert_xml_to_str_with_pipeline\nfrom common.variables import DASHBOARD_TIME_FORMAT, DASHBOARD_TIME_FORMAT_T, DASHBOARD_TIME_FREQNAMES, \\\n DASHBOARD_TIME_FREQNAMES_T, SENSITIVE_KEYS, JENKINS_CALLBACK_KEY, \\\n JENKINS_STATUS_MAP, DEV_LANGUAGE_KEY\nfrom dbapp.models import AppInfo, Product, KubernetesCluster, KubernetesDeploy, MicroApp, Project, ProjectConfig, DevLanguage, BuildJob, UserProfile, SystemConfig, Role, Permission, Menu, DataDict\nfrom django.conf import settings\nfrom django.core.cache import cache\nfrom django.utils import timezone\nfrom django.db.models import Q\nfrom social_django.utils import load_strategy\nfrom rest_framework.utils.serializer_helpers import ReturnDict\nfrom config import SOCIAL_AUTH_GITLAB_API_URL, GITLAB_ADMIN_TOKEN\nfrom common.utils.K8sAPI import K8sAPI\nfrom urllib.parse import urlparse, quote_plus\nfrom dateutil.relativedelta import relativedelta\nfrom dateutil.rrule import rrule\nfrom ruamel import yaml\nfrom datetime import datetime, timedelta\n from celery import current_app\nimport copy\nimport operator\nimport re\nimport time\nimport pytz\nimport os\nimport json\nimport requests\nimport math\nimport shortuuid\nimport logging"},"token_num":{"kind":"number","value":14828,"string":"14,828"},"cropped_code":{"kind":"string","value":"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\n@Author : Charles Lai\n@Contact : qqing_lai@hotmail.com\n@Time : 2020/12/21 上午10:00\n@FileName: ext_fun.py\n@Blog ：https://imaojia.com\n\"\"\"\n\n\n\n\n\n\nlogger = logging.getLogger('drf')\n\n\nclass ThirdPartyUser(object):\n\n def get_user(self):\n"},"all_code":{"kind":"string","value":"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\n@Author : Charles Lai\n@Contact : qqing_lai@hotmail.com\n@Time : 2020/12/21 上午10:00\n@FileName: ext_fun.py\n@Blog ：https://imaojia.com\n\"\"\"\n\n\n\n\n\n\nlogger = logging.getLogger('drf')\n\n\nclass ThirdPartyUser(object):\n\n def get_user(self):"},"next_line":{"kind":"string","value":" user = UserProfile.objects.get_or_create(username='thirdparty')[0]"},"gold_snippet_index":{"kind":"number","value":14,"string":"14"},"created_at":{"kind":"string","value":"2023-12-13 03:09:32+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5975,"cells":{"repo_name":{"kind":"string","value":"MarilynKeller/aitviewer-skel"},"file_path":{"kind":"string","value":"aitviewer/scene/scene.py"},"context":{"kind":"list like","value":[{"identifier":"CONFIG","path":"aitviewer/configuration.py","snippet":"CONFIG = Configuration()"},{"identifier":"CoordinateSystem","path":"aitviewer/renderables/coordinate_system.py","snippet":"class CoordinateSystem(RigidBodies):\n \"\"\"\n Render a coordinate system using shaded cylinders.\n \"\"\"\n\n def __init__(self, length=1.0, icon=\"\\u008a\", **kwargs):\n r = length / 50\n l = length\n super(CoordinateSystem, self).__init__(\n np.array([[[0.0, 0.0, 0.0]]]),\n np.eye(3)[np.newaxis, np.newaxis],\n radius=r,\n length=l,\n icon=icon,\n **kwargs,\n )"},{"identifier":"Lines2D","path":"aitviewer/renderables/lines.py","snippet":"class Lines2D(Node):\n \"\"\"Render 2D lines.\"\"\"\n\n def __init__(\n self,\n lines,\n color=(0.0, 0.0, 1.0, 1.0),\n mode=\"line_strip\",\n **kwargs,\n ):\n \"\"\"\n Initializer.\n :param lines: Set of 3D coordinates as a np array of shape (F, L, 3) or (L, 3).\n :param color: Color of the line (4-tuple) or array of color (N_LINES, 4), one for each line.\n :param mode: 'lines' or 'line_strip'.\n 'lines': a line is drawn from point 0 to 1, from 2 to 3, and so on, number of lines is L / 2.\n 'line_strip': a line is drawn between all adjacent points, 0 to 1, 1 to 2 and so on, number of lines is L - 1.\n \"\"\"\n if len(lines.shape) == 2:\n lines = lines[np.newaxis]\n assert len(lines.shape) == 3\n assert mode == \"lines\" or mode == \"line_strip\"\n if mode == \"lines\":\n assert lines.shape[1] % 2 == 0\n\n self._lines = lines\n self.mode = mode\n self.n_lines = self.lines.shape[1] // 2 if mode == \"lines\" else self.lines.shape[1] - 1\n self.is_renderable = False\n\n # Define a default material in case there is None.\n if isinstance(color, tuple) or len(color.shape) == 1:\n kwargs[\"material\"] = kwargs.get(\"material\", Material(color=color, ambient=0.2))\n self.line_colors = kwargs[\"material\"].color\n else:\n assert (\n color.shape[1] == 4 and color.shape[0] == self.n_lines\n ), \"Color must be a tuple of 4 values or a numpy array of shape (N_LINES, 4)\"\n self.line_colors = color\n\n super(Lines2D, self).__init__(n_frames=self.lines.shape[0], **kwargs)\n\n @property\n def bounds(self):\n bounds = self.get_bounds(self.lines)\n return bounds\n\n @property\n def current_bounds(self):\n bounds = self.get_bounds(self.current_lines)\n return bounds\n\n @property\n def lines(self):\n return self._lines\n\n @lines.setter\n def lines(self, value):\n self._lines = value if len(value.shape) == 3 else value[np.newaxis]\n self.n_frames = self.lines.shape[0]\n self.redraw()\n\n @property\n def current_lines(self):\n idx = self.current_frame_id if self._lines.shape[0] > 1 else 0\n return self._lines[idx]\n\n @current_lines.setter\n def current_lines(self, lines):\n assert len(lines.shape) == 2\n idx = self.current_frame_id if self._lines.shape[0] > 1 else 0\n self._lines[idx] = lines\n self.redraw()\n\n @Node.color.setter\n def color(self, color):\n self.material.color = color\n self.line_colors = color\n self.redraw()\n\n @property\n def line_colors(self):\n if len(self._line_colors.shape) == 1:\n t = np.tile(np.array(self._line_colors), (self.n_lines, 1))\n return t\n else:\n return self._line_colors\n\n @line_colors.setter\n def line_colors(self, color):\n if isinstance(color, tuple):\n color = np.array(color)\n self._line_colors = color\n self.redraw()\n\n def on_frame_update(self):\n super().on_frame_update()\n self.redraw()\n\n def _get_vertices(self):\n vertices = self.current_lines\n if self.mode == \"line_strip\":\n expanded = np.zeros((self.n_lines * 2, 3))\n expanded[::2] = vertices[:-1]\n expanded[1::2] = vertices[1:]\n vertices = expanded\n return vertices\n\n def _get_colors(self):\n cols = self.line_colors\n doubled = np.zeros((self.n_lines * 2, 4))\n doubled[::2] = cols\n doubled[1::2] = cols\n return doubled\n\n def redraw(self, **kwargs):\n \"\"\"Upload the current frame data to the GPU for rendering.\"\"\"\n if not self.is_renderable:\n return\n\n self.vbo_vertices.write(self._get_vertices().astype(\"f4\").tobytes())\n self.vbo_colors.write(self._get_colors().astype(\"f4\").tobytes())\n\n @Node.once\n def make_renderable(self, ctx: moderngl.Context):\n self.prog = get_simple_unlit_program()\n\n self.vbo_vertices = ctx.buffer(self._get_vertices().astype(\"f4\").tobytes(), dynamic=True)\n self.vbo_colors = ctx.buffer(self._get_colors().astype(\"f4\").tobytes(), dynamic=True)\n self.vao = VAO(\"lines\", mode=moderngl.LINES)\n self.vao.buffer(self.vbo_vertices, \"3f\", [\"in_position\"])\n self.vao.buffer(self.vbo_colors, \"4f\", [\"in_color\"])\n\n def render(self, camera, **kwargs):\n self.set_camera_matrices(self.prog, camera, **kwargs)\n self.vao.render(self.prog, vertices=self.n_lines * 2)\n\n @hooked\n def release(self):\n if self.is_renderable:\n self.vao.release()"},{"identifier":"ChessboardPlane","path":"aitviewer/renderables/plane.py","snippet":"class ChessboardPlane(Node):\n \"\"\"A plane that is textured like a chessboard.\"\"\"\n\n def __init__(\n self,\n side_length,\n n_tiles,\n color1=(0.0, 0.0, 0.0, 1.0),\n color2=(1.0, 1.0, 1.0, 1.0),\n plane=\"xz\",\n height=0.0,\n tiling=True,\n icon=\"\\u008b\",\n **kwargs,\n ):\n \"\"\"\n Initializer.\n :param side_length: Length of one side of the plane.\n :param n_tiles: Number of tiles for the chessboard pattern.\n :param color1: First color of the chessboard pattern.\n :param color2: Second color of the chessboard pattern.\n :param plane: In which plane the chessboard lies. Allowed are 'xz', 'xy', 'yz'.\n :param height: The height of the plane.\n :param kwargs: Remaining kwargs.\n \"\"\"\n assert plane in [\"xz\", \"xy\", \"yz\"]\n super(ChessboardPlane, self).__init__(icon=icon, **kwargs)\n self.side_length = side_length\n self.n_tiles = n_tiles\n self.c1 = np.array(color1)\n self.c2 = np.array(color2)\n self.plane = plane\n self.height = height\n self.tiling = tiling\n\n if plane == \"xz\":\n v1 = np.array([1, 0, 0], dtype=np.float32)\n v2 = np.array([0, 0, 1], dtype=np.float32)\n elif plane == \"xy\":\n v1 = np.array([0, 1, 0], dtype=np.float32)\n v2 = np.array([1, 0, 0], dtype=np.float32)\n else:\n # plane == \"yz\"\n v1 = np.array([0, 1, 0], dtype=np.float32)\n v2 = np.array([0, 0, 1], dtype=np.float32)\n\n self.vertices, self.normals, self.uvs = self._get_renderable_data(v1, v2, side_length)\n self.backface_culling = False\n\n def _get_renderable_data(self, v1, v2, size):\n p0 = v1 * (size * 0.5) - v2 * (size * 0.5)\n p1 = v1 * (size * 0.5) + v2 * (size * 0.5)\n p2 = -v1 * (size * 0.5) + v2 * (size * 0.5)\n p3 = -v1 * (size * 0.5) - v2 * (size * 0.5)\n\n normals = np.tile(np.cross(v2, v1), (4, 1))\n\n uvs = np.array([0, 0, 0, 1, 1, 0, 1, 1], dtype=np.float32)\n\n return np.row_stack([p1, p0, p2, p3]), normals, uvs\n\n # noinspection PyAttributeOutsideInit\n @Node.once\n def make_renderable(self, ctx):\n self.prog = get_chessboard_program()\n self.vbo_vertices = ctx.buffer(self.vertices.astype(\"f4\").tobytes())\n self.vbo_normals = ctx.buffer(self.normals.astype(\"f4\").tobytes())\n self.vbo_uvs = ctx.buffer(self.uvs.astype(\"f4\").tobytes())\n\n self.vao = ctx.vertex_array(\n self.prog,\n [\n (self.vbo_vertices, \"3f4 /v\", \"in_position\"),\n (self.vbo_normals, \"3f4 /v\", \"in_normal\"),\n (self.vbo_uvs, \"2f4 /v\", \"in_uv\"),\n ],\n )\n\n def render(self, camera, **kwargs):\n self.prog[\"color_1\"].value = (self.c1[0], self.c1[1], self.c1[2], self.c1[3])\n self.prog[\"color_2\"].value = (self.c2[0], self.c2[1], self.c2[2], self.c2[3])\n self.prog[\"n_tiles\"].value = self.n_tiles\n self.prog[\"tiling_enabled\"].value = self.tiling\n\n self.set_camera_matrices(self.prog, camera, **kwargs)\n self.receive_shadow(self.prog, **kwargs)\n\n set_lights_in_program(\n self.prog,\n kwargs[\"lights\"],\n kwargs[\"shadows_enabled\"],\n kwargs[\"ambient_strength\"],\n )\n set_material_properties(self.prog, self.material)\n\n self.vao.render(moderngl.TRIANGLE_STRIP)\n\n @property\n def bounds(self):\n return self.get_bounds(self.vertices)\n\n @property\n def current_bounds(self):\n return self.bounds\n\n def gui(self, imgui):\n _, self.c1 = imgui.color_edit4(\"Color 1##color{}'\".format(self.unique_name), *self.c1)\n _, self.c2 = imgui.color_edit4(\"Color 2##color{}'\".format(self.unique_name), *self.c2)\n _, self.tiling = imgui.checkbox(\"Toggle Tiling\", self.tiling)\n _, self.n_tiles = imgui.drag_int(\"Number of tiles\", self.n_tiles, 1.0, 1, 200)\n\n def export_usd(self, stage, usd_path: str, directory: str = None, verbose=False):\n usd_path = f\"{usd_path}/{self.name}_{self.uid:03}\".replace(\" \", \"_\")\n\n # Transform.\n xform = UsdGeom.Xform.Define(stage, usd_path)\n a_xform = xform.AddTransformOp()\n a_xform.Set(Gf.Matrix4d(self.get_local_transform().astype(np.float64).T))\n\n # Geometry.\n mesh = UsdGeom.Mesh.Define(stage, usd_path + \"/\" + self.name.replace(\" \", \"_\"))\n mesh.CreatePointsAttr(self.vertices)\n mesh.CreateFaceVertexCountsAttr(np.array([4]))\n mesh.CreateFaceVertexIndicesAttr([0, 1, 3, 2])\n self._export_usd_recursively(stage, usd_path, directory, verbose)"},{"identifier":"ViewerCamera","path":"aitviewer/scene/camera.py","snippet":"class ViewerCamera(CameraInterface):\n \"\"\"\n The camera used by the Viewer. It can be either a Pinhole or Orthographic camera.\n This camera also supports orbiting, panning and generating camera rays.\n \"\"\"\n\n def __init__(self, fov=45, orthographic=None, znear=None, zfar=None):\n super(ViewerCamera, self).__init__()\n self.fov = fov\n self.is_ortho = orthographic is not None\n self.ortho_size = 1.0 if orthographic is None else orthographic\n\n # Default camera settings.\n self._position = np.array([0.0, 2.5, 0.0]) if C.z_up else np.array([0.0, 0.0, 2.5])\n self._target = np.array([0.0, 0.0, 0.0])\n self._up = np.array([0.0, 0.0, 1.0]) if C.z_up else np.array([0.0, 1.0, 0.0])\n\n self.ZOOM_FACTOR = 4\n self.ROT_FACTOR = 0.0025\n self.PAN_FACTOR = 0.01\n\n self.near = znear if znear is not None else C.znear\n self.far = zfar if zfar is not None else C.zfar\n\n # Controls options.\n self.constant_speed = 1.0\n self._control_modes = [\"turntable\", \"trackball\", \"first_person\"]\n self._control_mode = \"turntable\"\n self._trackball_start_view_inverse = None\n self._trackball_start_hit = None\n self._trackball_start_position = None\n self._trackball_start_up = None\n\n # GUI options.\n self.name = \"Camera\"\n self.icon = \"\\u0084\"\n\n # Animation.\n self.animating = False\n self._animation_t = 0.0\n self._animation_time = 0.0\n self._animation_start_position = None\n self._animation_end_position = None\n self._animation_start_target = None\n self._animation_end_target = None\n\n @property\n def control_mode(self):\n return self._control_mode\n\n @control_mode.setter\n def control_mode(self, mode):\n if mode not in self._control_modes:\n raise ValueError(f\"Invalid camera mode: {mode}\")\n if mode == \"first_person\" or mode == \"turntable\":\n self.up = (0, 0, 1) if C.z_up else (0, 1, 0)\n self._control_mode = mode\n\n def copy(self):\n camera = ViewerCamera(self.fov, self.ortho_size, self.near, self.far)\n camera.is_ortho = self.is_ortho\n camera.position = self.position\n camera.target = self.target\n camera.up = self.up\n camera.constant_speed = self.constant_speed\n camera.control_mode = self.control_mode\n return camera\n\n @property\n def position(self):\n return self._position\n\n @position.setter\n def position(self, position):\n self._position = np.array(position, dtype=np.float32).copy()\n\n @property\n def forward(self):\n return normalize(self.target - self.position)\n\n @property\n def up(self):\n return self._up\n\n @up.setter\n def up(self, up):\n self._up = np.array(up, dtype=np.float32).copy()\n\n @property\n def right(self):\n return normalize(np.cross(self.up, self.forward))\n\n @property\n def target(self):\n return self._target\n\n @target.setter\n def target(self, t):\n self._target = np.array(t, np.float32).copy()\n\n def save_cam(self):\n \"\"\"Saves the current camera parameters\"\"\"\n cam_dir = C.export_dir + \"/camera_params/\"\n if not os.path.exists(cam_dir):\n os.makedirs(cam_dir)\n\n cam_dict = {}\n cam_dict[\"position\"] = self.position\n cam_dict[\"target\"] = self.target\n cam_dict[\"up\"] = self.up\n cam_dict[\"ZOOM_FACTOR\"] = self.ZOOM_FACTOR\n cam_dict[\"ROT_FACTOR\"] = self.ROT_FACTOR\n cam_dict[\"PAN_FACTOR\"] = self.PAN_FACTOR\n cam_dict[\"near\"] = self.near\n cam_dict[\"far\"] = self.far\n\n joblib.dump(cam_dict, cam_dir + \"cam_params.pkl\")\n\n def load_cam(self):\n \"\"\"Loads the camera parameters\"\"\"\n cam_dir = C.export_dir + \"/camera_params/\"\n if not os.path.exists(cam_dir):\n print(\"camera config does not exist\")\n else:\n cam_dict = joblib.load(cam_dir + \"cam_params.pkl\")\n self.position = cam_dict[\"position\"]\n self.target = cam_dict[\"target\"]\n self.up = cam_dict[\"up\"]\n self.ZOOM_FACTOR = cam_dict[\"ZOOM_FACTOR\"]\n self.ROT_FACTOR = cam_dict[\"ROT_FACTOR\"]\n self.PAN_FACTOR = cam_dict[\"PAN_FACTOR\"]\n self.near = cam_dict[\"near\"]\n self.far = cam_dict[\"far\"]\n\n def update_matrices(self, width, height):\n # Compute projection matrix.\n if self.is_ortho:\n yscale = self.ortho_size\n xscale = width / height * yscale\n P = orthographic_projection(xscale, yscale, self.near, self.far)\n else:\n P = perspective_projection(np.deg2rad(self.fov), width / height, self.near, self.far)\n\n # Compute view matrix.\n V = look_at(self.position, self.target, self.up)\n\n # Update camera matrices.\n self.projection_matrix = P.astype(\"f4\")\n self.view_matrix = V.astype(\"f4\")\n self.view_projection_matrix = np.matmul(P, V).astype(\"f4\")\n\n def dolly_zoom(self, speed, move_target=False, constant_speed=False):\n \"\"\"\n Zoom by moving the camera along its view direction.\n If move_target is true the camera target will also move rigidly with the camera.\n \"\"\"\n # We update both the orthographic and perspective projection so that the transition is seamless when\n # transitioning between them.\n self.ortho_size -= 0.1 * np.sign(speed)\n self.ortho_size = max(0.0001, self.ortho_size)\n\n # Scale the speed in proportion to the norm (i.e. camera moves slower closer to the target)\n norm = max(np.linalg.norm(self.position - self.target), 2)\n fwd = self.forward\n\n # Adjust speed according to config\n speed *= C.camera_zoom_speed\n\n if move_target or constant_speed:\n if constant_speed:\n norm = self.constant_speed * 20\n self.position += fwd * speed * norm\n self.target += fwd * speed * norm\n else:\n # Clamp movement size to avoid surpassing the target\n movement_length = speed * norm\n max_movement_length = max(np.linalg.norm(self.target - self.position) - 0.01, 0.0)\n\n # Update position\n self.position += fwd * min(movement_length, max_movement_length)\n\n def pan(self, mouse_dx, mouse_dy):\n \"\"\"Move the camera in the image plane.\"\"\"\n sideways = normalize(np.cross(self.forward, self.up))\n up = np.cross(sideways, self.forward)\n\n # scale speed according to distance from target\n speed = max(np.linalg.norm(self.target - self.position) * 0.1, 0.1)\n\n speed_x = mouse_dx * self.PAN_FACTOR * speed\n speed_y = mouse_dy * self.PAN_FACTOR * speed\n\n self.position -= sideways * speed_x\n self.target -= sideways * speed_x\n\n self.position += up * speed_y\n self.target += up * speed_y\n\n def rotate_azimuth(self, angle):\n \"\"\"Rotate around camera's up-axis by given angle (in radians).\"\"\"\n if np.abs(angle) < 1e-8:\n return\n cam_pose = np.linalg.inv(self.view_matrix)\n up_axis = cam_pose[:3, 1]\n rot = rotation_matrix(angle, up_axis, self.target)\n self.position = _transform_vector(rot, self.position)\n\n def _rotation_from_mouse_delta(self, mouse_dx: int, mouse_dy: int):\n z_axis = -self.forward\n dot = np.dot(z_axis, self.up)\n rot = np.eye(4)\n\n # Avoid singularity when z axis of camera is aligned with the up axis of the scene.\n if not (mouse_dy > 0 and dot > 0 and 1 - dot < 0.001) and not (mouse_dy < 0 and dot < 0 and 1 + dot < 0.001):\n # We are either hovering exactly below or above the scene's target but we want to move away or we are\n # not hitting the singularity anyway.\n x_axis = -self.right\n rot_x = rotation_matrix(self.ROT_FACTOR * -mouse_dy, x_axis, self.target)\n rot = rot_x @ rot\n\n y_axis = np.cross(self.forward, self.right)\n x_speed = self.ROT_FACTOR / 10 if 1 - np.abs(dot) < 0.01 else self.ROT_FACTOR\n rot = rotation_matrix(x_speed * -mouse_dx, y_axis, self.target) @ rot\n return rot\n\n def rotate_azimuth_elevation(self, mouse_dx: int, mouse_dy: int):\n \"\"\"Rotate the camera position left-right and up-down orbiting around the target (roll is not allowed).\"\"\"\n rot = self._rotation_from_mouse_delta(mouse_dx, mouse_dy)\n self.position = _transform_vector(rot, self.position)\n\n def rotate_first_person(self, mouse_dx: int, mouse_dy: int):\n \"\"\"Rotate the camera target left-right and up-down (roll is not allowed).\"\"\"\n rot = self._rotation_from_mouse_delta(mouse_dx, mouse_dy)\n self.target = _transform_direction(rot, self.target - self.position) + self.position\n\n def intersect_trackball(self, x: int, y: int, width: int, height: int):\n \"\"\"\n Return intersection of a line passing through the mouse position at pixel coordinates x, y\n and the trackball as a point in world coordinates.\n \"\"\"\n # Transform mouse coordinates from -1 to 1\n nx = 2 * (x + 0.5) / width - 1\n ny = 1 - 2 * (y + 0.5) / height\n\n # Adjust coordinates for the larger side of the viewport rectangle.\n if width > height:\n nx *= width / height\n else:\n ny *= height / width\n\n s = nx * nx + ny * ny\n if s <= 0.5:\n # Sphere intersection\n nz = np.sqrt(1 - s)\n else:\n # Hyperboloid intersection.\n nz = 1 / (2 * np.sqrt(s))\n\n # Return intersection position in world coordinates.\n return self._trackball_start_view_inverse @ np.array((nx, ny, nz))\n\n def rotate_trackball(self, x: int, y: int, width: int, height: int):\n \"\"\"Rotate the camera with trackball controls. Must be called after rotate_start().\"\"\"\n # Compute points on trackball.\n start = self._trackball_start_hit\n current = self.intersect_trackball(x, y, width, height)\n dist = np.linalg.norm(current - start)\n\n # Skip if starting and current point are too close.\n if dist < 1e-6:\n return\n\n # Compute axis of rotation as the vector perpendicular to the plane spanned by the\n # vectors connecting the origin to the two points.\n axis = normalize(np.cross(current, start))\n\n # Compute angle as the angle between the two vectors, if they are too far away we use the distance\n # between them instead, this makes it continue to rotate when dragging the mouse further away.\n angle = max(np.arccos(np.dot(normalize(current), normalize(start))), dist)\n\n # Compute resulting rotation and apply it to the starting position and up vector.\n rot = rotation_matrix(angle, axis, self.target)\n self.position = _transform_vector(rot, self._trackball_start_position)\n self.up = _transform_direction(rot, self._trackball_start_up)\n\n def rotate_start(self, x: int, y: int, width: int, height: int):\n \"\"\"Start rotating the camera. Called on mouse button press.\"\"\"\n if self.control_mode == \"trackball\":\n self._trackball_start_view_inverse = look_at(self.position, self.target, self.up)[:3, :3].T\n self._trackball_start_hit = self.intersect_trackball(x, y, width, height)\n self._trackball_start_position = self.position\n self._trackball_start_up = self.up\n\n def rotate(self, x: int, y: int, mouse_dx: int, mouse_dy: int, width: int, height: int):\n \"\"\"Rotate the camera. Called on mouse movement.\"\"\"\n if self.control_mode == \"turntable\":\n self.rotate_azimuth_elevation(mouse_dx, mouse_dy)\n elif self.control_mode == \"trackball\":\n self.rotate_trackball(x, y, width, height)\n elif self.control_mode == \"first_person\":\n self.rotate_first_person(mouse_dx, mouse_dy)\n\n def get_ray(self, x, y, width, height):\n \"\"\"Construct a ray going through the middle of the given pixel.\"\"\"\n w, h = width, height\n\n # Pixel in (-1, 1) range.\n screen_x = 2 * (x + 0.5) / w - 1\n screen_y = 1 - 2 * (y + 0.5) / h\n\n # Scale to actual image plane size.\n scale = self.ortho_size if self.is_ortho else np.tan(np.deg2rad(self.fov) / 2)\n screen_x *= scale * w / h\n screen_y *= scale\n\n pixel_2d = np.array([screen_x, screen_y, 0 if self.is_ortho else -1])\n cam2world = np.linalg.inv(self.view_matrix)\n pixel_3d = _transform_vector(cam2world, pixel_2d)\n if self.is_ortho:\n ray_origin = pixel_3d\n ray_dir = self.forward\n else:\n eye_origin = np.zeros(3)\n ray_origin = _transform_vector(cam2world, eye_origin)\n ray_dir = pixel_3d - ray_origin\n ray_dir = ray_dir / np.linalg.norm(ray_dir)\n\n return ray_origin, ray_dir\n\n def move_with_animation(self, end_position, end_target, time=0.25):\n self._animation_start_position = self.position.copy()\n self._animation_end_position = np.array(end_position)\n self._animation_start_target = self.target.copy()\n self._animation_end_target = np.array(end_target)\n self._animation_total_time = time\n self._animation_t = 0.0\n self.animating = True\n\n def update_animation(self, dt):\n if not self.animating:\n return\n\n self._animation_t += dt\n if self._animation_t >= self._animation_total_time:\n self.position = self._animation_end_position\n self.target = self._animation_end_target\n self.animating = False\n else:\n t = self._animation_t / self._animation_total_time\n # Smootherstep interpolation (this polynomial has 0 first and second derivative at 0 and 1)\n t = t * t * t * (t * (t * 6 - 15) + 10)\n self.position = self._animation_start_position * (1 - t) + self._animation_end_position * t\n self.target = self._animation_start_target * (1 - t) + self._animation_end_target * t\n\n def gui(self, imgui):\n _, self.is_ortho = imgui.checkbox(\"Orthographic Camera\", self.is_ortho)\n _, self.fov = imgui.slider_float(\"Camera FOV##fov\", self.fov, 0.1, 180.0, \"%.1f\")\n _, self.position = imgui.drag_float3(\"Position\", *self.position)\n _, self.target = imgui.drag_float3(\"Target\", *self.target)\n _, self.up = imgui.drag_float3(\"Up\", *self.up)\n\n imgui.spacing()\n # Note: must be kept in sync with self._control_modes.\n control_modes_labels = [\"Turntable\", \"Trackball\", \"First Person\"]\n u, idx = imgui.combo(\"Control mode\", self._control_modes.index(self.control_mode), control_modes_labels)\n if u and idx >= 0 and idx <= len(self._control_modes):\n self.control_mode = self._control_modes[idx]"},{"identifier":"Light","path":"aitviewer/scene/light.py","snippet":"class Light(Node):\n \"\"\"Simple point light.\"\"\"\n\n def __init__(\n self,\n light_color=(1.0, 1.0, 1.0),\n elevation=-90.0,\n azimuth=0.0,\n strength=1.0,\n shadow_enabled=True,\n **kwargs,\n ):\n kwargs[\"gui_material\"] = False\n super(Light, self).__init__(icon=\"\\u0085\", **kwargs)\n\n self._light_color = light_color\n self.strength = strength\n self._azimuth = azimuth\n self._elevation = elevation\n self.update_rotation()\n\n self.shadow_enabled = shadow_enabled\n self.shadow_map = None\n self.shadow_map_framebuffer = None\n\n self.shadow_map_size = 15.0\n self.shadow_map_near = 5.0\n self.shadow_map_far = 50.0\n\n self._debug_lines = None\n self._show_debug_lines = False\n\n rot = np.eye(3)\n rot[2, 2] = -1\n self.mesh = RigidBodies(\n np.array([[0, 0, 0]], dtype=np.float32),\n np.array([rot], dtype=np.float32),\n radius=0.08,\n length=0.4,\n is_selectable=False,\n )\n self.mesh.spheres.material.diffuse = 0.0\n self.mesh.spheres.material.ambient = 1.0\n self.mesh.spheres.color = (*tuple(light_color), 1.0)\n self.mesh.export_usd_enabled = False\n self.add(self.mesh, show_in_hierarchy=False, enabled=False)\n\n @classmethod\n def facing_origin(cls, **kwargs):\n pos = np.array(kwargs[\"position\"])\n dir = -pos / np.linalg.norm(pos)\n theta, phi = spherical_coordinates_from_direction(dir, degrees=True)\n return cls(elevation=theta, azimuth=phi, **kwargs)\n\n @property\n def elevation(self):\n return self._elevation\n\n @elevation.setter\n def elevation(self, elevation):\n self._elevation = elevation\n self.update_rotation()\n\n @property\n def azimuth(self):\n return self._azimuth\n\n @azimuth.setter\n def azimuth(self, azimuth):\n self._azimuth = azimuth\n self.update_rotation()\n\n @property\n def light_color(self):\n return self._light_color\n\n @light_color.setter\n def light_color(self, light_color):\n self._light_color = light_color\n self.mesh.spheres.color = (*tuple(light_color), 1.0)\n\n def update_rotation(self):\n self.rotation = look_at(np.array([0, 0, 0]), self.direction, np.array([0.0, 1.0, 0.0]))[:3, :3].T\n\n def create_shadowmap(self, ctx):\n if self.shadow_map is None:\n shadow_map_size = 8192, 8192\n\n # Setup shadow mapping\n self.shadow_map = ctx.depth_texture(shadow_map_size)\n self.shadow_map.compare_func = \">\"\n self.shadow_map.repeat_x = False\n self.shadow_map.repeat_y = False\n self.shadow_map_framebuffer = ctx.framebuffer(depth_attachment=self.shadow_map)\n\n def use(self, ctx):\n if not self.shadow_map:\n self.create_shadowmap(ctx)\n\n self.shadow_map_framebuffer.clear()\n self.shadow_map_framebuffer.use()\n\n @staticmethod\n @lru_cache()\n def _compute_light_matrix(position, direction, size, near, far):\n P = orthographic_projection(size, size, near, far)\n p = np.array(position)\n d = np.array(direction)\n V = look_at(p, p + d, np.array([0.0, 1.0, 0.0]))\n return (P @ V).astype(\"f4\")\n\n def mvp(self):\n \"\"\"Return a model-view-projection matrix to project vertices into the view of the light.\"\"\"\n return self._compute_light_matrix(\n tuple(self.position),\n tuple(self.direction),\n self.shadow_map_size,\n self.shadow_map_near,\n self.shadow_map_far,\n )\n\n def _update_debug_lines(self):\n lines = np.array(\n [\n [-1, -1, -1],\n [-1, 1, -1],\n [-1, -1, 1],\n [-1, 1, 1],\n [1, -1, -1],\n [1, 1, -1],\n [1, -1, 1],\n [1, 1, 1],\n [-1, -1, -1],\n [-1, -1, 1],\n [-1, 1, -1],\n [-1, 1, 1],\n [1, -1, -1],\n [1, -1, 1],\n [1, 1, -1],\n [1, 1, 1],\n [-1, -1, -1],\n [1, -1, -1],\n [-1, -1, 1],\n [1, -1, 1],\n [-1, 1, -1],\n [1, 1, -1],\n [-1, 1, 1],\n [1, 1, 1],\n ]\n )\n\n size = self.shadow_map_size\n view_from_ndc = np.linalg.inv(orthographic_projection(size, size, self.shadow_map_near, self.shadow_map_far))\n lines = np.apply_along_axis(lambda x: (view_from_ndc @ np.append(x, 1.0))[:3], 1, lines)\n\n if self._debug_lines is None:\n self._debug_lines = Lines(lines, r_base=0.05, mode=\"lines\", cast_shadow=False, is_selectable=False)\n self._debug_lines.export_usd_enabled = False\n self.add(self._debug_lines, show_in_hierarchy=False)\n else:\n self._debug_lines.lines = lines\n self._debug_lines.redraw()\n\n def render_outline(self, *args, **kwargs):\n if self.mesh.enabled:\n self.mesh.spheres.render_outline(*args, **kwargs)\n\n @Node.position.setter\n def position(self, position):\n super(Light, self.__class__).position.fset(self, position)\n self._update_debug_lines()\n\n @property\n def bounds(self):\n return self.mesh.bounds\n\n @property\n def current_bounds(self):\n return self.mesh.current_bounds\n\n @property\n def direction(self):\n return direction_from_spherical_coordinates(self.elevation, self.azimuth, degrees=True)\n\n def redraw(self, **kwargs):\n if self._debug_lines:\n self._debug_lines.redraw(**kwargs)\n\n def gui_affine(self, imgui): # Position controls\n up, pos = imgui.drag_float3(\n \"Position##pos{}\".format(self.unique_name),\n *self.position,\n 1e-2,\n format=\"%.2f\",\n )\n if up:\n self.position = pos\n\n def gui(self, imgui):\n uc, light_color = imgui.color_edit3(\"Color\", *self.light_color)\n if uc:\n self.light_color = light_color\n _, self.strength = imgui.drag_float(\n \"Strength\",\n self.strength,\n 0.01,\n min_value=0.0,\n max_value=10.0,\n format=\"%.2f\",\n )\n u_el, elevation = imgui.drag_float(\n \"Elevation\",\n self.elevation,\n 0.1,\n min_value=-90,\n max_value=90.0,\n format=\"%.2f\",\n )\n if u_el:\n self.elevation = elevation\n u_az, azimuth = imgui.drag_float(\n \"Azimuth\",\n self.azimuth,\n 0.1,\n min_value=-360.0,\n max_value=360.0,\n format=\"%.2f\",\n )\n if u_az:\n self.azimuth = np.remainder(azimuth, 360.0)\n\n imgui.spacing()\n _, self.shadow_enabled = imgui.checkbox(\"Enable Shadows\", self.shadow_enabled)\n u_size, self.shadow_map_size = imgui.drag_float(\n \"Shadowmap size\",\n self.shadow_map_size,\n 0.1,\n format=\"%.2f\",\n min_value=0.01,\n max_value=100.0,\n )\n u_near, self.shadow_map_near = imgui.drag_float(\n \"Shadowmap Near\",\n self.shadow_map_near,\n 0.1,\n format=\"%.2f\",\n min_value=0.01,\n max_value=100.0,\n )\n u_far, self.shadow_map_far = imgui.drag_float(\n \"Shadowmap Far\",\n self.shadow_map_far,\n 0.1,\n format=\"%.2f\",\n min_value=0.01,\n max_value=100.0,\n )\n _, self.mesh.enabled = imgui.checkbox(\"Show light\", self.mesh.enabled)\n u_show, self._show_debug_lines = imgui.checkbox(\"Show Frustum\", self._show_debug_lines)\n\n if self._show_debug_lines:\n if self._debug_lines:\n self._debug_lines.enabled = True\n\n if u_size or u_near or u_far or u_show:\n self._update_debug_lines()\n else:\n if self._debug_lines:\n self._debug_lines.enabled = False\n\n def export_usd(self, stage, usd_path: str, directory: str = None, verbose=False):\n name = f\"{self.name}_{self.uid:03}\".replace(\" \", \"_\")\n usd_path = f\"{usd_path}/{name}\"\n\n # Transform.\n xform = UsdGeom.Xform.Define(stage, usd_path)\n a_xform = xform.AddTransformOp()\n a_xform.Set(Gf.Matrix4d(self.get_local_transform().astype(np.float64).T))\n\n # Light.\n light = UsdLux.DistantLight.Define(stage, usd_path + \"/\" + name.replace(\" \", \"_\"))\n lightAPI = light.LightAPI()\n lightAPI.GetInput(\"color\").Set(self.light_color[:3])\n lightAPI.GetInput(\"intensity\").Set(self.strength)\n\n self._export_usd_recursively(stage, usd_path, directory, verbose)"},{"identifier":"Node","path":"aitviewer/scene/node.py","snippet":"class Node(object):\n \"\"\"Interface for nodes.\"\"\"\n\n def __init__(\n self,\n name=None,\n icon=None,\n position=None,\n rotation=None,\n scale=1.0,\n color=(0.5, 0.5, 0.5, 1.0),\n material=None,\n is_selectable=True,\n gui_affine=True,\n gui_material=True,\n enabled_frames=None,\n n_frames=1,\n ):\n \"\"\"\n :param name: Name of the node\n :param icon: Custom Node Icon using custom Icon font\n :param position: Starting position in the format (X,Y,Z) or np array of positions with shape (F, 3)\n :param rotation: Starting rotation in rotation matrix representation (3,3) or np array of rotations with shape (F, 3, 3)\n :param scale: Starting scale (scalar) or np array of scale values with shape (F)\n :param color: (R,G,B,A) 0-1 formatted color value.\n :param material: Object material properties. The color specified in the material will override node color\n :param is_selectable: If True the node is selectable when clicked on, otherwise the parent node will be selected.\n :param gui_affine: If True the node will have transform controls (position, rotation, scale) in the GUI.\n :param gui_material: If True the node will have material controls in the GUI.\n :param enabled_frames: Numpy array of boolean values, the object will be enabled only in frames where the value is True,\n the number of ones in the mask must match the number of frames of the object.\n :param n_frames: How many frames this renderable has.\n \"\"\"\n # Transform & Animation\n position = np.zeros(3, dtype=np.float32) if position is None else np.array(position, dtype=np.float32)\n rotation = np.eye(3, dtype=np.float32) if rotation is None else np.array(rotation, dtype=np.float32)\n\n self._positions = position if len(position.shape) != 1 else position[np.newaxis]\n self._rotations = rotation if len(rotation.shape) != 2 else rotation[np.newaxis]\n self._scales = (scale if isinstance(scale, np.ndarray) else np.array([scale])).astype(np.float32)\n\n n_positions = self._positions.shape[0]\n n_rotations = self._rotations.shape[0]\n n_scales = self._scales.shape[0]\n\n if n_frames > 1:\n assert n_positions == 1 or n_frames == n_positions, (\n f\"Number of position frames\" f\" ({n_positions}) must be 1 or match number of Node frames {n_frames}\"\n )\n assert n_rotations == 1 or n_frames == n_rotations, (\n f\"Number of rotations frames\" f\" ({n_rotations}) must be 1 or match number of Node frames {n_frames}\"\n )\n assert n_scales == 1 or n_frames == n_scales, (\n f\"Number of scales frames\" f\" ({n_scales}) must be 1 or match number of Node frames {n_frames}\"\n )\n else:\n n_frames = max(n_positions, n_rotations, n_scales)\n assert (\n (n_positions == 1 or n_positions == n_frames)\n and (n_rotations == 1 or n_rotations == n_frames)\n and (n_scales == 1 or n_scales == n_frames)\n ), (\n f\"Number of position\"\n f\"({n_positions}), rotation ({n_rotations}) and scale ({n_scales})\"\n \"frames must be 1 or match.\"\n )\n\n # Frames\n self._n_frames = n_frames\n self._current_frame_id = 0\n self.model_matrix = self.get_local_transform()\n self._enabled_frames = enabled_frames\n if self._enabled_frames is not None:\n assert np.count_nonzero(self._enabled_frames) == n_frames, (\n f\"Number of non-zero elements in enabled_frames\"\n f\" ({np.count_nonzero(self._enabled_frames)}) must match number of frames in sequence ({n_frames})\"\n )\n # Create an array that maps from the true frame id (counting also disabled frames) to the index of the\n # first existing frame in the sequence.\n self._enabled_frame_id = np.cumsum(self._enabled_frames) - 1\n\n # Stores the true frame id (counting also disabled frames) we use this to allow going\n # through both enabled and disabled frames from the GUI.\n self._internal_frame_id = 0\n\n # Material\n self.material = Material(color=color) if material is None else material\n\n # Renderable Attributes\n self.is_renderable = False\n self.backface_culling = True\n self.backface_fragmap = False\n self.draw_outline = False\n\n # Flags to enable rendering passes\n self.cast_shadow = False\n self.depth_prepass = False\n self.fragmap = False\n self.outline = False\n\n # Programs for render passes. Subclasses are responsible for setting these.\n self.depth_only_program = None # Required for depth_prepass and cast_shadow passes\n self.fragmap_program = None # Required for fragmap pass\n self.outline_program = None # Required for outline pass\n\n # GUI\n self.name = name if name is not None else type(self).__name__\n self.uid = C.next_gui_id()\n self.unique_name = self.name + \"{}\".format(self.uid)\n self.icon = icon if icon is not None else \"\\u0082\"\n self._enabled = True\n self._expanded = False\n self.gui_controls = {\n \"affine\": {\n \"fn\": self.gui_affine,\n \"icon\": \"\\u009b\",\n \"is_visible\": gui_affine,\n },\n \"material\": {\n \"fn\": self.gui_material,\n \"icon\": \"\\u0088\",\n \"is_visible\": gui_material,\n },\n \"animation\": {\n \"fn\": self.gui_animation,\n \"icon\": \"\\u0098\",\n \"is_visible\": (lambda: self._n_frames > 1)(),\n },\n \"io\": {\n \"fn\": self.gui_io,\n \"icon\": \"\\u009a\",\n \"is_visible\": (lambda: self.gui_io.__func__ is not Node.gui_io)(),\n },\n }\n self.gui_modes = {\"view\": {\"title\": \" View\", \"fn\": self.gui_mode_view, \"icon\": \"\\u0099\"}}\n self._selected_mode = \"view\"\n self._show_in_hierarchy = True\n self.is_selectable = is_selectable\n self.export_usd_enabled = True\n self.export_usd_expanded = True\n\n self.nodes: List[Node] = []\n self.parent: Node = None\n\n # Selected Mode\n @property\n def selected_mode(self):\n return self._selected_mode\n\n @selected_mode.setter\n def selected_mode(self, selected_mode):\n self._selected_mode = selected_mode\n\n # Transform\n @property\n def position(self):\n idx = self.current_frame_id if self._positions.shape[0] > 1 else 0\n return self._positions[idx]\n\n @position.setter\n def position(self, position):\n idx = self.current_frame_id if self._positions.shape[0] > 1 else 0\n self._positions[idx] = np.array(position, dtype=np.float32).copy()\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\n\n @property\n def positions(self):\n return self._positions\n\n @positions.setter\n def positions(self, positions):\n self._positions = positions\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\n\n @property\n def rotation(self):\n idx = self.current_frame_id if self._rotations.shape[0] > 1 else 0\n return self._rotations[idx]\n\n @rotation.setter\n def rotation(self, rotation):\n idx = self.current_frame_id if self._rotations.shape[0] > 1 else 0\n self._rotations[idx] = rotation\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\n\n @property\n def rotations(self):\n return self._rotations\n\n @rotations.setter\n def rotations(self, rotations):\n self._rotations = rotations\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\n\n @property\n def scale(self):\n idx = self.current_frame_id if self._scales.shape[0] > 1 else 0\n return self._scales[idx]\n\n @scale.setter\n def scale(self, scale):\n idx = self.current_frame_id if self._scales.shape[0] > 1 else 0\n self._scales[idx] = scale\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\n\n @property\n def scales(self):\n return self._scales\n\n @scales.setter\n def scales(self, scales):\n self._scales = scales\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\n\n @staticmethod\n @lru_cache()\n def _compute_transform(pos, rot, scale):\n rotation = np.eye(4)\n rotation[:3, :3] = np.array(rot)\n\n trans = np.eye(4)\n trans[:3, 3] = np.array(pos)\n\n scale = np.diag([scale, scale, scale, 1])\n\n return (trans @ rotation @ scale).astype(\"f4\")\n\n def get_local_transform(self):\n \"\"\"Construct local transform as a 4x4 matrix from this node's position, orientation and scale.\"\"\"\n return self._compute_transform(tuple(self.position), tuple(map(tuple, self.rotation)), self.scale)\n\n def update_transform(self, parent_transform=None):\n \"\"\"Update the model matrix of this node and all of its descendants.\"\"\"\n if parent_transform is None:\n self.model_matrix = self.get_local_transform()\n else:\n self.model_matrix = parent_transform.astype(\"f4\") @ self.get_local_transform()\n\n for n in self.nodes:\n n.update_transform(self.model_matrix)\n\n @property\n def color(self):\n return self.material.color\n\n @color.setter\n def color(self, color):\n self.material.color = color\n\n @property\n def bounds(self):\n \"\"\"The bounds in the format ((x_min, x_max), (y_min, y_max), (z_min, z_max))\"\"\"\n return np.array([[0, 0], [0, 0], [0, 0]])\n\n @property\n def current_bounds(self):\n return np.array([[0, 0], [0, 0], [0, 0]])\n\n @property\n def current_center(self):\n return self.current_bounds.mean(-1)\n\n @property\n def center(self):\n return self.bounds.mean(-1)\n\n def get_local_bounds(self, points):\n if len(points.shape) == 2 and points.shape[-1] == 3:\n points = points[np.newaxis]\n assert len(points.shape) == 3\n\n # Compute min and max coordinates of the bounding box ignoring NaNs.\n val = np.array(\n [\n [np.nanmin(points[:, :, 0]), np.nanmax(points[:, :, 0])],\n [np.nanmin(points[:, :, 1]), np.nanmax(points[:, :, 1])],\n [np.nanmin(points[:, :, 2]), np.nanmax(points[:, :, 2])],\n ]\n )\n\n # If any of the elements is NaN return an empty bounding box.\n if np.isnan(val).any():\n return np.array([[0, 0], [0, 0], [0, 0]])\n else:\n return val\n\n def get_bounds(self, points):\n val = self.get_local_bounds(points)\n\n # Transform bounding box with the model matrix.\n val = (self.model_matrix @ np.vstack((val, np.array([1.0, 1.0]))))[:3]\n\n # If any of the elements is NaN return an empty bounding box.\n if np.isnan(val).any():\n return np.array([[0, 0], [0, 0], [0, 0]])\n else:\n return val\n\n @property\n def n_frames(self):\n return self._n_frames\n\n @n_frames.setter\n def n_frames(self, n_frames):\n self._n_frames = n_frames\n\n def __len__(self):\n return self.n_frames\n\n @property\n def current_frame_id(self):\n return self._current_frame_id\n\n @current_frame_id.setter\n def current_frame_id(self, frame_id):\n # Check if the frame changed.\n last_frame_id = self._current_frame_id if self._enabled_frames is None else self._internal_frame_id\n if self.n_frames == 1 or frame_id == last_frame_id:\n return\n\n self.on_before_frame_update()\n if self._enabled_frames is None:\n if frame_id < 0:\n self._current_frame_id = 0\n elif frame_id >= len(self):\n self._current_frame_id = len(self) - 1\n else:\n self._current_frame_id = frame_id\n else:\n # If an enabled_frames is present use it to get the current frame.\n if frame_id < 0:\n self._internal_frame_id = 0\n elif frame_id >= self._enabled_frames.shape[0]:\n self._internal_frame_id = self._enabled_frames.shape[0] - 1\n else:\n self._internal_frame_id = frame_id\n self._current_frame_id = self._enabled_frame_id[self._internal_frame_id]\n # Update enabled using the mask.\n self.enabled = self._enabled_frames[self._internal_frame_id]\n\n # Update frame id of all children nodes.\n for n in self.nodes:\n n.current_frame_id = self._current_frame_id\n\n self.on_frame_update()\n if self.parent and (self._positions.shape[0] > 1 or self._rotations.shape[0] > 1 or self._scales.shape[0] > 1):\n self.update_transform(self.parent.model_matrix)\n\n def next_frame(self):\n self.current_frame_id = self.current_frame_id + 1 if self.current_frame_id < len(self) - 1 else 0\n\n def previous_frame(self):\n self.current_frame_id = self.current_frame_id - 1 if self.current_frame_id > 0 else len(self) - 1\n\n def on_before_frame_update(self):\n \"\"\"Called when the current frame is about to change, 'self.current_frame_id' still has the id of the\n previous frame.\"\"\"\n pass\n\n def on_frame_update(self):\n \"\"\"Called when the current frame is changed.\"\"\"\n pass\n\n def add(self, *nodes, **kwargs):\n self._add_nodes(*nodes, **kwargs)\n\n def _add_node(self, n: \"Node\", show_in_hierarchy=True, expanded=False, enabled=True):\n \"\"\"\n Add a single node\n :param show_in_hierarchy: Whether to show the node in the scene hierarchy.\n :param expanded: Whether the node is initially expanded in the GUI.\n \"\"\"\n if n is None:\n return\n n._show_in_hierarchy = show_in_hierarchy\n n._expanded = expanded\n n._enabled = enabled if n._enabled_frames is None else n._enabled_frames[n.current_frame_id]\n self.nodes.append(n)\n n.parent = self\n n.update_transform(self.model_matrix)\n\n def _add_nodes(self, *nodes, **kwargs):\n \"\"\"Add multiple nodes\"\"\"\n for n in nodes:\n self._add_node(n, **kwargs)\n\n def remove(self, *nodes):\n for n in nodes:\n n.release()\n try:\n self.nodes.remove(n)\n except:\n pass\n\n @property\n def show_in_hierarchy(self):\n return self._show_in_hierarchy\n\n @property\n def enabled(self):\n return self._enabled\n\n @enabled.setter\n def enabled(self, enabled):\n self._enabled = enabled\n\n @property\n def expanded(self):\n return self._expanded\n\n @expanded.setter\n def expanded(self, expanded):\n self._expanded = expanded\n\n def is_transparent(self):\n \"\"\"\n Returns true if the object is transparent and should thus be sorted when rendering.\n Subclassess that use a different color should implement this method to be rendered correctly when transparent.\n \"\"\"\n return self.material.color[3] < 1.0\n\n def gui(self, imgui):\n \"\"\"\n Render GUI for custom node properties and controls. Implementation optional.\n Elements rendered here will show up in the scene hierarchy\n :param imgui: imgui context.\n See https://pyimgui.readthedocs.io/en/latest/reference/imgui.core.html for available elements to render\n \"\"\"\n pass\n\n def gui_modes(self, imgui):\n \"\"\"Render GUI with toolbar (tools) for this particular node\"\"\"\n\n def gui_animation(self, imgui):\n \"\"\"Render GUI for animation related settings\"\"\"\n\n if self._enabled_frames is None:\n if self.n_frames > 1:\n u, fid = imgui.slider_int(\n \"Frame##r_{}\".format(self.unique_name),\n self.current_frame_id,\n min_value=0,\n max_value=self.n_frames - 1,\n )\n if u:\n self.current_frame_id = fid\n else:\n u, fid = imgui.slider_int(\n \"Frame##r_{}\".format(self.unique_name),\n self._internal_frame_id,\n min_value=0,\n max_value=self._enabled_frames.shape[0] - 1,\n )\n if u:\n self.current_frame_id = fid\n\n def gui_affine(self, imgui):\n \"\"\"Render GUI for affine transformations\"\"\"\n # Position controls\n up, pos = imgui.drag_float3(\n \"Position##pos{}\".format(self.unique_name),\n *self.position,\n 1e-2,\n format=\"%.2f\",\n )\n if up:\n self.position = pos\n\n # Rotation controls\n euler_angles = rot2euler_numpy(self.rotation[np.newaxis], degrees=True)[0]\n ur, euler_angles = imgui.drag_float3(\n \"Rotation##pos{}\".format(self.unique_name),\n *euler_angles,\n 1e-2,\n format=\"%.2f\",\n )\n if ur:\n self.rotation = euler2rot_numpy(np.array(euler_angles)[np.newaxis], degrees=True)[0]\n\n # Scale controls\n us, scale = imgui.drag_float(\n \"Scale##scale{}\".format(self.unique_name),\n self.scale,\n 1e-2,\n min_value=0.001,\n max_value=100.0,\n format=\"%.3f\",\n )\n if us:\n self.scale = scale\n\n def gui_material(self, imgui):\n \"\"\"Render GUI with material properties\"\"\"\n\n # Color Control\n uc, color = imgui.color_edit4(\"Color##color{}'\".format(self.unique_name), *self.material.color)\n if uc:\n self.color = color\n\n # Diffuse\n ud, diffuse = imgui.slider_float(\n \"Diffuse##diffuse{}\".format(self.unique_name),\n self.material.diffuse,\n 0.0,\n 1.0,\n \"%.2f\",\n )\n if ud:\n self.material.diffuse = diffuse\n\n # Ambient\n ua, ambient = imgui.slider_float(\n \"Ambient##ambient{}\".format(self.unique_name),\n self.material.ambient,\n 0.0,\n 1.0,\n \"%.2f\",\n )\n if ua:\n self.material.ambient = ambient\n\n def gui_io(self, imgui):\n \"\"\"Render GUI for import/export\"\"\"\n pass\n\n def gui_mode_view(self, imgui):\n \"\"\"Render custom GUI for view mode\"\"\"\n pass\n\n def gui_context_menu(self, imgui, x: int, y: int):\n _, self.enabled = imgui.checkbox(\"Enabled\", self.enabled)\n if any([n._show_in_hierarchy for n in self.nodes]):\n imgui.spacing()\n imgui.separator()\n imgui.spacing()\n for n in self.nodes:\n if not n._show_in_hierarchy:\n continue\n if imgui.begin_menu(f\"{n.name}##{n.uid}\"):\n n.gui_context_menu(imgui, x, y)\n imgui.end_menu()\n\n # Renderable\n @staticmethod\n def once(func):\n def _decorator(self, *args, **kwargs):\n if self.is_renderable:\n return\n else:\n func(self, *args, **kwargs)\n self.is_renderable = True\n\n return _decorator\n\n def make_renderable(self, ctx):\n \"\"\"\n Prepares this object for rendering. This function must be called before `render` is used.\n :param ctx: The moderngl context.\n \"\"\"\n pass\n\n def render(self, camera, position=None, rotation=None, **kwargs):\n \"\"\"Render the current frame in this sequence.\"\"\"\n pass\n\n def render_positions(self, prog):\n \"\"\"\n Render with a VAO with only positions bound, used for shadow mapping, fragmap and depth prepass.\n \"\"\"\n pass\n\n def redraw(self, **kwargs):\n \"\"\"Perform update and redraw operations. Push to the GPU when finished. Recursively redraw child nodes\"\"\"\n for n in self.nodes:\n n.redraw(**kwargs)\n\n def set_camera_matrices(self, prog, camera, **kwargs):\n \"\"\"Set the model view projection matrix in the given program.\"\"\"\n # Transpose because np is row-major but OpenGL expects column-major.\n prog[\"model_matrix\"].write(self.model_matrix.T.astype(\"f4\").tobytes())\n prog[\"view_projection_matrix\"].write(camera.get_view_projection_matrix().T.astype(\"f4\").tobytes())\n\n def receive_shadow(self, program, **kwargs):\n \"\"\"\n Call this function if the renderable is to receive shadows.\n :param program: The shader program that can shade with shadows.\n :param kwargs: The render kwargs.\n \"\"\"\n if kwargs.get(\"shadows_enabled\", False):\n lights = kwargs[\"lights\"]\n\n for i, light in enumerate(lights):\n if light.shadow_enabled and light.shadow_map:\n light_matrix = light.mvp() @ self.model_matrix\n program[f\"dirLights[{i}].matrix\"].write(light_matrix.T.tobytes())\n\n # Bind shadowmap to slot i + 1, we reserve slot 0 for the mesh texture\n # and use slots 1 to (#lights + 1) for shadow maps\n light.shadow_map.use(location=i + 1)\n\n # Set sampler uniforms\n uniform = program[f\"shadow_maps\"]\n uniform.value = 1 if uniform.array_length == 1 else [*range(1, len(lights) + 1)]\n\n def render_shadowmap(self, light_matrix):\n if not self.cast_shadow or self.depth_only_program is None or self.color[3] == 0.0:\n return\n\n prog = self.depth_only_program\n prog[\"model_matrix\"].write(self.model_matrix.T.tobytes())\n prog[\"view_projection_matrix\"].write(light_matrix.T.tobytes())\n\n self.render_positions(prog)\n\n def render_fragmap(self, ctx, camera, uid=None):\n if not self.fragmap or self.fragmap_program is None:\n return\n\n # Transpose because np is row-major but OpenGL expects column-major.\n prog = self.fragmap_program\n self.set_camera_matrices(prog, camera)\n\n # Render with the specified object uid, if None use the node uid instead.\n prog[\"obj_id\"] = uid or self.uid\n\n if self.backface_culling or self.backface_fragmap:\n ctx.enable(moderngl.CULL_FACE)\n else:\n ctx.disable(moderngl.CULL_FACE)\n\n # If backface_fragmap is enabled for this node only render backfaces\n if self.backface_fragmap:\n ctx.cull_face = \"front\"\n\n self.render_positions(prog)\n\n # Restore cull face to back\n if self.backface_fragmap:\n ctx.cull_face = \"back\"\n\n def render_depth_prepass(self, camera, **kwargs):\n if not self.depth_prepass or self.depth_only_program is None:\n return\n\n prog = self.depth_only_program\n self.set_camera_matrices(prog, camera)\n self.render_positions(prog)\n\n def render_outline(self, ctx, camera):\n if self.outline and self.outline_program is not None:\n prog = self.outline_program\n self.set_camera_matrices(prog, camera)\n\n if self.backface_culling:\n ctx.enable(moderngl.CULL_FACE)\n else:\n ctx.disable(moderngl.CULL_FACE)\n self.render_positions(prog)\n\n # Render children node recursively.\n for n in self.nodes:\n n.render_outline(ctx, camera)\n\n def release(self):\n \"\"\"\n Release all OpenGL resources used by this node and any of its children. Subclasses that instantiate OpenGL\n objects should implement this method with '@hooked' to avoid leaking resources.\n \"\"\"\n for n in self.nodes:\n n.release()\n\n def on_selection(self, node, instance_id, tri_id):\n \"\"\"\n Called when the node is selected\n\n :param node: the node which was clicked (can be None if the selection wasn't a mouse event)\n :param instance_id: the id of the instance that was clicked, 0 if the object is not instanced\n (can be None if the selection wasn't a mouse event)\n :param tri_id: the id of the triangle that was clicked from the 'node' mesh\n (can be None if the selection wasn't a mouse event)\n \"\"\"\n pass\n\n def key_event(self, key, wnd_keys):\n \"\"\"\n Handle shortcut key presses (if you are the selected object)\n \"\"\"\n pass\n\n def update_frames(self, *args, **kwargs):\n pass\n\n def add_frames(self, *args, **kwargs):\n pass\n\n def remove_frames(self, *args, **kwargs):\n pass\n\n def _export_usd_recursively(self, stage, usd_path, directory, verbose):\n if verbose:\n print(usd_path)\n for n in self.nodes:\n if n.export_usd_enabled:\n n.export_usd(stage, usd_path, directory, verbose)\n\n def export_usd(self, stage, usd_path: str, directory: str = None, verbose=False):\n \"\"\"\n Export the node into an USD file. Nodes that implement this method should use\n recursively call this for every children that should also be exported.\n\n :param stage: an object of type Usd.Stage into which to export the node\n :param usd_path: the path of the parent object in the USD file scene hierarchy.\n \"\"\"\n from pxr import Gf, UsdGeom\n\n usd_path = f\"{usd_path}/{self.name.replace(' ', '_')}_{self.uid:03}\"\n\n # Transform.\n xform = UsdGeom.Xform.Define(stage, usd_path)\n a_xform = xform.AddTransformOp()\n a_xform.Set(Gf.Matrix4d(self.get_local_transform().astype(np.float64).T))\n\n self._export_usd_recursively(stage, usd_path, directory, verbose)"},{"identifier":"compute_union_of_bounds","path":"aitviewer/utils/utils.py","snippet":"def compute_union_of_bounds(nodes):\r\n if len(nodes) == 0:\r\n return np.zeros((3, 2))\r\n\r\n bounds = np.array([[np.inf, np.NINF], [np.inf, np.NINF], [np.inf, np.NINF]])\r\n for n in nodes:\r\n child = n.bounds\r\n bounds[:, 0] = np.minimum(bounds[:, 0], child[:, 0])\r\n bounds[:, 1] = np.maximum(bounds[:, 1], child[:, 1])\r\n return bounds\r"},{"identifier":"compute_union_of_current_bounds","path":"aitviewer/utils/utils.py","snippet":"def compute_union_of_current_bounds(nodes):\r\n if len(nodes) == 0:\r\n return np.zeros((3, 2))\r\n\r\n bounds = np.array([[np.inf, np.NINF], [np.inf, np.NINF], [np.inf, np.NINF]])\r\n for n in nodes:\r\n child = n.current_bounds\r\n bounds[:, 0] = np.minimum(bounds[:, 0], child[:, 0])\r\n bounds[:, 1] = np.maximum(bounds[:, 1], child[:, 1])\r\n return bounds\r"}],"string":"[\n {\n \"identifier\": \"CONFIG\",\n \"path\": \"aitviewer/configuration.py\",\n \"snippet\": \"CONFIG = Configuration()\"\n },\n {\n \"identifier\": \"CoordinateSystem\",\n \"path\": \"aitviewer/renderables/coordinate_system.py\",\n \"snippet\": \"class CoordinateSystem(RigidBodies):\\n \\\"\\\"\\\"\\n Render a coordinate system using shaded cylinders.\\n \\\"\\\"\\\"\\n\\n def __init__(self, length=1.0, icon=\\\"\\\\u008a\\\", **kwargs):\\n r = length / 50\\n l = length\\n super(CoordinateSystem, self).__init__(\\n np.array([[[0.0, 0.0, 0.0]]]),\\n np.eye(3)[np.newaxis, np.newaxis],\\n radius=r,\\n length=l,\\n icon=icon,\\n **kwargs,\\n )\"\n },\n {\n \"identifier\": \"Lines2D\",\n \"path\": \"aitviewer/renderables/lines.py\",\n \"snippet\": \"class Lines2D(Node):\\n \\\"\\\"\\\"Render 2D lines.\\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n lines,\\n color=(0.0, 0.0, 1.0, 1.0),\\n mode=\\\"line_strip\\\",\\n **kwargs,\\n ):\\n \\\"\\\"\\\"\\n Initializer.\\n :param lines: Set of 3D coordinates as a np array of shape (F, L, 3) or (L, 3).\\n :param color: Color of the line (4-tuple) or array of color (N_LINES, 4), one for each line.\\n :param mode: 'lines' or 'line_strip'.\\n 'lines': a line is drawn from point 0 to 1, from 2 to 3, and so on, number of lines is L / 2.\\n 'line_strip': a line is drawn between all adjacent points, 0 to 1, 1 to 2 and so on, number of lines is L - 1.\\n \\\"\\\"\\\"\\n if len(lines.shape) == 2:\\n lines = lines[np.newaxis]\\n assert len(lines.shape) == 3\\n assert mode == \\\"lines\\\" or mode == \\\"line_strip\\\"\\n if mode == \\\"lines\\\":\\n assert lines.shape[1] % 2 == 0\\n\\n self._lines = lines\\n self.mode = mode\\n self.n_lines = self.lines.shape[1] // 2 if mode == \\\"lines\\\" else self.lines.shape[1] - 1\\n self.is_renderable = False\\n\\n # Define a default material in case there is None.\\n if isinstance(color, tuple) or len(color.shape) == 1:\\n kwargs[\\\"material\\\"] = kwargs.get(\\\"material\\\", Material(color=color, ambient=0.2))\\n self.line_colors = kwargs[\\\"material\\\"].color\\n else:\\n assert (\\n color.shape[1] == 4 and color.shape[0] == self.n_lines\\n ), \\\"Color must be a tuple of 4 values or a numpy array of shape (N_LINES, 4)\\\"\\n self.line_colors = color\\n\\n super(Lines2D, self).__init__(n_frames=self.lines.shape[0], **kwargs)\\n\\n @property\\n def bounds(self):\\n bounds = self.get_bounds(self.lines)\\n return bounds\\n\\n @property\\n def current_bounds(self):\\n bounds = self.get_bounds(self.current_lines)\\n return bounds\\n\\n @property\\n def lines(self):\\n return self._lines\\n\\n @lines.setter\\n def lines(self, value):\\n self._lines = value if len(value.shape) == 3 else value[np.newaxis]\\n self.n_frames = self.lines.shape[0]\\n self.redraw()\\n\\n @property\\n def current_lines(self):\\n idx = self.current_frame_id if self._lines.shape[0] > 1 else 0\\n return self._lines[idx]\\n\\n @current_lines.setter\\n def current_lines(self, lines):\\n assert len(lines.shape) == 2\\n idx = self.current_frame_id if self._lines.shape[0] > 1 else 0\\n self._lines[idx] = lines\\n self.redraw()\\n\\n @Node.color.setter\\n def color(self, color):\\n self.material.color = color\\n self.line_colors = color\\n self.redraw()\\n\\n @property\\n def line_colors(self):\\n if len(self._line_colors.shape) == 1:\\n t = np.tile(np.array(self._line_colors), (self.n_lines, 1))\\n return t\\n else:\\n return self._line_colors\\n\\n @line_colors.setter\\n def line_colors(self, color):\\n if isinstance(color, tuple):\\n color = np.array(color)\\n self._line_colors = color\\n self.redraw()\\n\\n def on_frame_update(self):\\n super().on_frame_update()\\n self.redraw()\\n\\n def _get_vertices(self):\\n vertices = self.current_lines\\n if self.mode == \\\"line_strip\\\":\\n expanded = np.zeros((self.n_lines * 2, 3))\\n expanded[::2] = vertices[:-1]\\n expanded[1::2] = vertices[1:]\\n vertices = expanded\\n return vertices\\n\\n def _get_colors(self):\\n cols = self.line_colors\\n doubled = np.zeros((self.n_lines * 2, 4))\\n doubled[::2] = cols\\n doubled[1::2] = cols\\n return doubled\\n\\n def redraw(self, **kwargs):\\n \\\"\\\"\\\"Upload the current frame data to the GPU for rendering.\\\"\\\"\\\"\\n if not self.is_renderable:\\n return\\n\\n self.vbo_vertices.write(self._get_vertices().astype(\\\"f4\\\").tobytes())\\n self.vbo_colors.write(self._get_colors().astype(\\\"f4\\\").tobytes())\\n\\n @Node.once\\n def make_renderable(self, ctx: moderngl.Context):\\n self.prog = get_simple_unlit_program()\\n\\n self.vbo_vertices = ctx.buffer(self._get_vertices().astype(\\\"f4\\\").tobytes(), dynamic=True)\\n self.vbo_colors = ctx.buffer(self._get_colors().astype(\\\"f4\\\").tobytes(), dynamic=True)\\n self.vao = VAO(\\\"lines\\\", mode=moderngl.LINES)\\n self.vao.buffer(self.vbo_vertices, \\\"3f\\\", [\\\"in_position\\\"])\\n self.vao.buffer(self.vbo_colors, \\\"4f\\\", [\\\"in_color\\\"])\\n\\n def render(self, camera, **kwargs):\\n self.set_camera_matrices(self.prog, camera, **kwargs)\\n self.vao.render(self.prog, vertices=self.n_lines * 2)\\n\\n @hooked\\n def release(self):\\n if self.is_renderable:\\n self.vao.release()\"\n },\n {\n \"identifier\": \"ChessboardPlane\",\n \"path\": \"aitviewer/renderables/plane.py\",\n \"snippet\": \"class ChessboardPlane(Node):\\n \\\"\\\"\\\"A plane that is textured like a chessboard.\\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n side_length,\\n n_tiles,\\n color1=(0.0, 0.0, 0.0, 1.0),\\n color2=(1.0, 1.0, 1.0, 1.0),\\n plane=\\\"xz\\\",\\n height=0.0,\\n tiling=True,\\n icon=\\\"\\\\u008b\\\",\\n **kwargs,\\n ):\\n \\\"\\\"\\\"\\n Initializer.\\n :param side_length: Length of one side of the plane.\\n :param n_tiles: Number of tiles for the chessboard pattern.\\n :param color1: First color of the chessboard pattern.\\n :param color2: Second color of the chessboard pattern.\\n :param plane: In which plane the chessboard lies. Allowed are 'xz', 'xy', 'yz'.\\n :param height: The height of the plane.\\n :param kwargs: Remaining kwargs.\\n \\\"\\\"\\\"\\n assert plane in [\\\"xz\\\", \\\"xy\\\", \\\"yz\\\"]\\n super(ChessboardPlane, self).__init__(icon=icon, **kwargs)\\n self.side_length = side_length\\n self.n_tiles = n_tiles\\n self.c1 = np.array(color1)\\n self.c2 = np.array(color2)\\n self.plane = plane\\n self.height = height\\n self.tiling = tiling\\n\\n if plane == \\\"xz\\\":\\n v1 = np.array([1, 0, 0], dtype=np.float32)\\n v2 = np.array([0, 0, 1], dtype=np.float32)\\n elif plane == \\\"xy\\\":\\n v1 = np.array([0, 1, 0], dtype=np.float32)\\n v2 = np.array([1, 0, 0], dtype=np.float32)\\n else:\\n # plane == \\\"yz\\\"\\n v1 = np.array([0, 1, 0], dtype=np.float32)\\n v2 = np.array([0, 0, 1], dtype=np.float32)\\n\\n self.vertices, self.normals, self.uvs = self._get_renderable_data(v1, v2, side_length)\\n self.backface_culling = False\\n\\n def _get_renderable_data(self, v1, v2, size):\\n p0 = v1 * (size * 0.5) - v2 * (size * 0.5)\\n p1 = v1 * (size * 0.5) + v2 * (size * 0.5)\\n p2 = -v1 * (size * 0.5) + v2 * (size * 0.5)\\n p3 = -v1 * (size * 0.5) - v2 * (size * 0.5)\\n\\n normals = np.tile(np.cross(v2, v1), (4, 1))\\n\\n uvs = np.array([0, 0, 0, 1, 1, 0, 1, 1], dtype=np.float32)\\n\\n return np.row_stack([p1, p0, p2, p3]), normals, uvs\\n\\n # noinspection PyAttributeOutsideInit\\n @Node.once\\n def make_renderable(self, ctx):\\n self.prog = get_chessboard_program()\\n self.vbo_vertices = ctx.buffer(self.vertices.astype(\\\"f4\\\").tobytes())\\n self.vbo_normals = ctx.buffer(self.normals.astype(\\\"f4\\\").tobytes())\\n self.vbo_uvs = ctx.buffer(self.uvs.astype(\\\"f4\\\").tobytes())\\n\\n self.vao = ctx.vertex_array(\\n self.prog,\\n [\\n (self.vbo_vertices, \\\"3f4 /v\\\", \\\"in_position\\\"),\\n (self.vbo_normals, \\\"3f4 /v\\\", \\\"in_normal\\\"),\\n (self.vbo_uvs, \\\"2f4 /v\\\", \\\"in_uv\\\"),\\n ],\\n )\\n\\n def render(self, camera, **kwargs):\\n self.prog[\\\"color_1\\\"].value = (self.c1[0], self.c1[1], self.c1[2], self.c1[3])\\n self.prog[\\\"color_2\\\"].value = (self.c2[0], self.c2[1], self.c2[2], self.c2[3])\\n self.prog[\\\"n_tiles\\\"].value = self.n_tiles\\n self.prog[\\\"tiling_enabled\\\"].value = self.tiling\\n\\n self.set_camera_matrices(self.prog, camera, **kwargs)\\n self.receive_shadow(self.prog, **kwargs)\\n\\n set_lights_in_program(\\n self.prog,\\n kwargs[\\\"lights\\\"],\\n kwargs[\\\"shadows_enabled\\\"],\\n kwargs[\\\"ambient_strength\\\"],\\n )\\n set_material_properties(self.prog, self.material)\\n\\n self.vao.render(moderngl.TRIANGLE_STRIP)\\n\\n @property\\n def bounds(self):\\n return self.get_bounds(self.vertices)\\n\\n @property\\n def current_bounds(self):\\n return self.bounds\\n\\n def gui(self, imgui):\\n _, self.c1 = imgui.color_edit4(\\\"Color 1##color{}'\\\".format(self.unique_name), *self.c1)\\n _, self.c2 = imgui.color_edit4(\\\"Color 2##color{}'\\\".format(self.unique_name), *self.c2)\\n _, self.tiling = imgui.checkbox(\\\"Toggle Tiling\\\", self.tiling)\\n _, self.n_tiles = imgui.drag_int(\\\"Number of tiles\\\", self.n_tiles, 1.0, 1, 200)\\n\\n def export_usd(self, stage, usd_path: str, directory: str = None, verbose=False):\\n usd_path = f\\\"{usd_path}/{self.name}_{self.uid:03}\\\".replace(\\\" \\\", \\\"_\\\")\\n\\n # Transform.\\n xform = UsdGeom.Xform.Define(stage, usd_path)\\n a_xform = xform.AddTransformOp()\\n a_xform.Set(Gf.Matrix4d(self.get_local_transform().astype(np.float64).T))\\n\\n # Geometry.\\n mesh = UsdGeom.Mesh.Define(stage, usd_path + \\\"/\\\" + self.name.replace(\\\" \\\", \\\"_\\\"))\\n mesh.CreatePointsAttr(self.vertices)\\n mesh.CreateFaceVertexCountsAttr(np.array([4]))\\n mesh.CreateFaceVertexIndicesAttr([0, 1, 3, 2])\\n self._export_usd_recursively(stage, usd_path, directory, verbose)\"\n },\n {\n \"identifier\": \"ViewerCamera\",\n \"path\": \"aitviewer/scene/camera.py\",\n \"snippet\": \"class ViewerCamera(CameraInterface):\\n \\\"\\\"\\\"\\n The camera used by the Viewer. It can be either a Pinhole or Orthographic camera.\\n This camera also supports orbiting, panning and generating camera rays.\\n \\\"\\\"\\\"\\n\\n def __init__(self, fov=45, orthographic=None, znear=None, zfar=None):\\n super(ViewerCamera, self).__init__()\\n self.fov = fov\\n self.is_ortho = orthographic is not None\\n self.ortho_size = 1.0 if orthographic is None else orthographic\\n\\n # Default camera settings.\\n self._position = np.array([0.0, 2.5, 0.0]) if C.z_up else np.array([0.0, 0.0, 2.5])\\n self._target = np.array([0.0, 0.0, 0.0])\\n self._up = np.array([0.0, 0.0, 1.0]) if C.z_up else np.array([0.0, 1.0, 0.0])\\n\\n self.ZOOM_FACTOR = 4\\n self.ROT_FACTOR = 0.0025\\n self.PAN_FACTOR = 0.01\\n\\n self.near = znear if znear is not None else C.znear\\n self.far = zfar if zfar is not None else C.zfar\\n\\n # Controls options.\\n self.constant_speed = 1.0\\n self._control_modes = [\\\"turntable\\\", \\\"trackball\\\", \\\"first_person\\\"]\\n self._control_mode = \\\"turntable\\\"\\n self._trackball_start_view_inverse = None\\n self._trackball_start_hit = None\\n self._trackball_start_position = None\\n self._trackball_start_up = None\\n\\n # GUI options.\\n self.name = \\\"Camera\\\"\\n self.icon = \\\"\\\\u0084\\\"\\n\\n # Animation.\\n self.animating = False\\n self._animation_t = 0.0\\n self._animation_time = 0.0\\n self._animation_start_position = None\\n self._animation_end_position = None\\n self._animation_start_target = None\\n self._animation_end_target = None\\n\\n @property\\n def control_mode(self):\\n return self._control_mode\\n\\n @control_mode.setter\\n def control_mode(self, mode):\\n if mode not in self._control_modes:\\n raise ValueError(f\\\"Invalid camera mode: {mode}\\\")\\n if mode == \\\"first_person\\\" or mode == \\\"turntable\\\":\\n self.up = (0, 0, 1) if C.z_up else (0, 1, 0)\\n self._control_mode = mode\\n\\n def copy(self):\\n camera = ViewerCamera(self.fov, self.ortho_size, self.near, self.far)\\n camera.is_ortho = self.is_ortho\\n camera.position = self.position\\n camera.target = self.target\\n camera.up = self.up\\n camera.constant_speed = self.constant_speed\\n camera.control_mode = self.control_mode\\n return camera\\n\\n @property\\n def position(self):\\n return self._position\\n\\n @position.setter\\n def position(self, position):\\n self._position = np.array(position, dtype=np.float32).copy()\\n\\n @property\\n def forward(self):\\n return normalize(self.target - self.position)\\n\\n @property\\n def up(self):\\n return self._up\\n\\n @up.setter\\n def up(self, up):\\n self._up = np.array(up, dtype=np.float32).copy()\\n\\n @property\\n def right(self):\\n return normalize(np.cross(self.up, self.forward))\\n\\n @property\\n def target(self):\\n return self._target\\n\\n @target.setter\\n def target(self, t):\\n self._target = np.array(t, np.float32).copy()\\n\\n def save_cam(self):\\n \\\"\\\"\\\"Saves the current camera parameters\\\"\\\"\\\"\\n cam_dir = C.export_dir + \\\"/camera_params/\\\"\\n if not os.path.exists(cam_dir):\\n os.makedirs(cam_dir)\\n\\n cam_dict = {}\\n cam_dict[\\\"position\\\"] = self.position\\n cam_dict[\\\"target\\\"] = self.target\\n cam_dict[\\\"up\\\"] = self.up\\n cam_dict[\\\"ZOOM_FACTOR\\\"] = self.ZOOM_FACTOR\\n cam_dict[\\\"ROT_FACTOR\\\"] = self.ROT_FACTOR\\n cam_dict[\\\"PAN_FACTOR\\\"] = self.PAN_FACTOR\\n cam_dict[\\\"near\\\"] = self.near\\n cam_dict[\\\"far\\\"] = self.far\\n\\n joblib.dump(cam_dict, cam_dir + \\\"cam_params.pkl\\\")\\n\\n def load_cam(self):\\n \\\"\\\"\\\"Loads the camera parameters\\\"\\\"\\\"\\n cam_dir = C.export_dir + \\\"/camera_params/\\\"\\n if not os.path.exists(cam_dir):\\n print(\\\"camera config does not exist\\\")\\n else:\\n cam_dict = joblib.load(cam_dir + \\\"cam_params.pkl\\\")\\n self.position = cam_dict[\\\"position\\\"]\\n self.target = cam_dict[\\\"target\\\"]\\n self.up = cam_dict[\\\"up\\\"]\\n self.ZOOM_FACTOR = cam_dict[\\\"ZOOM_FACTOR\\\"]\\n self.ROT_FACTOR = cam_dict[\\\"ROT_FACTOR\\\"]\\n self.PAN_FACTOR = cam_dict[\\\"PAN_FACTOR\\\"]\\n self.near = cam_dict[\\\"near\\\"]\\n self.far = cam_dict[\\\"far\\\"]\\n\\n def update_matrices(self, width, height):\\n # Compute projection matrix.\\n if self.is_ortho:\\n yscale = self.ortho_size\\n xscale = width / height * yscale\\n P = orthographic_projection(xscale, yscale, self.near, self.far)\\n else:\\n P = perspective_projection(np.deg2rad(self.fov), width / height, self.near, self.far)\\n\\n # Compute view matrix.\\n V = look_at(self.position, self.target, self.up)\\n\\n # Update camera matrices.\\n self.projection_matrix = P.astype(\\\"f4\\\")\\n self.view_matrix = V.astype(\\\"f4\\\")\\n self.view_projection_matrix = np.matmul(P, V).astype(\\\"f4\\\")\\n\\n def dolly_zoom(self, speed, move_target=False, constant_speed=False):\\n \\\"\\\"\\\"\\n Zoom by moving the camera along its view direction.\\n If move_target is true the camera target will also move rigidly with the camera.\\n \\\"\\\"\\\"\\n # We update both the orthographic and perspective projection so that the transition is seamless when\\n # transitioning between them.\\n self.ortho_size -= 0.1 * np.sign(speed)\\n self.ortho_size = max(0.0001, self.ortho_size)\\n\\n # Scale the speed in proportion to the norm (i.e. camera moves slower closer to the target)\\n norm = max(np.linalg.norm(self.position - self.target), 2)\\n fwd = self.forward\\n\\n # Adjust speed according to config\\n speed *= C.camera_zoom_speed\\n\\n if move_target or constant_speed:\\n if constant_speed:\\n norm = self.constant_speed * 20\\n self.position += fwd * speed * norm\\n self.target += fwd * speed * norm\\n else:\\n # Clamp movement size to avoid surpassing the target\\n movement_length = speed * norm\\n max_movement_length = max(np.linalg.norm(self.target - self.position) - 0.01, 0.0)\\n\\n # Update position\\n self.position += fwd * min(movement_length, max_movement_length)\\n\\n def pan(self, mouse_dx, mouse_dy):\\n \\\"\\\"\\\"Move the camera in the image plane.\\\"\\\"\\\"\\n sideways = normalize(np.cross(self.forward, self.up))\\n up = np.cross(sideways, self.forward)\\n\\n # scale speed according to distance from target\\n speed = max(np.linalg.norm(self.target - self.position) * 0.1, 0.1)\\n\\n speed_x = mouse_dx * self.PAN_FACTOR * speed\\n speed_y = mouse_dy * self.PAN_FACTOR * speed\\n\\n self.position -= sideways * speed_x\\n self.target -= sideways * speed_x\\n\\n self.position += up * speed_y\\n self.target += up * speed_y\\n\\n def rotate_azimuth(self, angle):\\n \\\"\\\"\\\"Rotate around camera's up-axis by given angle (in radians).\\\"\\\"\\\"\\n if np.abs(angle) < 1e-8:\\n return\\n cam_pose = np.linalg.inv(self.view_matrix)\\n up_axis = cam_pose[:3, 1]\\n rot = rotation_matrix(angle, up_axis, self.target)\\n self.position = _transform_vector(rot, self.position)\\n\\n def _rotation_from_mouse_delta(self, mouse_dx: int, mouse_dy: int):\\n z_axis = -self.forward\\n dot = np.dot(z_axis, self.up)\\n rot = np.eye(4)\\n\\n # Avoid singularity when z axis of camera is aligned with the up axis of the scene.\\n if not (mouse_dy > 0 and dot > 0 and 1 - dot < 0.001) and not (mouse_dy < 0 and dot < 0 and 1 + dot < 0.001):\\n # We are either hovering exactly below or above the scene's target but we want to move away or we are\\n # not hitting the singularity anyway.\\n x_axis = -self.right\\n rot_x = rotation_matrix(self.ROT_FACTOR * -mouse_dy, x_axis, self.target)\\n rot = rot_x @ rot\\n\\n y_axis = np.cross(self.forward, self.right)\\n x_speed = self.ROT_FACTOR / 10 if 1 - np.abs(dot) < 0.01 else self.ROT_FACTOR\\n rot = rotation_matrix(x_speed * -mouse_dx, y_axis, self.target) @ rot\\n return rot\\n\\n def rotate_azimuth_elevation(self, mouse_dx: int, mouse_dy: int):\\n \\\"\\\"\\\"Rotate the camera position left-right and up-down orbiting around the target (roll is not allowed).\\\"\\\"\\\"\\n rot = self._rotation_from_mouse_delta(mouse_dx, mouse_dy)\\n self.position = _transform_vector(rot, self.position)\\n\\n def rotate_first_person(self, mouse_dx: int, mouse_dy: int):\\n \\\"\\\"\\\"Rotate the camera target left-right and up-down (roll is not allowed).\\\"\\\"\\\"\\n rot = self._rotation_from_mouse_delta(mouse_dx, mouse_dy)\\n self.target = _transform_direction(rot, self.target - self.position) + self.position\\n\\n def intersect_trackball(self, x: int, y: int, width: int, height: int):\\n \\\"\\\"\\\"\\n Return intersection of a line passing through the mouse position at pixel coordinates x, y\\n and the trackball as a point in world coordinates.\\n \\\"\\\"\\\"\\n # Transform mouse coordinates from -1 to 1\\n nx = 2 * (x + 0.5) / width - 1\\n ny = 1 - 2 * (y + 0.5) / height\\n\\n # Adjust coordinates for the larger side of the viewport rectangle.\\n if width > height:\\n nx *= width / height\\n else:\\n ny *= height / width\\n\\n s = nx * nx + ny * ny\\n if s <= 0.5:\\n # Sphere intersection\\n nz = np.sqrt(1 - s)\\n else:\\n # Hyperboloid intersection.\\n nz = 1 / (2 * np.sqrt(s))\\n\\n # Return intersection position in world coordinates.\\n return self._trackball_start_view_inverse @ np.array((nx, ny, nz))\\n\\n def rotate_trackball(self, x: int, y: int, width: int, height: int):\\n \\\"\\\"\\\"Rotate the camera with trackball controls. Must be called after rotate_start().\\\"\\\"\\\"\\n # Compute points on trackball.\\n start = self._trackball_start_hit\\n current = self.intersect_trackball(x, y, width, height)\\n dist = np.linalg.norm(current - start)\\n\\n # Skip if starting and current point are too close.\\n if dist < 1e-6:\\n return\\n\\n # Compute axis of rotation as the vector perpendicular to the plane spanned by the\\n # vectors connecting the origin to the two points.\\n axis = normalize(np.cross(current, start))\\n\\n # Compute angle as the angle between the two vectors, if they are too far away we use the distance\\n # between them instead, this makes it continue to rotate when dragging the mouse further away.\\n angle = max(np.arccos(np.dot(normalize(current), normalize(start))), dist)\\n\\n # Compute resulting rotation and apply it to the starting position and up vector.\\n rot = rotation_matrix(angle, axis, self.target)\\n self.position = _transform_vector(rot, self._trackball_start_position)\\n self.up = _transform_direction(rot, self._trackball_start_up)\\n\\n def rotate_start(self, x: int, y: int, width: int, height: int):\\n \\\"\\\"\\\"Start rotating the camera. Called on mouse button press.\\\"\\\"\\\"\\n if self.control_mode == \\\"trackball\\\":\\n self._trackball_start_view_inverse = look_at(self.position, self.target, self.up)[:3, :3].T\\n self._trackball_start_hit = self.intersect_trackball(x, y, width, height)\\n self._trackball_start_position = self.position\\n self._trackball_start_up = self.up\\n\\n def rotate(self, x: int, y: int, mouse_dx: int, mouse_dy: int, width: int, height: int):\\n \\\"\\\"\\\"Rotate the camera. Called on mouse movement.\\\"\\\"\\\"\\n if self.control_mode == \\\"turntable\\\":\\n self.rotate_azimuth_elevation(mouse_dx, mouse_dy)\\n elif self.control_mode == \\\"trackball\\\":\\n self.rotate_trackball(x, y, width, height)\\n elif self.control_mode == \\\"first_person\\\":\\n self.rotate_first_person(mouse_dx, mouse_dy)\\n\\n def get_ray(self, x, y, width, height):\\n \\\"\\\"\\\"Construct a ray going through the middle of the given pixel.\\\"\\\"\\\"\\n w, h = width, height\\n\\n # Pixel in (-1, 1) range.\\n screen_x = 2 * (x + 0.5) / w - 1\\n screen_y = 1 - 2 * (y + 0.5) / h\\n\\n # Scale to actual image plane size.\\n scale = self.ortho_size if self.is_ortho else np.tan(np.deg2rad(self.fov) / 2)\\n screen_x *= scale * w / h\\n screen_y *= scale\\n\\n pixel_2d = np.array([screen_x, screen_y, 0 if self.is_ortho else -1])\\n cam2world = np.linalg.inv(self.view_matrix)\\n pixel_3d = _transform_vector(cam2world, pixel_2d)\\n if self.is_ortho:\\n ray_origin = pixel_3d\\n ray_dir = self.forward\\n else:\\n eye_origin = np.zeros(3)\\n ray_origin = _transform_vector(cam2world, eye_origin)\\n ray_dir = pixel_3d - ray_origin\\n ray_dir = ray_dir / np.linalg.norm(ray_dir)\\n\\n return ray_origin, ray_dir\\n\\n def move_with_animation(self, end_position, end_target, time=0.25):\\n self._animation_start_position = self.position.copy()\\n self._animation_end_position = np.array(end_position)\\n self._animation_start_target = self.target.copy()\\n self._animation_end_target = np.array(end_target)\\n self._animation_total_time = time\\n self._animation_t = 0.0\\n self.animating = True\\n\\n def update_animation(self, dt):\\n if not self.animating:\\n return\\n\\n self._animation_t += dt\\n if self._animation_t >= self._animation_total_time:\\n self.position = self._animation_end_position\\n self.target = self._animation_end_target\\n self.animating = False\\n else:\\n t = self._animation_t / self._animation_total_time\\n # Smootherstep interpolation (this polynomial has 0 first and second derivative at 0 and 1)\\n t = t * t * t * (t * (t * 6 - 15) + 10)\\n self.position = self._animation_start_position * (1 - t) + self._animation_end_position * t\\n self.target = self._animation_start_target * (1 - t) + self._animation_end_target * t\\n\\n def gui(self, imgui):\\n _, self.is_ortho = imgui.checkbox(\\\"Orthographic Camera\\\", self.is_ortho)\\n _, self.fov = imgui.slider_float(\\\"Camera FOV##fov\\\", self.fov, 0.1, 180.0, \\\"%.1f\\\")\\n _, self.position = imgui.drag_float3(\\\"Position\\\", *self.position)\\n _, self.target = imgui.drag_float3(\\\"Target\\\", *self.target)\\n _, self.up = imgui.drag_float3(\\\"Up\\\", *self.up)\\n\\n imgui.spacing()\\n # Note: must be kept in sync with self._control_modes.\\n control_modes_labels = [\\\"Turntable\\\", \\\"Trackball\\\", \\\"First Person\\\"]\\n u, idx = imgui.combo(\\\"Control mode\\\", self._control_modes.index(self.control_mode), control_modes_labels)\\n if u and idx >= 0 and idx <= len(self._control_modes):\\n self.control_mode = self._control_modes[idx]\"\n },\n {\n \"identifier\": \"Light\",\n \"path\": \"aitviewer/scene/light.py\",\n \"snippet\": \"class Light(Node):\\n \\\"\\\"\\\"Simple point light.\\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n light_color=(1.0, 1.0, 1.0),\\n elevation=-90.0,\\n azimuth=0.0,\\n strength=1.0,\\n shadow_enabled=True,\\n **kwargs,\\n ):\\n kwargs[\\\"gui_material\\\"] = False\\n super(Light, self).__init__(icon=\\\"\\\\u0085\\\", **kwargs)\\n\\n self._light_color = light_color\\n self.strength = strength\\n self._azimuth = azimuth\\n self._elevation = elevation\\n self.update_rotation()\\n\\n self.shadow_enabled = shadow_enabled\\n self.shadow_map = None\\n self.shadow_map_framebuffer = None\\n\\n self.shadow_map_size = 15.0\\n self.shadow_map_near = 5.0\\n self.shadow_map_far = 50.0\\n\\n self._debug_lines = None\\n self._show_debug_lines = False\\n\\n rot = np.eye(3)\\n rot[2, 2] = -1\\n self.mesh = RigidBodies(\\n np.array([[0, 0, 0]], dtype=np.float32),\\n np.array([rot], dtype=np.float32),\\n radius=0.08,\\n length=0.4,\\n is_selectable=False,\\n )\\n self.mesh.spheres.material.diffuse = 0.0\\n self.mesh.spheres.material.ambient = 1.0\\n self.mesh.spheres.color = (*tuple(light_color), 1.0)\\n self.mesh.export_usd_enabled = False\\n self.add(self.mesh, show_in_hierarchy=False, enabled=False)\\n\\n @classmethod\\n def facing_origin(cls, **kwargs):\\n pos = np.array(kwargs[\\\"position\\\"])\\n dir = -pos / np.linalg.norm(pos)\\n theta, phi = spherical_coordinates_from_direction(dir, degrees=True)\\n return cls(elevation=theta, azimuth=phi, **kwargs)\\n\\n @property\\n def elevation(self):\\n return self._elevation\\n\\n @elevation.setter\\n def elevation(self, elevation):\\n self._elevation = elevation\\n self.update_rotation()\\n\\n @property\\n def azimuth(self):\\n return self._azimuth\\n\\n @azimuth.setter\\n def azimuth(self, azimuth):\\n self._azimuth = azimuth\\n self.update_rotation()\\n\\n @property\\n def light_color(self):\\n return self._light_color\\n\\n @light_color.setter\\n def light_color(self, light_color):\\n self._light_color = light_color\\n self.mesh.spheres.color = (*tuple(light_color), 1.0)\\n\\n def update_rotation(self):\\n self.rotation = look_at(np.array([0, 0, 0]), self.direction, np.array([0.0, 1.0, 0.0]))[:3, :3].T\\n\\n def create_shadowmap(self, ctx):\\n if self.shadow_map is None:\\n shadow_map_size = 8192, 8192\\n\\n # Setup shadow mapping\\n self.shadow_map = ctx.depth_texture(shadow_map_size)\\n self.shadow_map.compare_func = \\\">\\\"\\n self.shadow_map.repeat_x = False\\n self.shadow_map.repeat_y = False\\n self.shadow_map_framebuffer = ctx.framebuffer(depth_attachment=self.shadow_map)\\n\\n def use(self, ctx):\\n if not self.shadow_map:\\n self.create_shadowmap(ctx)\\n\\n self.shadow_map_framebuffer.clear()\\n self.shadow_map_framebuffer.use()\\n\\n @staticmethod\\n @lru_cache()\\n def _compute_light_matrix(position, direction, size, near, far):\\n P = orthographic_projection(size, size, near, far)\\n p = np.array(position)\\n d = np.array(direction)\\n V = look_at(p, p + d, np.array([0.0, 1.0, 0.0]))\\n return (P @ V).astype(\\\"f4\\\")\\n\\n def mvp(self):\\n \\\"\\\"\\\"Return a model-view-projection matrix to project vertices into the view of the light.\\\"\\\"\\\"\\n return self._compute_light_matrix(\\n tuple(self.position),\\n tuple(self.direction),\\n self.shadow_map_size,\\n self.shadow_map_near,\\n self.shadow_map_far,\\n )\\n\\n def _update_debug_lines(self):\\n lines = np.array(\\n [\\n [-1, -1, -1],\\n [-1, 1, -1],\\n [-1, -1, 1],\\n [-1, 1, 1],\\n [1, -1, -1],\\n [1, 1, -1],\\n [1, -1, 1],\\n [1, 1, 1],\\n [-1, -1, -1],\\n [-1, -1, 1],\\n [-1, 1, -1],\\n [-1, 1, 1],\\n [1, -1, -1],\\n [1, -1, 1],\\n [1, 1, -1],\\n [1, 1, 1],\\n [-1, -1, -1],\\n [1, -1, -1],\\n [-1, -1, 1],\\n [1, -1, 1],\\n [-1, 1, -1],\\n [1, 1, -1],\\n [-1, 1, 1],\\n [1, 1, 1],\\n ]\\n )\\n\\n size = self.shadow_map_size\\n view_from_ndc = np.linalg.inv(orthographic_projection(size, size, self.shadow_map_near, self.shadow_map_far))\\n lines = np.apply_along_axis(lambda x: (view_from_ndc @ np.append(x, 1.0))[:3], 1, lines)\\n\\n if self._debug_lines is None:\\n self._debug_lines = Lines(lines, r_base=0.05, mode=\\\"lines\\\", cast_shadow=False, is_selectable=False)\\n self._debug_lines.export_usd_enabled = False\\n self.add(self._debug_lines, show_in_hierarchy=False)\\n else:\\n self._debug_lines.lines = lines\\n self._debug_lines.redraw()\\n\\n def render_outline(self, *args, **kwargs):\\n if self.mesh.enabled:\\n self.mesh.spheres.render_outline(*args, **kwargs)\\n\\n @Node.position.setter\\n def position(self, position):\\n super(Light, self.__class__).position.fset(self, position)\\n self._update_debug_lines()\\n\\n @property\\n def bounds(self):\\n return self.mesh.bounds\\n\\n @property\\n def current_bounds(self):\\n return self.mesh.current_bounds\\n\\n @property\\n def direction(self):\\n return direction_from_spherical_coordinates(self.elevation, self.azimuth, degrees=True)\\n\\n def redraw(self, **kwargs):\\n if self._debug_lines:\\n self._debug_lines.redraw(**kwargs)\\n\\n def gui_affine(self, imgui): # Position controls\\n up, pos = imgui.drag_float3(\\n \\\"Position##pos{}\\\".format(self.unique_name),\\n *self.position,\\n 1e-2,\\n format=\\\"%.2f\\\",\\n )\\n if up:\\n self.position = pos\\n\\n def gui(self, imgui):\\n uc, light_color = imgui.color_edit3(\\\"Color\\\", *self.light_color)\\n if uc:\\n self.light_color = light_color\\n _, self.strength = imgui.drag_float(\\n \\\"Strength\\\",\\n self.strength,\\n 0.01,\\n min_value=0.0,\\n max_value=10.0,\\n format=\\\"%.2f\\\",\\n )\\n u_el, elevation = imgui.drag_float(\\n \\\"Elevation\\\",\\n self.elevation,\\n 0.1,\\n min_value=-90,\\n max_value=90.0,\\n format=\\\"%.2f\\\",\\n )\\n if u_el:\\n self.elevation = elevation\\n u_az, azimuth = imgui.drag_float(\\n \\\"Azimuth\\\",\\n self.azimuth,\\n 0.1,\\n min_value=-360.0,\\n max_value=360.0,\\n format=\\\"%.2f\\\",\\n )\\n if u_az:\\n self.azimuth = np.remainder(azimuth, 360.0)\\n\\n imgui.spacing()\\n _, self.shadow_enabled = imgui.checkbox(\\\"Enable Shadows\\\", self.shadow_enabled)\\n u_size, self.shadow_map_size = imgui.drag_float(\\n \\\"Shadowmap size\\\",\\n self.shadow_map_size,\\n 0.1,\\n format=\\\"%.2f\\\",\\n min_value=0.01,\\n max_value=100.0,\\n )\\n u_near, self.shadow_map_near = imgui.drag_float(\\n \\\"Shadowmap Near\\\",\\n self.shadow_map_near,\\n 0.1,\\n format=\\\"%.2f\\\",\\n min_value=0.01,\\n max_value=100.0,\\n )\\n u_far, self.shadow_map_far = imgui.drag_float(\\n \\\"Shadowmap Far\\\",\\n self.shadow_map_far,\\n 0.1,\\n format=\\\"%.2f\\\",\\n min_value=0.01,\\n max_value=100.0,\\n )\\n _, self.mesh.enabled = imgui.checkbox(\\\"Show light\\\", self.mesh.enabled)\\n u_show, self._show_debug_lines = imgui.checkbox(\\\"Show Frustum\\\", self._show_debug_lines)\\n\\n if self._show_debug_lines:\\n if self._debug_lines:\\n self._debug_lines.enabled = True\\n\\n if u_size or u_near or u_far or u_show:\\n self._update_debug_lines()\\n else:\\n if self._debug_lines:\\n self._debug_lines.enabled = False\\n\\n def export_usd(self, stage, usd_path: str, directory: str = None, verbose=False):\\n name = f\\\"{self.name}_{self.uid:03}\\\".replace(\\\" \\\", \\\"_\\\")\\n usd_path = f\\\"{usd_path}/{name}\\\"\\n\\n # Transform.\\n xform = UsdGeom.Xform.Define(stage, usd_path)\\n a_xform = xform.AddTransformOp()\\n a_xform.Set(Gf.Matrix4d(self.get_local_transform().astype(np.float64).T))\\n\\n # Light.\\n light = UsdLux.DistantLight.Define(stage, usd_path + \\\"/\\\" + name.replace(\\\" \\\", \\\"_\\\"))\\n lightAPI = light.LightAPI()\\n lightAPI.GetInput(\\\"color\\\").Set(self.light_color[:3])\\n lightAPI.GetInput(\\\"intensity\\\").Set(self.strength)\\n\\n self._export_usd_recursively(stage, usd_path, directory, verbose)\"\n },\n {\n \"identifier\": \"Node\",\n \"path\": \"aitviewer/scene/node.py\",\n \"snippet\": \"class Node(object):\\n \\\"\\\"\\\"Interface for nodes.\\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n name=None,\\n icon=None,\\n position=None,\\n rotation=None,\\n scale=1.0,\\n color=(0.5, 0.5, 0.5, 1.0),\\n material=None,\\n is_selectable=True,\\n gui_affine=True,\\n gui_material=True,\\n enabled_frames=None,\\n n_frames=1,\\n ):\\n \\\"\\\"\\\"\\n :param name: Name of the node\\n :param icon: Custom Node Icon using custom Icon font\\n :param position: Starting position in the format (X,Y,Z) or np array of positions with shape (F, 3)\\n :param rotation: Starting rotation in rotation matrix representation (3,3) or np array of rotations with shape (F, 3, 3)\\n :param scale: Starting scale (scalar) or np array of scale values with shape (F)\\n :param color: (R,G,B,A) 0-1 formatted color value.\\n :param material: Object material properties. The color specified in the material will override node color\\n :param is_selectable: If True the node is selectable when clicked on, otherwise the parent node will be selected.\\n :param gui_affine: If True the node will have transform controls (position, rotation, scale) in the GUI.\\n :param gui_material: If True the node will have material controls in the GUI.\\n :param enabled_frames: Numpy array of boolean values, the object will be enabled only in frames where the value is True,\\n the number of ones in the mask must match the number of frames of the object.\\n :param n_frames: How many frames this renderable has.\\n \\\"\\\"\\\"\\n # Transform & Animation\\n position = np.zeros(3, dtype=np.float32) if position is None else np.array(position, dtype=np.float32)\\n rotation = np.eye(3, dtype=np.float32) if rotation is None else np.array(rotation, dtype=np.float32)\\n\\n self._positions = position if len(position.shape) != 1 else position[np.newaxis]\\n self._rotations = rotation if len(rotation.shape) != 2 else rotation[np.newaxis]\\n self._scales = (scale if isinstance(scale, np.ndarray) else np.array([scale])).astype(np.float32)\\n\\n n_positions = self._positions.shape[0]\\n n_rotations = self._rotations.shape[0]\\n n_scales = self._scales.shape[0]\\n\\n if n_frames > 1:\\n assert n_positions == 1 or n_frames == n_positions, (\\n f\\\"Number of position frames\\\" f\\\" ({n_positions}) must be 1 or match number of Node frames {n_frames}\\\"\\n )\\n assert n_rotations == 1 or n_frames == n_rotations, (\\n f\\\"Number of rotations frames\\\" f\\\" ({n_rotations}) must be 1 or match number of Node frames {n_frames}\\\"\\n )\\n assert n_scales == 1 or n_frames == n_scales, (\\n f\\\"Number of scales frames\\\" f\\\" ({n_scales}) must be 1 or match number of Node frames {n_frames}\\\"\\n )\\n else:\\n n_frames = max(n_positions, n_rotations, n_scales)\\n assert (\\n (n_positions == 1 or n_positions == n_frames)\\n and (n_rotations == 1 or n_rotations == n_frames)\\n and (n_scales == 1 or n_scales == n_frames)\\n ), (\\n f\\\"Number of position\\\"\\n f\\\"({n_positions}), rotation ({n_rotations}) and scale ({n_scales})\\\"\\n \\\"frames must be 1 or match.\\\"\\n )\\n\\n # Frames\\n self._n_frames = n_frames\\n self._current_frame_id = 0\\n self.model_matrix = self.get_local_transform()\\n self._enabled_frames = enabled_frames\\n if self._enabled_frames is not None:\\n assert np.count_nonzero(self._enabled_frames) == n_frames, (\\n f\\\"Number of non-zero elements in enabled_frames\\\"\\n f\\\" ({np.count_nonzero(self._enabled_frames)}) must match number of frames in sequence ({n_frames})\\\"\\n )\\n # Create an array that maps from the true frame id (counting also disabled frames) to the index of the\\n # first existing frame in the sequence.\\n self._enabled_frame_id = np.cumsum(self._enabled_frames) - 1\\n\\n # Stores the true frame id (counting also disabled frames) we use this to allow going\\n # through both enabled and disabled frames from the GUI.\\n self._internal_frame_id = 0\\n\\n # Material\\n self.material = Material(color=color) if material is None else material\\n\\n # Renderable Attributes\\n self.is_renderable = False\\n self.backface_culling = True\\n self.backface_fragmap = False\\n self.draw_outline = False\\n\\n # Flags to enable rendering passes\\n self.cast_shadow = False\\n self.depth_prepass = False\\n self.fragmap = False\\n self.outline = False\\n\\n # Programs for render passes. Subclasses are responsible for setting these.\\n self.depth_only_program = None # Required for depth_prepass and cast_shadow passes\\n self.fragmap_program = None # Required for fragmap pass\\n self.outline_program = None # Required for outline pass\\n\\n # GUI\\n self.name = name if name is not None else type(self).__name__\\n self.uid = C.next_gui_id()\\n self.unique_name = self.name + \\\"{}\\\".format(self.uid)\\n self.icon = icon if icon is not None else \\\"\\\\u0082\\\"\\n self._enabled = True\\n self._expanded = False\\n self.gui_controls = {\\n \\\"affine\\\": {\\n \\\"fn\\\": self.gui_affine,\\n \\\"icon\\\": \\\"\\\\u009b\\\",\\n \\\"is_visible\\\": gui_affine,\\n },\\n \\\"material\\\": {\\n \\\"fn\\\": self.gui_material,\\n \\\"icon\\\": \\\"\\\\u0088\\\",\\n \\\"is_visible\\\": gui_material,\\n },\\n \\\"animation\\\": {\\n \\\"fn\\\": self.gui_animation,\\n \\\"icon\\\": \\\"\\\\u0098\\\",\\n \\\"is_visible\\\": (lambda: self._n_frames > 1)(),\\n },\\n \\\"io\\\": {\\n \\\"fn\\\": self.gui_io,\\n \\\"icon\\\": \\\"\\\\u009a\\\",\\n \\\"is_visible\\\": (lambda: self.gui_io.__func__ is not Node.gui_io)(),\\n },\\n }\\n self.gui_modes = {\\\"view\\\": {\\\"title\\\": \\\" View\\\", \\\"fn\\\": self.gui_mode_view, \\\"icon\\\": \\\"\\\\u0099\\\"}}\\n self._selected_mode = \\\"view\\\"\\n self._show_in_hierarchy = True\\n self.is_selectable = is_selectable\\n self.export_usd_enabled = True\\n self.export_usd_expanded = True\\n\\n self.nodes: List[Node] = []\\n self.parent: Node = None\\n\\n # Selected Mode\\n @property\\n def selected_mode(self):\\n return self._selected_mode\\n\\n @selected_mode.setter\\n def selected_mode(self, selected_mode):\\n self._selected_mode = selected_mode\\n\\n # Transform\\n @property\\n def position(self):\\n idx = self.current_frame_id if self._positions.shape[0] > 1 else 0\\n return self._positions[idx]\\n\\n @position.setter\\n def position(self, position):\\n idx = self.current_frame_id if self._positions.shape[0] > 1 else 0\\n self._positions[idx] = np.array(position, dtype=np.float32).copy()\\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\\n\\n @property\\n def positions(self):\\n return self._positions\\n\\n @positions.setter\\n def positions(self, positions):\\n self._positions = positions\\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\\n\\n @property\\n def rotation(self):\\n idx = self.current_frame_id if self._rotations.shape[0] > 1 else 0\\n return self._rotations[idx]\\n\\n @rotation.setter\\n def rotation(self, rotation):\\n idx = self.current_frame_id if self._rotations.shape[0] > 1 else 0\\n self._rotations[idx] = rotation\\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\\n\\n @property\\n def rotations(self):\\n return self._rotations\\n\\n @rotations.setter\\n def rotations(self, rotations):\\n self._rotations = rotations\\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\\n\\n @property\\n def scale(self):\\n idx = self.current_frame_id if self._scales.shape[0] > 1 else 0\\n return self._scales[idx]\\n\\n @scale.setter\\n def scale(self, scale):\\n idx = self.current_frame_id if self._scales.shape[0] > 1 else 0\\n self._scales[idx] = scale\\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\\n\\n @property\\n def scales(self):\\n return self._scales\\n\\n @scales.setter\\n def scales(self, scales):\\n self._scales = scales\\n self.update_transform(None if self.parent is None else self.parent.model_matrix)\\n\\n @staticmethod\\n @lru_cache()\\n def _compute_transform(pos, rot, scale):\\n rotation = np.eye(4)\\n rotation[:3, :3] = np.array(rot)\\n\\n trans = np.eye(4)\\n trans[:3, 3] = np.array(pos)\\n\\n scale = np.diag([scale, scale, scale, 1])\\n\\n return (trans @ rotation @ scale).astype(\\\"f4\\\")\\n\\n def get_local_transform(self):\\n \\\"\\\"\\\"Construct local transform as a 4x4 matrix from this node's position, orientation and scale.\\\"\\\"\\\"\\n return self._compute_transform(tuple(self.position), tuple(map(tuple, self.rotation)), self.scale)\\n\\n def update_transform(self, parent_transform=None):\\n \\\"\\\"\\\"Update the model matrix of this node and all of its descendants.\\\"\\\"\\\"\\n if parent_transform is None:\\n self.model_matrix = self.get_local_transform()\\n else:\\n self.model_matrix = parent_transform.astype(\\\"f4\\\") @ self.get_local_transform()\\n\\n for n in self.nodes:\\n n.update_transform(self.model_matrix)\\n\\n @property\\n def color(self):\\n return self.material.color\\n\\n @color.setter\\n def color(self, color):\\n self.material.color = color\\n\\n @property\\n def bounds(self):\\n \\\"\\\"\\\"The bounds in the format ((x_min, x_max), (y_min, y_max), (z_min, z_max))\\\"\\\"\\\"\\n return np.array([[0, 0], [0, 0], [0, 0]])\\n\\n @property\\n def current_bounds(self):\\n return np.array([[0, 0], [0, 0], [0, 0]])\\n\\n @property\\n def current_center(self):\\n return self.current_bounds.mean(-1)\\n\\n @property\\n def center(self):\\n return self.bounds.mean(-1)\\n\\n def get_local_bounds(self, points):\\n if len(points.shape) == 2 and points.shape[-1] == 3:\\n points = points[np.newaxis]\\n assert len(points.shape) == 3\\n\\n # Compute min and max coordinates of the bounding box ignoring NaNs.\\n val = np.array(\\n [\\n [np.nanmin(points[:, :, 0]), np.nanmax(points[:, :, 0])],\\n [np.nanmin(points[:, :, 1]), np.nanmax(points[:, :, 1])],\\n [np.nanmin(points[:, :, 2]), np.nanmax(points[:, :, 2])],\\n ]\\n )\\n\\n # If any of the elements is NaN return an empty bounding box.\\n if np.isnan(val).any():\\n return np.array([[0, 0], [0, 0], [0, 0]])\\n else:\\n return val\\n\\n def get_bounds(self, points):\\n val = self.get_local_bounds(points)\\n\\n # Transform bounding box with the model matrix.\\n val = (self.model_matrix @ np.vstack((val, np.array([1.0, 1.0]))))[:3]\\n\\n # If any of the elements is NaN return an empty bounding box.\\n if np.isnan(val).any():\\n return np.array([[0, 0], [0, 0], [0, 0]])\\n else:\\n return val\\n\\n @property\\n def n_frames(self):\\n return self._n_frames\\n\\n @n_frames.setter\\n def n_frames(self, n_frames):\\n self._n_frames = n_frames\\n\\n def __len__(self):\\n return self.n_frames\\n\\n @property\\n def current_frame_id(self):\\n return self._current_frame_id\\n\\n @current_frame_id.setter\\n def current_frame_id(self, frame_id):\\n # Check if the frame changed.\\n last_frame_id = self._current_frame_id if self._enabled_frames is None else self._internal_frame_id\\n if self.n_frames == 1 or frame_id == last_frame_id:\\n return\\n\\n self.on_before_frame_update()\\n if self._enabled_frames is None:\\n if frame_id < 0:\\n self._current_frame_id = 0\\n elif frame_id >= len(self):\\n self._current_frame_id = len(self) - 1\\n else:\\n self._current_frame_id = frame_id\\n else:\\n # If an enabled_frames is present use it to get the current frame.\\n if frame_id < 0:\\n self._internal_frame_id = 0\\n elif frame_id >= self._enabled_frames.shape[0]:\\n self._internal_frame_id = self._enabled_frames.shape[0] - 1\\n else:\\n self._internal_frame_id = frame_id\\n self._current_frame_id = self._enabled_frame_id[self._internal_frame_id]\\n # Update enabled using the mask.\\n self.enabled = self._enabled_frames[self._internal_frame_id]\\n\\n # Update frame id of all children nodes.\\n for n in self.nodes:\\n n.current_frame_id = self._current_frame_id\\n\\n self.on_frame_update()\\n if self.parent and (self._positions.shape[0] > 1 or self._rotations.shape[0] > 1 or self._scales.shape[0] > 1):\\n self.update_transform(self.parent.model_matrix)\\n\\n def next_frame(self):\\n self.current_frame_id = self.current_frame_id + 1 if self.current_frame_id < len(self) - 1 else 0\\n\\n def previous_frame(self):\\n self.current_frame_id = self.current_frame_id - 1 if self.current_frame_id > 0 else len(self) - 1\\n\\n def on_before_frame_update(self):\\n \\\"\\\"\\\"Called when the current frame is about to change, 'self.current_frame_id' still has the id of the\\n previous frame.\\\"\\\"\\\"\\n pass\\n\\n def on_frame_update(self):\\n \\\"\\\"\\\"Called when the current frame is changed.\\\"\\\"\\\"\\n pass\\n\\n def add(self, *nodes, **kwargs):\\n self._add_nodes(*nodes, **kwargs)\\n\\n def _add_node(self, n: \\\"Node\\\", show_in_hierarchy=True, expanded=False, enabled=True):\\n \\\"\\\"\\\"\\n Add a single node\\n :param show_in_hierarchy: Whether to show the node in the scene hierarchy.\\n :param expanded: Whether the node is initially expanded in the GUI.\\n \\\"\\\"\\\"\\n if n is None:\\n return\\n n._show_in_hierarchy = show_in_hierarchy\\n n._expanded = expanded\\n n._enabled = enabled if n._enabled_frames is None else n._enabled_frames[n.current_frame_id]\\n self.nodes.append(n)\\n n.parent = self\\n n.update_transform(self.model_matrix)\\n\\n def _add_nodes(self, *nodes, **kwargs):\\n \\\"\\\"\\\"Add multiple nodes\\\"\\\"\\\"\\n for n in nodes:\\n self._add_node(n, **kwargs)\\n\\n def remove(self, *nodes):\\n for n in nodes:\\n n.release()\\n try:\\n self.nodes.remove(n)\\n except:\\n pass\\n\\n @property\\n def show_in_hierarchy(self):\\n return self._show_in_hierarchy\\n\\n @property\\n def enabled(self):\\n return self._enabled\\n\\n @enabled.setter\\n def enabled(self, enabled):\\n self._enabled = enabled\\n\\n @property\\n def expanded(self):\\n return self._expanded\\n\\n @expanded.setter\\n def expanded(self, expanded):\\n self._expanded = expanded\\n\\n def is_transparent(self):\\n \\\"\\\"\\\"\\n Returns true if the object is transparent and should thus be sorted when rendering.\\n Subclassess that use a different color should implement this method to be rendered correctly when transparent.\\n \\\"\\\"\\\"\\n return self.material.color[3] < 1.0\\n\\n def gui(self, imgui):\\n \\\"\\\"\\\"\\n Render GUI for custom node properties and controls. Implementation optional.\\n Elements rendered here will show up in the scene hierarchy\\n :param imgui: imgui context.\\n See https://pyimgui.readthedocs.io/en/latest/reference/imgui.core.html for available elements to render\\n \\\"\\\"\\\"\\n pass\\n\\n def gui_modes(self, imgui):\\n \\\"\\\"\\\"Render GUI with toolbar (tools) for this particular node\\\"\\\"\\\"\\n\\n def gui_animation(self, imgui):\\n \\\"\\\"\\\"Render GUI for animation related settings\\\"\\\"\\\"\\n\\n if self._enabled_frames is None:\\n if self.n_frames > 1:\\n u, fid = imgui.slider_int(\\n \\\"Frame##r_{}\\\".format(self.unique_name),\\n self.current_frame_id,\\n min_value=0,\\n max_value=self.n_frames - 1,\\n )\\n if u:\\n self.current_frame_id = fid\\n else:\\n u, fid = imgui.slider_int(\\n \\\"Frame##r_{}\\\".format(self.unique_name),\\n self._internal_frame_id,\\n min_value=0,\\n max_value=self._enabled_frames.shape[0] - 1,\\n )\\n if u:\\n self.current_frame_id = fid\\n\\n def gui_affine(self, imgui):\\n \\\"\\\"\\\"Render GUI for affine transformations\\\"\\\"\\\"\\n # Position controls\\n up, pos = imgui.drag_float3(\\n \\\"Position##pos{}\\\".format(self.unique_name),\\n *self.position,\\n 1e-2,\\n format=\\\"%.2f\\\",\\n )\\n if up:\\n self.position = pos\\n\\n # Rotation controls\\n euler_angles = rot2euler_numpy(self.rotation[np.newaxis], degrees=True)[0]\\n ur, euler_angles = imgui.drag_float3(\\n \\\"Rotation##pos{}\\\".format(self.unique_name),\\n *euler_angles,\\n 1e-2,\\n format=\\\"%.2f\\\",\\n )\\n if ur:\\n self.rotation = euler2rot_numpy(np.array(euler_angles)[np.newaxis], degrees=True)[0]\\n\\n # Scale controls\\n us, scale = imgui.drag_float(\\n \\\"Scale##scale{}\\\".format(self.unique_name),\\n self.scale,\\n 1e-2,\\n min_value=0.001,\\n max_value=100.0,\\n format=\\\"%.3f\\\",\\n )\\n if us:\\n self.scale = scale\\n\\n def gui_material(self, imgui):\\n \\\"\\\"\\\"Render GUI with material properties\\\"\\\"\\\"\\n\\n # Color Control\\n uc, color = imgui.color_edit4(\\\"Color##color{}'\\\".format(self.unique_name), *self.material.color)\\n if uc:\\n self.color = color\\n\\n # Diffuse\\n ud, diffuse = imgui.slider_float(\\n \\\"Diffuse##diffuse{}\\\".format(self.unique_name),\\n self.material.diffuse,\\n 0.0,\\n 1.0,\\n \\\"%.2f\\\",\\n )\\n if ud:\\n self.material.diffuse = diffuse\\n\\n # Ambient\\n ua, ambient = imgui.slider_float(\\n \\\"Ambient##ambient{}\\\".format(self.unique_name),\\n self.material.ambient,\\n 0.0,\\n 1.0,\\n \\\"%.2f\\\",\\n )\\n if ua:\\n self.material.ambient = ambient\\n\\n def gui_io(self, imgui):\\n \\\"\\\"\\\"Render GUI for import/export\\\"\\\"\\\"\\n pass\\n\\n def gui_mode_view(self, imgui):\\n \\\"\\\"\\\"Render custom GUI for view mode\\\"\\\"\\\"\\n pass\\n\\n def gui_context_menu(self, imgui, x: int, y: int):\\n _, self.enabled = imgui.checkbox(\\\"Enabled\\\", self.enabled)\\n if any([n._show_in_hierarchy for n in self.nodes]):\\n imgui.spacing()\\n imgui.separator()\\n imgui.spacing()\\n for n in self.nodes:\\n if not n._show_in_hierarchy:\\n continue\\n if imgui.begin_menu(f\\\"{n.name}##{n.uid}\\\"):\\n n.gui_context_menu(imgui, x, y)\\n imgui.end_menu()\\n\\n # Renderable\\n @staticmethod\\n def once(func):\\n def _decorator(self, *args, **kwargs):\\n if self.is_renderable:\\n return\\n else:\\n func(self, *args, **kwargs)\\n self.is_renderable = True\\n\\n return _decorator\\n\\n def make_renderable(self, ctx):\\n \\\"\\\"\\\"\\n Prepares this object for rendering. This function must be called before `render` is used.\\n :param ctx: The moderngl context.\\n \\\"\\\"\\\"\\n pass\\n\\n def render(self, camera, position=None, rotation=None, **kwargs):\\n \\\"\\\"\\\"Render the current frame in this sequence.\\\"\\\"\\\"\\n pass\\n\\n def render_positions(self, prog):\\n \\\"\\\"\\\"\\n Render with a VAO with only positions bound, used for shadow mapping, fragmap and depth prepass.\\n \\\"\\\"\\\"\\n pass\\n\\n def redraw(self, **kwargs):\\n \\\"\\\"\\\"Perform update and redraw operations. Push to the GPU when finished. Recursively redraw child nodes\\\"\\\"\\\"\\n for n in self.nodes:\\n n.redraw(**kwargs)\\n\\n def set_camera_matrices(self, prog, camera, **kwargs):\\n \\\"\\\"\\\"Set the model view projection matrix in the given program.\\\"\\\"\\\"\\n # Transpose because np is row-major but OpenGL expects column-major.\\n prog[\\\"model_matrix\\\"].write(self.model_matrix.T.astype(\\\"f4\\\").tobytes())\\n prog[\\\"view_projection_matrix\\\"].write(camera.get_view_projection_matrix().T.astype(\\\"f4\\\").tobytes())\\n\\n def receive_shadow(self, program, **kwargs):\\n \\\"\\\"\\\"\\n Call this function if the renderable is to receive shadows.\\n :param program: The shader program that can shade with shadows.\\n :param kwargs: The render kwargs.\\n \\\"\\\"\\\"\\n if kwargs.get(\\\"shadows_enabled\\\", False):\\n lights = kwargs[\\\"lights\\\"]\\n\\n for i, light in enumerate(lights):\\n if light.shadow_enabled and light.shadow_map:\\n light_matrix = light.mvp() @ self.model_matrix\\n program[f\\\"dirLights[{i}].matrix\\\"].write(light_matrix.T.tobytes())\\n\\n # Bind shadowmap to slot i + 1, we reserve slot 0 for the mesh texture\\n # and use slots 1 to (#lights + 1) for shadow maps\\n light.shadow_map.use(location=i + 1)\\n\\n # Set sampler uniforms\\n uniform = program[f\\\"shadow_maps\\\"]\\n uniform.value = 1 if uniform.array_length == 1 else [*range(1, len(lights) + 1)]\\n\\n def render_shadowmap(self, light_matrix):\\n if not self.cast_shadow or self.depth_only_program is None or self.color[3] == 0.0:\\n return\\n\\n prog = self.depth_only_program\\n prog[\\\"model_matrix\\\"].write(self.model_matrix.T.tobytes())\\n prog[\\\"view_projection_matrix\\\"].write(light_matrix.T.tobytes())\\n\\n self.render_positions(prog)\\n\\n def render_fragmap(self, ctx, camera, uid=None):\\n if not self.fragmap or self.fragmap_program is None:\\n return\\n\\n # Transpose because np is row-major but OpenGL expects column-major.\\n prog = self.fragmap_program\\n self.set_camera_matrices(prog, camera)\\n\\n # Render with the specified object uid, if None use the node uid instead.\\n prog[\\\"obj_id\\\"] = uid or self.uid\\n\\n if self.backface_culling or self.backface_fragmap:\\n ctx.enable(moderngl.CULL_FACE)\\n else:\\n ctx.disable(moderngl.CULL_FACE)\\n\\n # If backface_fragmap is enabled for this node only render backfaces\\n if self.backface_fragmap:\\n ctx.cull_face = \\\"front\\\"\\n\\n self.render_positions(prog)\\n\\n # Restore cull face to back\\n if self.backface_fragmap:\\n ctx.cull_face = \\\"back\\\"\\n\\n def render_depth_prepass(self, camera, **kwargs):\\n if not self.depth_prepass or self.depth_only_program is None:\\n return\\n\\n prog = self.depth_only_program\\n self.set_camera_matrices(prog, camera)\\n self.render_positions(prog)\\n\\n def render_outline(self, ctx, camera):\\n if self.outline and self.outline_program is not None:\\n prog = self.outline_program\\n self.set_camera_matrices(prog, camera)\\n\\n if self.backface_culling:\\n ctx.enable(moderngl.CULL_FACE)\\n else:\\n ctx.disable(moderngl.CULL_FACE)\\n self.render_positions(prog)\\n\\n # Render children node recursively.\\n for n in self.nodes:\\n n.render_outline(ctx, camera)\\n\\n def release(self):\\n \\\"\\\"\\\"\\n Release all OpenGL resources used by this node and any of its children. Subclasses that instantiate OpenGL\\n objects should implement this method with '@hooked' to avoid leaking resources.\\n \\\"\\\"\\\"\\n for n in self.nodes:\\n n.release()\\n\\n def on_selection(self, node, instance_id, tri_id):\\n \\\"\\\"\\\"\\n Called when the node is selected\\n\\n :param node: the node which was clicked (can be None if the selection wasn't a mouse event)\\n :param instance_id: the id of the instance that was clicked, 0 if the object is not instanced\\n (can be None if the selection wasn't a mouse event)\\n :param tri_id: the id of the triangle that was clicked from the 'node' mesh\\n (can be None if the selection wasn't a mouse event)\\n \\\"\\\"\\\"\\n pass\\n\\n def key_event(self, key, wnd_keys):\\n \\\"\\\"\\\"\\n Handle shortcut key presses (if you are the selected object)\\n \\\"\\\"\\\"\\n pass\\n\\n def update_frames(self, *args, **kwargs):\\n pass\\n\\n def add_frames(self, *args, **kwargs):\\n pass\\n\\n def remove_frames(self, *args, **kwargs):\\n pass\\n\\n def _export_usd_recursively(self, stage, usd_path, directory, verbose):\\n if verbose:\\n print(usd_path)\\n for n in self.nodes:\\n if n.export_usd_enabled:\\n n.export_usd(stage, usd_path, directory, verbose)\\n\\n def export_usd(self, stage, usd_path: str, directory: str = None, verbose=False):\\n \\\"\\\"\\\"\\n Export the node into an USD file. Nodes that implement this method should use\\n recursively call this for every children that should also be exported.\\n\\n :param stage: an object of type Usd.Stage into which to export the node\\n :param usd_path: the path of the parent object in the USD file scene hierarchy.\\n \\\"\\\"\\\"\\n from pxr import Gf, UsdGeom\\n\\n usd_path = f\\\"{usd_path}/{self.name.replace(' ', '_')}_{self.uid:03}\\\"\\n\\n # Transform.\\n xform = UsdGeom.Xform.Define(stage, usd_path)\\n a_xform = xform.AddTransformOp()\\n a_xform.Set(Gf.Matrix4d(self.get_local_transform().astype(np.float64).T))\\n\\n self._export_usd_recursively(stage, usd_path, directory, verbose)\"\n },\n {\n \"identifier\": \"compute_union_of_bounds\",\n \"path\": \"aitviewer/utils/utils.py\",\n \"snippet\": \"def compute_union_of_bounds(nodes):\\r\\n if len(nodes) == 0:\\r\\n return np.zeros((3, 2))\\r\\n\\r\\n bounds = np.array([[np.inf, np.NINF], [np.inf, np.NINF], [np.inf, np.NINF]])\\r\\n for n in nodes:\\r\\n child = n.bounds\\r\\n bounds[:, 0] = np.minimum(bounds[:, 0], child[:, 0])\\r\\n bounds[:, 1] = np.maximum(bounds[:, 1], child[:, 1])\\r\\n return bounds\\r\"\n },\n {\n \"identifier\": \"compute_union_of_current_bounds\",\n \"path\": \"aitviewer/utils/utils.py\",\n \"snippet\": \"def compute_union_of_current_bounds(nodes):\\r\\n if len(nodes) == 0:\\r\\n return np.zeros((3, 2))\\r\\n\\r\\n bounds = np.array([[np.inf, np.NINF], [np.inf, np.NINF], [np.inf, np.NINF]])\\r\\n for n in nodes:\\r\\n child = n.current_bounds\\r\\n bounds[:, 0] = np.minimum(bounds[:, 0], child[:, 0])\\r\\n bounds[:, 1] = np.maximum(bounds[:, 1], child[:, 1])\\r\\n return bounds\\r\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import moderngl\nimport numpy as np\nfrom aitviewer.configuration import CONFIG as C\nfrom aitviewer.renderables.coordinate_system import CoordinateSystem\nfrom aitviewer.renderables.lines import Lines2D\nfrom aitviewer.renderables.plane import ChessboardPlane\nfrom aitviewer.scene.camera import ViewerCamera\nfrom aitviewer.scene.light import Light\nfrom aitviewer.scene.node import Node\nfrom aitviewer.utils.utils import (\n compute_union_of_bounds,\n compute_union_of_current_bounds,\n)"},"token_num":{"kind":"number","value":17064,"string":"17,064"},"cropped_code":{"kind":"string","value":"# Copyright (C) 2023 ETH Zurich, Manuel Kaufmann, Velko Vechev, Dario Mylonopoulos\n\n\n\nclass Scene(Node):\n \"\"\"Generic scene node\"\"\"\n\n def __init__(self, **kwargs):\n \"\"\"Create a scene with a name.\"\"\"\n kwargs[\"gui_material\"] = False\n super(Scene, self).__init__(**kwargs)\n\n # References resources in the scene\n self.lights = []\n self.camera = None\n\n # Scene has a reference to ctx\n self.ctx = None\n\n self.backface_culling = True\n"},"all_code":{"kind":"string","value":"# Copyright (C) 2023 ETH Zurich, Manuel Kaufmann, Velko Vechev, Dario Mylonopoulos\n\n\n\nclass Scene(Node):\n \"\"\"Generic scene node\"\"\"\n\n def __init__(self, **kwargs):\n \"\"\"Create a scene with a name.\"\"\"\n kwargs[\"gui_material\"] = False\n super(Scene, self).__init__(**kwargs)\n\n # References resources in the scene\n self.lights = []\n self.camera = None\n\n # Scene has a reference to ctx\n self.ctx = None\n\n self.backface_culling = True"},"next_line":{"kind":"string","value":" self.fps = C.scene_fps"},"gold_snippet_index":{"kind":"number","value":3,"string":"3"},"created_at":{"kind":"string","value":"2023-12-07 16:13:50+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5976,"cells":{"repo_name":{"kind":"string","value":"nexB/dejacode"},"file_path":{"kind":"string","value":"reporting/admin.py"},"context":{"kind":"list like","value":[{"identifier":"DataspacedAdmin","path":"dje/admin.py","snippet":"class DataspacedAdmin(\n DataspacedFKMixin,\n ProtectedFieldsMixin,\n AdvancedSearchAdminMixin,\n HistoryAdminMixin,\n admin.ModelAdmin,\n):\n formfield_overrides = {\n models.DateField: {\"widget\": AdminDateWidget(attrs={\"placeholder\": \"YYYY-MM-DD\"})},\n }\n list_filter = (DataspaceFilter,)\n readonly_fields = (\n \"dataspace\",\n \"uuid\",\n )\n actions = [\"copy_to\", \"compare_with\"]\n actions_to_remove = []\n email_notification_on = [ADDITION, CHANGE, DELETION]\n save_as = True\n\n # Display only the current count\n show_full_result_count = False\n\n # Display a warning if any of the identifier_fields has changed\n identifier_fields_warning = True\n\n # Default form, customized form should always extend DataspacedAdminForm\n form = DataspacedAdminForm\n\n # Using extended version of base templates to avoid code duplication\n change_form_template = \"admin/change_form_extended.html\"\n change_list_template = \"admin/change_list_extended.html\"\n\n # Set this to a BaseImporter extension of the Model to enable the import\n importer_class = None\n\n # Set this to a DejacodeMassUpdateForm to enable the mass update action\n mass_update_form = None\n\n # Set this to False to disable the Activity Log feature\n activity_log = True\n\n # Set this to True to enable the Previous and Next buttons in change view\n navigation_buttons = False\n\n preserve_filters = True\n\n # Do not display the View on site links by default\n # Set: view_on_site = DataspacedAdmin.changeform_view_on_site\n # for the default obj.get_absolute_url()\n view_on_site = False\n\n def __init__(self, model, admin_site):\n self.form.admin_site = admin_site\n super().__init__(model, admin_site)\n\n def check(self, **kwargs):\n errors = super().check(**kwargs)\n\n has_wrong_form_subclass = all(\n [\n not issubclass(self.form, DataspacedAdminForm),\n self.model._meta.unique_together != ((\"dataspace\", \"uuid\"),),\n ]\n )\n\n if has_wrong_form_subclass:\n errors.extend(\n [checks.Error(f\"{self.form} is not a subclass of {DataspacedAdminForm}\", obj=self)]\n )\n\n return errors\n\n def changeform_view_on_site(self, obj):\n return obj.get_absolute_url()\n\n @admin.display(description=_(\"View\"))\n def changelist_view_on_site(self, obj):\n return format_html('<a href=\"{}\" target=\"_blank\">View</a>', obj.get_absolute_url())\n\n @admin.display(description=_(\"URN\"))\n def urn_link(self, instance):\n \"\"\"Attach the URN link if URN is supported on the Model.\"\"\"\n if instance.pk:\n return instance.urn_link\n return f\"URN will be available once the {instance._meta.verbose_name} is saved.\"\n\n def get_queryset(self, request):\n qs = super().get_queryset(request)\n return qs.scope_for_user_in_admin(request.user)\n\n def get_changelist(self, request, **kwargs):\n return DataspacedChangeList\n\n def get_list_filter(self, request):\n \"\"\"Limit the availability of `MissingInFilter` to superusers.\"\"\"\n list_filter = list(super().get_list_filter(request))\n\n if not request.user.is_superuser and MissingInFilter in list_filter:\n del list_filter[list_filter.index(MissingInFilter)]\n\n # Custom LogEntry-based filters when field not available on the model\n history_filters = {\n \"created_by\": CreatedByListFilter,\n \"last_modified_by\": None,\n \"created_date\": HistoryCreatedActionTimeListFilter,\n \"last_modified_date\": HistoryModifiedActionTimeListFilter,\n }\n\n for field_name, default_filter in history_filters.items():\n try:\n field = self.model._meta.get_field(field_name)\n except FieldDoesNotExist:\n if default_filter:\n list_filter.append(default_filter)\n continue\n\n filtr = field_name\n if isinstance(field, models.ForeignKey):\n filtr = (field_name, LimitToDataspaceListFilter)\n list_filter.append(filtr)\n\n return list_filter\n\n def get_readonly_fields(self, request, obj=None):\n readonly_fields = super().get_readonly_fields(request, obj)\n\n if issubclass(self.model, HistoryFieldsMixin):\n readonly_fields += (\n \"created_date\",\n \"created_by\",\n \"last_modified_date\",\n \"last_modified_by\",\n )\n\n return readonly_fields\n\n def change_view(self, request, object_id, form_url=\"\", extra_context=None):\n \"\"\"\n Render the changelist using the current preserved filters to gather the\n previous and next id.\n \"\"\"\n context = extra_context or {}\n\n # WARNING: request.GET is important as a condition since we do not want to run this\n # expensive operation in case no given filter/search/sort is applied.\n # For example when the admin form is reached directly from the user details view.\n if self.navigation_buttons and request.method == \"GET\" and request.GET:\n fake_request = copy(request)\n query_dict = fake_request.GET.copy()\n preserved_filters = query_dict.pop(\"_changelist_filters\", \"\")\n if preserved_filters:\n preserved_filters = force_str(preserved_filters[0])\n fake_request.GET = QueryDict(preserved_filters)\n changelist_view = self.changelist_view(fake_request)\n\n # Sanity check, if the _changelist_filters were manually changed for example.\n if hasattr(changelist_view, \"context_data\"):\n # Do not use \".values_list('id', flat=True)\" to avoid an extra query\n ids_list = [str(obj.id) for obj in changelist_view.context_data[\"cl\"].result_list]\n previous_id, next_id = get_previous_next(ids_list, str(object_id))\n context.update(\n {\n \"previous_id\": previous_id,\n \"next_id\": next_id,\n }\n )\n\n if self.save_as and self.identifier_fields_warning:\n identifier_fields = self.model.get_identifier_fields()\n context[\"identifier_fields\"] = identifier_fields\n\n return super().change_view(request, object_id, form_url, context)\n\n def render_change_form(self, request, context, add=False, change=False, form_url=\"\", obj=None):\n response = super().render_change_form(request, context, add, change, form_url, obj)\n # De-activating the 'Save as' option if the user is editing an Object\n # belonging to another Dataspace.\n # We are able to update the context_data at that point as the\n # TemplateResponse as not been rendered yet.\n if obj and obj.dataspace != request.user.dataspace:\n response.context_data[\"save_as\"] = False\n return response\n\n @staticmethod\n def get_selected_ids_from_request(request, queryset):\n select_across = request.POST.get(\"select_across\", 0)\n if int(select_across):\n # This is the \"Selected all\" case, we are using the all queryset\n object_ids = list(queryset.values_list(\"id\", flat=True))\n else:\n object_ids = request.POST.getlist(ACTION_CHECKBOX_NAME)\n # Converting the ids list in a comma separated string, to be used\n # in the GET parameters\n return \",\".join(str(id_) for id_ in object_ids)\n\n def base_action_with_redirect(self, request, queryset, viewname):\n ids = self.get_selected_ids_from_request(request, queryset)\n opts = self.model._meta\n preserved_filters = self.get_preserved_filters(request)\n view_url = reverse(f\"admin:{opts.app_label}_{opts.model_name}_{viewname}\")\n url_with_params = \"{}?{}\".format(view_url, urlencode({\"ids\": ids}))\n redirect_url = add_preserved_filters(\n {\"preserved_filters\": preserved_filters, \"opts\": opts}, url_with_params\n )\n return redirect(redirect_url)\n\n @admin.display(description=_(\"Copy the selected objects\"))\n def copy_to(self, request, queryset):\n \"\"\"Copy the selected objects to another Dataspace.\"\"\"\n return self.base_action_with_redirect(request, queryset, \"copy\")\n\n @admin.display(description=_(\"Compare the selected object\"))\n def compare_with(self, request, queryset):\n \"\"\"Compare one selected object with a matching object in another Dataspace.\"\"\"\n return self.base_action_with_redirect(request, queryset, \"compare\")\n\n @admin.display(description=_(\"Check for updates in reference data\"))\n def check_updates_in_reference(self, request, queryset):\n values = queryset.values_list(\"uuid\", \"last_modified_date\")\n\n orm_lookups = [\n models.Q(**{\"uuid\": uuid, \"last_modified_date__gt\": last_modified_date})\n for uuid, last_modified_date in values\n ]\n\n return self.base_check_in_reference_action(request, self.model, orm_lookups)\n\n @admin.display(description=_(\"Check for newer versions in reference data\"))\n def check_newer_version_in_reference(self, request, queryset):\n values = queryset.values_list(\"name\", \"version\")\n\n orm_lookups = [\n models.Q(**{\"name\": name, \"version__gt\": version}) for name, version in values\n ]\n\n return self.base_check_in_reference_action(request, self.model, orm_lookups)\n\n @staticmethod\n def base_check_in_reference_action(request, model_class, orm_lookups):\n reference_dataspace = Dataspace.objects.get_reference()\n if not reference_dataspace or not orm_lookups:\n return\n\n updated_qs = model_class.objects.scope(reference_dataspace).filter(\n reduce(operator.or_, orm_lookups)\n )\n\n params = {DataspaceFilter.parameter_name: reference_dataspace.pk}\n changelist_href = queryset_to_changelist_href(updated_qs, params)\n if changelist_href:\n return redirect(changelist_href)\n\n messages.warning(request, \"No updates available in the reference dataspace.\")\n\n @staticmethod\n def get_changes_details(form):\n \"\"\"\n Introspect a given form to collect the changes details.\n Original values are collected on the DB instance (pre-save value)\n and New values are collected on the form (post-save value)\n \"\"\"\n if not form.instance.pk:\n return {}\n\n model_class = form.instance.__class__\n original_instance = model_class.objects.get(pk=form.instance.pk)\n\n changes_details = []\n # Using form.changed_data to only iterate on updated fields\n for field in form.changed_data:\n original_value = getattr(original_instance, field)\n new_value = getattr(form.instance, field)\n changes_details.append((field, original_value, new_value))\n\n return {form.instance: changes_details}\n\n def save_model(self, request, obj, form, change):\n \"\"\"Set the created_by and last_modified_by fields at save time.\"\"\"\n # This have no impact on save() if the model does not declare those fields.\n obj.last_modified_by = request.user\n if not change:\n obj.created_by = request.user\n\n # Injecting the results in the request for future use in the\n # log_change() method. This content will be used to add the changes\n # details into the notification message.\n # Using an OrderedDict to keep the main instance details first\n # The related objects changes (inlines) are gathered in\n # self.save_formset()\n request.changes_details = OrderedDict()\n if change and CHANGE in self.email_notification_on:\n request.changes_details.update(self.get_changes_details(form))\n\n super().save_model(request, obj, form, change)\n\n def save_formset(self, request, form, formset, change):\n \"\"\"\n Set the Dataspace on the Inline instance before it's saved. Using the\n Dataspace of the Model instance of this ModelAdmin.\n Also craft the change details of the Inlines.\n \"\"\"\n for f in formset.forms:\n # Skip if nothing has changed in the current inline form\n if not f.changed_data:\n continue\n\n # Set the Dataspace on the Inline instance in case of addition of\n # the current inline.\n # The Dataspace is taken from the main form instance.\n if not f.instance.dataspace_id:\n f.instance.dataspace = form.instance.dataspace\n\n # Only in case of a 'change' on the main instance\n if change and CHANGE in self.email_notification_on:\n # As the `change` param is only about the main instance, we use\n # the pk of the inline instance to make sure we are in a\n # MODIFICATION case.\n #\n # If the pk of the inline instance is None, this is an ADDITION,\n # so skip the details creation. Also, if DELETION_FIELD_NAME is\n # in changed_data, we are in an inline deletion case, skipping\n # too.\n if f.instance.pk and DELETION_FIELD_NAME not in f.changed_data:\n # request.changes_details is created in self.save_model()\n request.changes_details.update(self.get_changes_details(f))\n\n super().save_formset(request, form, formset, change)\n\n def delete_model(self, request, obj):\n # We are using this rather than self.log_deletion because it's not called\n # Here, History.log_deletion is called for each object in the bulk.\n History.log_deletion(request.user, obj)\n super().delete_model(request, obj)\n if DELETION in self.email_notification_on:\n send_notification_email(request.user, obj, DELETION)\n\n def delete_queryset(self, request, queryset):\n \"\"\"\n Add the email notification on bulk deletion through the default django\n 'delete_selected' action.\n \"\"\"\n send_notification_email_on_queryset(request.user, queryset, DELETION)\n super().delete_queryset(request, queryset)\n\n def get_urls(self):\n info = self.model._meta.app_label, self.model._meta.model_name\n urls = []\n\n if self.activity_log:\n urls += [\n path(\n \"activity_log/\",\n self.admin_site.admin_view(ActivityLog.as_view(model=self.model)),\n name=\"{}_{}_activity_log\".format(*info),\n )\n ]\n\n actions = getattr(self, \"actions\", [])\n actions_to_remove = getattr(self, \"actions_to_remove\", [])\n\n if \"copy_to\" in actions and \"copy_to\" not in actions_to_remove:\n urls += [\n path(\n \"copy/\",\n self.admin_site.admin_view(object_copy_view),\n name=\"{}_{}_copy\".format(*info),\n ),\n ]\n\n if \"compare_with\" in actions and \"compare_with\" not in actions_to_remove:\n urls += [\n path(\n \"compare/\",\n self.admin_site.admin_view(object_compare_view),\n name=\"{}_{}_compare\".format(*info),\n ),\n ]\n\n if self.importer_class:\n urls += [\n path(\n \"import/\",\n self.admin_site.admin_view(import_view),\n {\"importer_class\": self.importer_class},\n name=\"{}_{}_import\".format(*info),\n ),\n ]\n\n return urls + super().get_urls()\n\n def get_form(self, request, obj=None, **kwargs):\n \"\"\"\n Set the `obj` instance on the `request` for future processing.\n Set the serialized_data of the object on the `request` to be used in the\n `log_change` method.\n Set the `request` on the `form_class`.\n \"\"\"\n if obj:\n request._object = obj\n request._serialized_data = obj.as_json()\n\n form_class = super().get_form(request, obj, **kwargs)\n form_class.request = request\n return form_class\n\n def get_fieldsets(self, request, obj=None):\n \"\"\"Exclude form fields from the ADMIN_FORMS_CONFIGURATION settings.\"\"\"\n fieldsets = super().get_fieldsets(request, obj)\n\n forms_config = settings.ADMIN_FORMS_CONFIGURATION\n if not forms_config:\n return fieldsets\n\n model_config = forms_config.get(self.model._meta.model_name, {})\n exclude = model_config.get(\"exclude\", [])\n if not exclude:\n return fieldsets\n\n fieldsets_with_exclude = []\n for label, entry in fieldsets:\n fields = entry.get(\"fields\")\n if fields:\n entry[\"fields\"] = [field for field in fields if field not in exclude]\n fieldsets_with_exclude.append((label, entry))\n\n return fieldsets_with_exclude\n\n def get_inline_instances(self, request, obj=None):\n \"\"\"Injects the ``request`` in each inline form to be used in validation.\"\"\"\n base_instances = super().get_inline_instances(request, obj)\n\n instances = []\n request._object = obj\n for inline in base_instances:\n inline.form.request = request\n instances.append(inline)\n\n return instances\n\n def get_actions(self, request):\n \"\"\"Limit the available actions based on who you are and what you are looking at.\"\"\"\n if IS_POPUP_VAR in request.GET:\n return OrderedDict()\n\n actions = super().get_actions(request)\n is_user_dataspace = DataspaceFilter.parameter_name not in request.GET\n\n can_mass_update = all(\n [\n self.mass_update_form,\n has_permission(self.model, request.user, \"change\"),\n is_user_dataspace or request.user.dataspace.is_reference,\n ]\n )\n\n if can_mass_update:\n actions[\"mass_update\"] = (mass_update_action, \"mass_update\", \"Mass update\")\n\n if not has_permission(self.model, request.user, \"add\") and \"copy_to\" in actions:\n del actions[\"copy_to\"]\n\n if not request.user.dataspace.is_reference:\n if is_user_dataspace: # The user is looking at his own Dataspace\n if \"copy_to\" in actions:\n del actions[\"copy_to\"]\n if \"compare_with\" in actions:\n del actions[\"compare_with\"]\n else: # The user is looking at another Dataspace\n if \"delete_selected\" in actions:\n del actions[\"delete_selected\"]\n\n if request.user.dataspace.is_reference or not is_user_dataspace:\n if \"check_updates_in_reference\" in actions:\n del actions[\"check_updates_in_reference\"]\n if \"check_newer_version_in_reference\" in actions:\n del actions[\"check_newer_version_in_reference\"]\n\n for action in self.actions_to_remove:\n if action in actions:\n del actions[action]\n\n return actions\n\n @admin.display(description=_(\"Copy to my Dataspace\"))\n def copy_link(self, obj):\n return format_html(\n '<strong><a href=\"{}&{}=1\">{}</a></strong>',\n obj.get_copy_url(),\n IS_POPUP_VAR,\n _(\"Copy to my Dataspace\"),\n )\n\n @staticmethod\n def hide_display_links(request):\n return all(\n [\n DataspaceFilter.parameter_name in request.GET,\n request.GET.get(DataspaceFilter.parameter_name) != str(request.user.dataspace_id),\n ]\n )\n\n def get_list_display(self, request):\n \"\"\"\n Remove the view_on_site and hierarchy links in popup mode.\n Also insert the copy link when looking at another dataspace.\n \"\"\"\n list_display = super().get_list_display(request)\n\n if IS_POPUP_VAR in request.GET:\n list_display = list(list_display)\n if \"changelist_view_on_site\" in list_display:\n list_display.remove(\"changelist_view_on_site\")\n if get_hierarchy_link in list_display:\n list_display.remove(get_hierarchy_link)\n\n if self.hide_display_links(request):\n list_display = list(list_display)\n if \"copy_to\" not in self.actions_to_remove:\n list_display.insert(0, \"copy_link\")\n if get_hierarchy_link in list_display:\n list_display.remove(get_hierarchy_link)\n\n return list_display\n\n def get_list_display_links(self, request, list_display):\n \"\"\"Remove all the display_links when looking at another dataspace.\"\"\"\n if not self.hide_display_links(request):\n return super().get_list_display_links(request, list_display)\n\n def response_change(self, request, obj):\n \"\"\"Add the logic for the \"Save and go to next\" feature.\"\"\"\n next_id = request.POST.get(\"next_id\")\n if \"_next\" in request.POST and next_id:\n opts = self.model._meta\n preserved_filters = self.get_preserved_filters(request)\n\n msg_dict = {\n \"name\": str(opts.verbose_name),\n \"obj\": str(obj),\n }\n msg = 'The {name} \"{obj}\" was changed successfully.'.format(**msg_dict)\n self.message_user(request, msg, messages.SUCCESS)\n\n viewname = f\"admin:{opts.app_label}_{opts.model_name}_change\"\n next_url = reverse(viewname, args=[next_id], current_app=self.admin_site.name)\n redirect_url = add_preserved_filters(\n {\"preserved_filters\": preserved_filters, \"opts\": opts}, next_url\n )\n return redirect(redirect_url)\n\n return super().response_change(request, obj)\n\n def lookup_allowed(self, lookup, value):\n if lookup in [EXTERNAL_SOURCE_LOOKUP]:\n return True\n return super().lookup_allowed(lookup, value)\n\n @staticmethod\n def _limited_permission(request, obj, has_perm):\n # Model permission\n if not has_perm:\n return False\n\n # Object instance permission\n if obj and obj.dataspace_id != request.user.dataspace_id:\n return request.user.dataspace.is_reference\n return True\n\n def has_add_permission(self, request):\n has_perm = super().has_add_permission(request)\n # Do not display the \"Add\" link in filter lookup popup mode\n if IS_FILTER_LOOKUP_VAR in request.GET:\n return False\n return has_perm\n\n def has_change_permission(self, request, obj=None):\n has_perm = super().has_change_permission(request, obj)\n return self._limited_permission(request, obj, has_perm)\n\n def has_delete_permission(self, request, obj=None):\n has_perm = super().has_delete_permission(request, obj)\n return self._limited_permission(request, obj, has_perm)\n\n def has_view_permission(self, request, obj=None):\n has_perm = super().has_view_permission(request, obj)\n return self._limited_permission(request, obj, has_perm)\n\n def has_importer(self):\n \"\"\"Return True if the importer_class has been set.\"\"\"\n if self.importer_class:\n return True\n\n def has_activity_log(self):\n \"\"\"Return True if the activity_log has been set.\"\"\"\n if self.activity_log:\n return True"},{"identifier":"DataspacedFKMixin","path":"dje/admin.py","snippet":"class DataspacedFKMixin:\n \"\"\"\n Limit the QuerySet of ForeignKeys to the current Dataspace,\n or to the parent object in case of Inlines.\n On ADDITION, the Dataspace is taken from the User\n On MODIFICATION, it's taken on the current object instance or parent\n instance in case of Inlines.\n This class can be applied to ModelAdmins and Inlines.\n The declared limit_choices_to on the model field will be respected.\n \"\"\"\n\n # The QuerySet for the fields in this list will be scoped by the Model content_type\n content_type_scope_fields = []\n\n def formfield_for_foreignkey(self, db_field, request=None, **kwargs):\n # If a QuerySet was given in the kwargs of the calling method, we then\n # assume that the filtering was done and we skip further processing.\n qs = kwargs.get(\"queryset\", None)\n if qs is not None:\n return super().formfield_for_foreignkey(db_field, request, **kwargs)\n\n related_model = db_field.related_model\n if is_dataspace_related(related_model):\n # No instance, ADDITION, get dataspace from user\n if not getattr(request, \"_object\", None):\n dataspace = request.user.dataspace\n # Parent instance, MODIFICATION, dataspace from instance\n else:\n dataspace = request._object.dataspace\n\n kwargs[\"queryset\"] = db_field.related_model.objects.scope(dataspace).complex_filter(\n db_field.remote_field.limit_choices_to\n )\n\n if db_field.name in self.content_type_scope_fields:\n kwargs[\"queryset\"] = kwargs[\"queryset\"].filter(\n content_type=ContentType.objects.get_for_model(self.model)\n )\n\n return super().formfield_for_foreignkey(db_field, request, **kwargs)"},{"identifier":"dejacode_site","path":"dje/admin.py","snippet":"EXTERNAL_SOURCE_LOOKUP = \"external_references__external_source_id\"\nADDITION = History.ADDITION\nCHANGE = History.CHANGE\nDELETION = History.DELETION\n HIDDEN_VALUE = \"*******\"\nclass DejaCodeAdminSite(AdminSite):\nclass ReferenceOnlyPermissions:\nclass DataspacedFKMixin:\nclass ProtectedFieldsMixin:\nclass ChangelistPopupPermissionMixin:\nclass ProhibitDataspaceLookupMixin:\nclass AdvancedSearchAdminMixin:\nclass HistoryAdminMixin:\nclass ColoredIconAdminMixin:\n class Media:\nclass DataspacedChangeList(ChangeList):\nclass DataspacedAdmin(\n DataspacedFKMixin,\n ProtectedFieldsMixin,\n AdvancedSearchAdminMixin,\n HistoryAdminMixin,\n admin.ModelAdmin,\n):\nclass HiddenValueWidget(forms.TextInput):\nclass DataspaceConfigurationForm(forms.ModelForm):\nclass DataspaceConfigurationInline(DataspacedFKMixin, admin.StackedInline):\nclass DataspaceAdmin(\n ReferenceOnlyPermissions,\n HistoryAdminMixin,\n admin.ModelAdmin,\n):\nclass ChildRelationshipInline(DataspacedFKMixin, admin.TabularInline):\nclass ExternalReferenceInline(DataspacedFKMixin, GenericTabularInline):\nclass ExternalSourceAdmin(DataspacedAdmin):\nclass DejacodeUserChangeForm(forms.ModelForm):\n class Meta:\nclass DejacodeUserCreationForm(DejacodeUserChangeForm):\nclass DejacodeUserAdmin(\n DataspacedFKMixin,\n AdvancedSearchAdminMixin,\n HistoryAdminMixin,\n UserAdmin,\n):\nclass GroupAdmin(ReferenceOnlyPermissions, HistoryAdminMixin, GroupAdmin):\n class ReferenceAccessAttemptAdmin(ReferenceOnlyPermissions, AccessAttemptAdmin):\n def get_urls(self):\ndef get_hierarchy_link(obj):\ndef get_additional_information_fieldset(pre_fields=None):\n def has_add_permission(self, request):\n def has_change_permission(self, request, obj=None):\n def has_delete_permission(self, request, obj=None):\n def has_view_permission(self, request, obj=None):\n def formfield_for_foreignkey(self, db_field, request=None, **kwargs):\n def get_readonly_fields(self, request, obj=None):\n def has_change_permission(self, request, obj=None):\n def lookup_allowed(self, lookup, value):\n def check(self, **kwargs):\n def get_queryset(self, request):\n def get_search_results(self, request, queryset, search_term):\n def log_addition(self, request, object, change_message=None):\n def log_change(self, request, object, message):\n def log_deletion(self, request, object, object_repr):\n def history_view(self, request, object_id, extra_context=None):\n def colored_icon(self, obj):\n def get_results(self, request):\n def has_filters_activated(self):\n def get_filters_params(self, params=None):\n def set_reference_link(self, request):\n def __init__(self, model, admin_site):\n def check(self, **kwargs):\n def changeform_view_on_site(self, obj):\n def changelist_view_on_site(self, obj):\n def urn_link(self, instance):\n def get_queryset(self, request):\n def get_changelist(self, request, **kwargs):\n def get_list_filter(self, request):\n def get_readonly_fields(self, request, obj=None):\n def change_view(self, request, object_id, form_url=\"\", extra_context=None):\n def render_change_form(self, request, context, add=False, change=False, form_url=\"\", obj=None):\n def get_selected_ids_from_request(request, queryset):\n def base_action_with_redirect(self, request, queryset, viewname):\n def copy_to(self, request, queryset):\n def compare_with(self, request, queryset):\n def check_updates_in_reference(self, request, queryset):\n def check_newer_version_in_reference(self, request, queryset):\n def base_check_in_reference_action(request, model_class, orm_lookups):\n def get_changes_details(form):\n def save_model(self, request, obj, form, change):\n def save_formset(self, request, form, formset, change):\n def delete_model(self, request, obj):\n def delete_queryset(self, request, queryset):\n def get_urls(self):\n def get_form(self, request, obj=None, **kwargs):\n def get_fieldsets(self, request, obj=None):\n def get_inline_instances(self, request, obj=None):\n def get_actions(self, request):\n def copy_link(self, obj):\n def hide_display_links(request):\n def get_list_display(self, request):\n def get_list_display_links(self, request, list_display):\n def response_change(self, request, obj):\n def lookup_allowed(self, lookup, value):\n def _limited_permission(request, obj, has_perm):\n def has_add_permission(self, request):\n def has_change_permission(self, request, obj=None):\n def has_delete_permission(self, request, obj=None):\n def has_view_permission(self, request, obj=None):\n def has_importer(self):\n def has_activity_log(self):\n def render(self, name, value, attrs=None, renderer=None):\n def __init__(self, *args, **kwargs):\n def clean(self):\n def has_change_permission(self, request, obj=None):\n def get_readonly_fields(self, request, obj=None):\n def get_urls(self):\n def get_queryset(self, request):\n def get_actions(self, request):\n def changeform_view(self, request, object_id=None, form_url=\"\", extra_context=None):\n def references(self, obj):\ndef send_activation_email(user, request):\n def __init__(self, *args, **kwargs):\n def save(self, commit=True):\n def get_form(self, request, obj=None, **kwargs):\n def get_queryset(self, request):\n def formfield_for_foreignkey(self, db_field, request=None, **kwargs):\n def user_change_password(self, request, id, form_url=\"\"):\n def get_list_filter(self, request):\n def has_activity_log(self):\n def get_urls(self):\n def log_addition(self, request, object, change_message=None):\n def delete_model(self, request, obj):\n def get_actions(self, request):\n def set_inactive(self, request, queryset):\n def export_as_csv(self, request, queryset):\n def send_activation_email(self, request, object_id):\n def get_queryset(self, request):\n def get_permissions(self, obj):\n def formfield_for_manytomany(self, db_field, request=None, **kwargs):\n def get_urls(self):\n def get_permission_group_mapping():\n def permission_details_view(self, request):\n def permission_export_csv(self, request):\ndef register_axes_admin():"},{"identifier":"get_additional_information_fieldset","path":"dje/admin.py","snippet":"def get_additional_information_fieldset(pre_fields=None):\n fields = (\n \"dataspace\",\n \"uuid\",\n \"created_date\",\n \"created_by\",\n \"last_modified_date\",\n \"last_modified_by\",\n )\n\n if pre_fields:\n fields = pre_fields + fields\n\n return (\"Additional Information\", {\"classes\": (\"grp-collapse grp-closed\",), \"fields\": fields})"},{"identifier":"add_client_data","path":"dje/client_data.py","snippet":"def add_client_data(request, **kwargs):\n \"\"\"\n Set values on the request, to be available in the JavaScript client data object.\n On the client side, the values are accessible through ``NEXB.client_data``.\n \"\"\"\n if not hasattr(request, 'client_data'):\n request.client_data = {}\n request.client_data.update(kwargs)"},{"identifier":"MissingInFilter","path":"dje/filters.py","snippet":"class MissingInFilter(BaseDataspaceLookupsFilter):\n \"\"\"\n Filter by objects missing in the given dataspace, compared with the\n current `DataspaceFilter.parameter_name` or user dataspace.\n Both values for reference and target Dataspace are validated against the\n self.lookup_choices to make sure the user has the proper access permissions.\n This filter is only available to superusers, this is enforced in\n DataspacedAdmin.get_list_filter()\n \"\"\"\n\n title = _(\"missing in\")\n parameter_name = \"missing_in\"\n\n def queryset(self, request, queryset):\n if not self.value():\n return\n\n valid_choices = [str(choice) for choice, _ in self.lookup_choices]\n if str(self.value()) not in valid_choices:\n raise IncorrectLookupParameters()\n\n return queryset.exclude(uuid__in=get_uuids_list_sorted(self.value(), queryset.model))"},{"identifier":"AsJoinList","path":"dje/list_display.py","snippet":"class AsJoinList(ListDisplayItem):\n def __init__(self, name, join_str, **kwargs):\n self.join_str = join_str\n kwargs[\"admin_order_field\"] = None\n super().__init__(name, **kwargs)\n\n def to_representation(self, value):\n return format_html(self.join_str.join(value))"},{"identifier":"AsLink","path":"dje/list_display.py","snippet":"class AsLink(ListDisplayItem):\n def to_representation(self, value):\n return value.get_admin_link(target=\"_blank\")"},{"identifier":"CHANGELIST_LINK_TEMPLATE","path":"dje/utils.py","snippet":"CHANGELIST_LINK_TEMPLATE = (\n '<strong>See the <a href=\"{}\" target=\"_blank\">{} {}</a> in changelist</strong>'\n)"},{"identifier":"queryset_to_html_list","path":"dje/utils.py","snippet":"def queryset_to_html_list(queryset, url_params, qs_limit=None):\n \"\"\"\n Return an HTML <ul> of a given queryset.\n A link to access the full list, in a changelist, of results is added.\n A limit can be specified.\n \"\"\"\n # Using len() to evaluate the qs rather than a count() that will cost an\n # extra query per row.\n count = len(queryset)\n if not count:\n return\n\n opts = queryset.model._meta\n url = reverse(f\"admin:{opts.app_label}_{opts.model_name}_changelist\")\n href = f\"{url}?{urlencode(url_params)}\"\n changelist_link = format_html(CHANGELIST_LINK_TEMPLATE, href, count, opts.verbose_name_plural)\n\n list_items = [\n \"<li>{}</li>\".format(instance.get_admin_link(target=\"_blank\"))\n for instance in queryset[:qs_limit]\n ]\n\n return format_html(\n '<ul class=\"with-disc\">{}</ul>{}', mark_safe(\"\".join(list_items)), changelist_link\n )"},{"identifier":"ReportingQueryListFilter","path":"reporting/filters.py","snippet":"class ReportingQueryListFilter(admin.SimpleListFilter):\n \"\"\"\n Allows to filter a changelist given a reporting.Query instance\n This can only be used on a ModelAdmin for which the Model is supported by\n the reporting app.\n Only available on the user dataspace objects for security reason.\n If `order_fields` are available on this Query, the ordering will be added in\n the filter parameters.\n \"\"\"\n\n title = _(\"reporting query\")\n parameter_name = \"reporting_query\"\n\n def lookups(self, request, model_admin):\n # Limit the availability of this filter to current user dataspace objects\n if DataspaceFilter.parameter_name in request.GET:\n return\n\n query_qs = (\n Query.objects.scope(request.user.dataspace)\n .get_for_model(model_admin.model)\n .prefetch_related(\"order_fields\")\n )\n\n lookups = []\n for query in query_qs:\n param_dict = {\n self.parameter_name: query._get_pk_val(),\n }\n\n ordering_from_query = query.get_order_list_for_url(request, model_admin)\n if ordering_from_query:\n param_dict[ORDER_VAR] = \".\".join(ordering_from_query)\n\n lookups.append((query.name, param_dict))\n\n return lookups\n\n def choices(self, changelist):\n yield {\n \"selected\": self.value() is None,\n \"query_string\": changelist.get_query_string({}, [self.parameter_name, ORDER_VAR]),\n \"display\": _(\"All\"),\n }\n for title, param_dict in self.lookup_choices:\n yield {\n \"selected\": str(param_dict.get(self.parameter_name)) == str(self.value()),\n \"query_string\": changelist.get_query_string(param_dict, [ORDER_VAR]),\n \"display\": title,\n }\n\n def queryset(self, request, queryset):\n if not self.value():\n return queryset\n\n # This filter is only available on the user dataspace objects\n query_instance = get_object_or_404(\n Query,\n pk=self.value(),\n dataspace=request.user.dataspace,\n )\n\n try:\n qs = query_instance.get_qs(user=request.user)\n except Exception as e: # Broad exception as get_qs is fairly unstable\n messages.error(request, f\"{self.title} filter error: {e}\")\n return\n\n msg = f\"{capfirst(self.title)} filter active. Other filters may be ignored.\"\n messages.warning(request, msg)\n\n return qs"},{"identifier":"ColumnTemplateForm","path":"reporting/forms.py","snippet":"class ColumnTemplateForm(CleanContentTypeFormMixin, DataspacedAdminForm):\n class Meta:\n model = ColumnTemplate\n fields = \"__all__\""},{"identifier":"QueryForm","path":"reporting/forms.py","snippet":"class QueryForm(CleanContentTypeFormMixin, DataspacedAdminForm):\n class Meta:\n model = Query\n fields = \"__all__\""},{"identifier":"ReportForm","path":"reporting/forms.py","snippet":"class ReportForm(DataspacedAdminForm):\n class Meta:\n model = Report\n fields = \"__all__\"\n\n def clean(self):\n cleaned_data = super().clean()\n\n query = cleaned_data.get(\"query\")\n column_template = cleaned_data.get(\"column_template\")\n\n if query and column_template:\n # Only do something if both fields are valid so far.\n if query.content_type != column_template.content_type:\n msg = \"The query and column template must have matching object types.\"\n self.add_error(\"query\", msg)\n self.add_error(\"column_template\", msg)\n\n raise ValidationError(\n \"{} The query has an object type of {}. The column \"\n \"template has an object type of {}.\".format(\n msg,\n query.content_type.model_class()._meta.verbose_name,\n column_template.content_type.model_class()._meta.verbose_name,\n )\n )\n\n return cleaned_data"},{"identifier":"ReportMassUpdateForm","path":"reporting/forms.py","snippet":"class ReportMassUpdateForm(DejacodeMassUpdateForm):\n class Meta:\n fields = [\n \"group\",\n ]"},{"identifier":"get_model_data_for_column_template","path":"reporting/forms.py","snippet":"def get_model_data_for_column_template(dataspace=None):\n \"\"\"\n Return a dict-based data structure of the models and their fields available\n in the ColumnTemplate system.\n An optional dataspace can be given, the LicenseTag will not be included\n if the dataspace is not specified.\n \"\"\"\n model_classes = introspector.get_related_models(get_reportable_models())\n model_data = introspector.get_model_data(\n model_classes=model_classes,\n model_whitelist=MODEL_WHITELIST,\n get_m2m=True,\n # Do not display the related many-to-many fields because they don't\n # make sense as selectable columns\n get_related_m2m=False,\n get_related=True,\n get_generic_relation=True,\n field_whitelist=FIELDS_WHITELIST,\n )\n\n # Extend model_data with some properties\n extended_model_data = {\n \"component_catalog:component\": {\n \"Properties\": [\n \"urn\",\n \"details_url\",\n \"primary_license\",\n \"attribution_required\",\n \"redistribution_required\",\n \"change_tracking_required\",\n \"where_used\",\n ],\n },\n \"component_catalog:package\": {\n \"Properties\": [\n \"identifier\",\n \"urn\",\n \"details_url\",\n \"primary_license\",\n \"attribution_required\",\n \"redistribution_required\",\n \"change_tracking_required\",\n \"package_url\",\n \"short_package_url\",\n \"where_used\",\n \"inferred_url\",\n ],\n },\n \"license_library:license\": {\n \"Properties\": [\n \"urn\",\n \"details_url\",\n \"spdx_url\",\n \"attribution_required\",\n \"redistribution_required\",\n \"change_tracking_required\",\n \"where_used\",\n \"language_code\",\n ],\n },\n \"organization:owner\": {\n \"Properties\": [\n \"urn\",\n ],\n },\n \"workflow:request\": {\n \"Properties\": [\n \"serialized_data_html\",\n \"details_url\",\n \"content_object\",\n ],\n },\n }\n\n if dataspace:\n qs = LicenseTag.objects.scope(dataspace)\n extended_model_data[\"license_library:license\"].update(\n {\n \"License Tags\": [f\"{LICENSE_TAG_PREFIX}{tag.label}\" for tag in qs],\n }\n )\n\n for model in get_reportable_models():\n model_label = get_model_label(model)\n\n if model_label not in model_data:\n continue\n\n fields = model_data[model_label][\"fields\"]\n grouped_fields = model_data[model_label][\"grouped_fields\"]\n meta = model_data[model_label][\"meta\"]\n extra_groups = []\n\n for group, labels in extended_model_data.get(model_label, {}).items():\n for label in labels:\n fields.append(label)\n meta[label] = {}\n extra_groups.append({\"group\": group, \"label\": label, \"value\": label})\n\n grouped_fields.extend(extra_groups)\n\n return model_data"},{"identifier":"get_model_data_for_order_field","path":"reporting/forms.py","snippet":"@functools.lru_cache(maxsize=None)\ndef get_model_data_for_order_field():\n \"\"\"\n Return a dict-based data structure of the models and their fields available\n in the OrderField system.\n \"\"\"\n model_classes = get_reportable_models()\n return introspector.get_model_data(\n model_classes=model_classes,\n model_whitelist=MODEL_WHITELIST,\n omit_foreign_key_fields=False,\n get_m2m=False,\n get_related_m2m=False,\n get_related=False,\n get_generic_relation=False,\n field_whitelist=FIELDS_WHITELIST,\n )"},{"identifier":"get_model_data_for_query","path":"reporting/forms.py","snippet":"@functools.lru_cache(maxsize=None)\ndef get_model_data_for_query():\n \"\"\"\n Return a dict-based data structure of the models and their fields available\n in the Query system.\n \"\"\"\n model_classes = introspector.get_related_models(get_reportable_models())\n return introspector.get_model_data(\n model_classes=model_classes,\n model_whitelist=MODEL_WHITELIST,\n get_m2m=True,\n # Do not display the related many-to-many fields because there is no\n # need to query against them\n get_related_m2m=False,\n get_related=True,\n get_generic_relation=True,\n field_whitelist=FIELDS_WHITELIST,\n )"},{"identifier":"ColumnTemplateAssignedFieldInline","path":"reporting/inlines.py","snippet":"class ColumnTemplateAssignedFieldInline(admin.TabularInline):\n model = ColumnTemplateAssignedField\n # Delegate to the Ember-based inline UI the responsibility of rendering, so\n # instantiate 0 extra forms\n extra = 0\n formset = ColumnTemplateAssignedFieldFormSet\n\n def get_formset(self, request, obj=None, **kwargs):\n \"\"\"\n Injecting the request in the FormSets, required for the validation in\n ColumnTemplateAssignedFieldFormSet.clean()\n \"\"\"\n FormSet = super().get_formset(request, obj, **kwargs)\n FormSet._request = request\n return FormSet"},{"identifier":"FilterInline","path":"reporting/inlines.py","snippet":"class FilterInline(admin.TabularInline):\n model = Filter\n fk_name = \"query\"\n # Delegate to the Ember-based inline UI the responsibility of rendering, so\n # instantiate 0 extra forms\n extra = 0\n form = FilterForm"},{"identifier":"OrderFieldInline","path":"reporting/inlines.py","snippet":"class OrderFieldInline(admin.TabularInline):\n model = OrderField\n fk_name = \"query\"\n # Delegate to the Ember-based inline UI the responsibility of rendering, so\n # instantiate 0 extra forms\n extra = 0\n form = OrderFieldForm"},{"identifier":"get_model_label","path":"reporting/introspection.py","snippet":"def get_model_label(model):\n return f\"{model._meta.app_label}:{model._meta.model_name}\""},{"identifier":"Card","path":"reporting/models.py","snippet":"class Card(HistoryFieldsMixin, DataspacedModel):\n title = models.CharField(\n max_length=1024,\n help_text=_(\"A concise and unique description of your Card.\"),\n )\n query = models.ForeignKey(\n to=\"reporting.Query\",\n on_delete=models.CASCADE,\n related_name=\"cards\",\n help_text=_(\n \"The Query that obtains the data to show in the Card. \"\n \"The best kind of Query for this purpose is one that filters by a \"\n \"status or a modification date, in order to alert the user to \"\n \"recent activity that may need reviewing.\"\n ),\n )\n number_of_results = models.PositiveSmallIntegerField(\n default=5,\n help_text=_(\"The number of results to display in the Card.\"),\n )\n display_changelist_link = models.BooleanField(\n default=False,\n help_text=_(\"Display a link to the filtered changelist for admin users.\"),\n )\n\n class Meta:\n unique_together = (\"dataspace\", \"title\")\n ordering = [\"title\"]\n\n def __str__(self):\n return self.title\n\n def get_object_list(self, user):\n qs = self.query.get_qs(user=user)[: self.number_of_results]\n return [obj.get_absolute_link() or obj for obj in qs]"},{"identifier":"CardLayout","path":"reporting/models.py","snippet":"class CardLayout(HistoryFieldsMixin, DataspacedModel):\n name = models.CharField(\n max_length=100,\n help_text=_(\n \"A concise and unique description of the Card layout that indicates \"\n \"the theme or purpose of the layout.\"\n ),\n )\n cards = models.ManyToManyField(\n to=\"reporting.Card\",\n through=\"reporting.LayoutAssignedCard\",\n )\n\n class Meta:\n unique_together = (\"dataspace\", \"name\")\n ordering = [\"name\"]\n\n def __str__(self):\n return self.name\n\n def get_ordered_cards(self):\n \"\"\"Return the Cards of this Layout ordered by sequence.\"\"\"\n return self.cards.all().order_by(\"layoutassignedcard__seq\")\n\n @property\n def cards_title(self):\n return [card.title for card in self.get_ordered_cards()]\n\n def cards_with_objects(self, user):\n cards = self.get_ordered_cards()\n for card in cards:\n card.object_list = card.get_object_list(user=user)\n\n return cards"},{"identifier":"ColumnTemplate","path":"reporting/models.py","snippet":"class ColumnTemplate(HistoryFieldsMixin, DataspacedModel):\n name = models.CharField(\n max_length=100,\n help_text=_(\"A unique, descriptive title for your column template.\"),\n )\n\n description = models.TextField(\n blank=True,\n help_text=_(\"The purpose of your column template.\"),\n )\n\n content_type = models.ForeignKey(\n to=ContentType,\n limit_choices_to=CT_LIMIT,\n on_delete=models.PROTECT,\n verbose_name=_(\"object type\"),\n help_text=_(\n \"Choose the primary data source for your column template: \"\n \"licenses, components, or owners.\"\n ),\n )\n\n class Meta:\n unique_together = (\n (\"dataspace\", \"name\"),\n (\"dataspace\", \"uuid\"),\n )\n ordering = (\"name\",)\n\n def __str__(self):\n return f\"{self.name} ({self.content_type.model})\"\n\n def is_valid(self):\n \"\"\"Return True each fields of the ColumnTemplate is valid.\"\"\"\n return all(field.is_valid() for field in self.fields.all())\n\n def get_model_class(self):\n return self.content_type.model_class()\n\n @staticmethod\n def get_extra_relational_fields():\n return [\"fields\"]\n\n def as_headers(self, include_view_link=False):\n \"\"\"Return a list of field name, usable as Report results headers.\"\"\"\n headers = [field.display_name or field.field_name for field in self.fields.all()]\n if include_view_link:\n headers.insert(0, format_html(\" \"))\n return headers"},{"identifier":"Filter","path":"reporting/models.py","snippet":"class Filter(DataspacedModel):\n query = models.ForeignKey(\n to=\"reporting.Query\",\n on_delete=models.CASCADE,\n related_name=\"filters\",\n )\n\n field_name = models.TextField()\n\n LOOKUP_CHOICES = (\n (\"exact\", \"Exact match. (e.g.: apache-2.0)\"),\n (\"iexact\", \"Case-insensitive exact match. (e.g.: APACHE-2.0)\"),\n (\"contains\", \"Case-sensitive containment test. (e.g.: apache)\"),\n (\"icontains\", \"Case-insensitive containment test. (e.g.: Apache)\"),\n (\"in\", 'In a given list. (e.g.: [\"apache-1.1\", \"apache-2.0\"])'),\n (\"startswith\", \"Case-sensitive starts-with.\"),\n (\"istartswith\", \"Case-insensitive starts-with.\"),\n (\"endswith\", \"Case-sensitive ends-with.\"),\n (\"iendswith\", \"Case-insensitive ends-with.\"),\n (\"gt\", \"Greater than.\"),\n (\"gte\", \"Greater than or equal to.\"),\n (\"lt\", \"Less than.\"),\n (\"lte\", \"Less than or equal to.\"),\n (\"year\", \"Exact year match.\"),\n (\"month\", \"Exact month match.\"),\n (\"day\", \"Exact day match.\"),\n (\"isnull\", \"IS NULL. Takes either True or False.\"),\n (\"isempty\", \"IS EMPTY. Takes either True or False.\"),\n (\"regex\", 'Case-sensitive regular expression match. (e.g.: r\"^(A?)+\")'),\n (\"descendant\", \"Hierarchy traversal: Descendant of (id). (e.g.: 1337)\"),\n (\n \"product_descendant\",\n \"Product Hierarchy traversal. Takes product identifier name:version or id\",\n ),\n )\n\n lookup = models.CharField(\n max_length=30,\n choices=LOOKUP_CHOICES,\n )\n\n value = models.TextField(\n blank=True,\n )\n\n runtime_parameter = models.BooleanField(\n default=False,\n )\n\n negate = models.BooleanField(\n default=False,\n help_text=(\n 'Check to negate this lookup, as in \"does NOT match\". '\n \"This can be combined with regular lookups.\"\n ),\n )\n\n class Meta:\n unique_together = (\"dataspace\", \"uuid\")\n ordering = (\"pk\",)\n\n def __str__(self):\n return f\"{self.field_name} {self.lookup} {self.value}\"\n\n def save(self, *args, **kwargs):\n self.dataspace = self.query.dataspace\n super().save(*args, **kwargs)\n\n def get_coerced_value(self, value):\n \"\"\"\n Return a Python object that corresponds to ``value``. This is\n accomplished by introspecting fields of models and using their\n corresponding form fields to convert strings to Python objects.\n\n For example, the value 'True' for a ``BooleanField`` is coerced to True.\n \"\"\"\n field_parts = self.field_name.split(\"__\") # Split field into list\n\n # Use the field parts to derive the model field instance\n model = self.query.get_model()\n query_name_map = introspector.get_query_name_map(\n model_class=model,\n get_fields=True,\n get_m2m=True,\n get_related_m2m=True,\n get_related=True,\n get_generic_relation=True,\n )\n for index, part in enumerate(field_parts):\n if index == len(field_parts) - 1:\n final_part = field_parts[-1]\n model_field_instance = model._meta.get_field(final_part)\n\n # For non-RelatedFields use the model field's form field to\n # coerce the value to a Python object\n if not isinstance(model_field_instance, RelatedField):\n # Skip validation for containment filters since the value may not be valid.\n if self.lookup in [\"contains\", \"icontains\"]:\n return value\n # Runs the Field.clean() method to validate the value, this\n # is required to run the custom validators declared on the\n # Model field.\n model_field_instance.clean(value, model)\n # We must check if ``fields_for_model()`` Return the field\n # we are considering. For example ``AutoField`` returns\n # None for its form field and thus will not be in the\n # dictionary returned by ``fields_for_model()``.\n form_field_instance = fields_for_model(model).get(final_part)\n if form_field_instance:\n widget_value = form_field_instance.widget.value_from_datadict(\n data={final_part: value}, files={}, name=final_part\n )\n # Set ``required`` to False to allow empty values\n form_field_instance.required = False\n return form_field_instance.clean(widget_value)\n else:\n return value\n elif part in query_name_map:\n # Set the next model and query name map to work with\n model = query_name_map[part]\n query_name_map = introspector.get_query_name_map(\n model_class=model,\n get_fields=True,\n get_m2m=True,\n get_related_m2m=True,\n get_related=True,\n get_generic_relation=True,\n )\n return value\n\n def get_value_as_list(self, value):\n try:\n # `ast.literal_eval()` allows to safely evaluate Python expressions\n return ast.literal_eval(value)\n except SyntaxError:\n return []\n\n def get_q(self, runtime_value=None, user=None):\n value = runtime_value or self.value\n if not value:\n return\n\n if value == BooleanSelect.ALL_CHOICE_VALUE:\n return\n\n # Hack to support special values for date filtering, see #9049\n if value in [choice[0] for choice in DATE_FILTER_CHOICES]:\n value = DateFieldFilterSelect().value_from_datadict(\n data={\"value\": value}, files=None, name=\"value\"\n )\n\n left_hand_side = f\"{self.field_name}__{self.lookup}\"\n\n # The in lookup is special because it must parse a comma-separated string\n if self.lookup == \"in\":\n right_hand_side = self.get_value_as_list(value)\n\n elif self.lookup == \"descendant\":\n model_class = self.query.content_type.model_class()\n root_instance = get_by_reporting_key(model_class, self.dataspace, value)\n if not root_instance:\n return\n left_hand_side = \"id__in\"\n right_hand_side = root_instance.get_descendant_ids()\n\n elif self.lookup == \"product_descendant\":\n from product_portfolio.models import Product\n\n # Requires a `user` to be provided for secured Product scoping\n product_secured_qs = Product.objects.get_queryset(user)\n product = get_by_reporting_key(product_secured_qs, self.dataspace, value)\n if not product:\n return\n left_hand_side = \"id__in\"\n right_hand_side = product.get_merged_descendant_ids()\n\n elif self.lookup == \"isnull\":\n right_hand_side = ISNULL_LOOKUP_CHOICES.get(value, None)\n # WARNING '== None' matters as False is a valid value!\n if right_hand_side is None:\n return\n\n elif self.lookup == \"isempty\":\n if bool(ISNULL_LOOKUP_CHOICES.get(value, False)):\n left_hand_side = f\"{self.field_name}__in\"\n right_hand_side = [\"\", [], {}] # Support for JSONfield\n else:\n # Using \"greater than\" as a workaround to filter by non-empty values.\n left_hand_side = f\"{self.field_name}__gt\"\n right_hand_side = \"\"\n\n elif value == \"None\":\n right_hand_side = None\n\n else:\n right_hand_side = self.get_coerced_value(value)\n\n q_object = Q(**{left_hand_side: right_hand_side})\n\n return ~q_object if self.negate else q_object"},{"identifier":"LayoutAssignedCard","path":"reporting/models.py","snippet":"class LayoutAssignedCard(DataspacedModel):\n layout = models.ForeignKey(\n \"reporting.CardLayout\",\n on_delete=models.CASCADE,\n )\n card = models.ForeignKey(\n \"reporting.Card\",\n on_delete=models.CASCADE,\n )\n seq = models.PositiveSmallIntegerField(\n default=0,\n db_index=True,\n )\n\n class Meta:\n unique_together = (\"dataspace\", \"uuid\")\n ordering = [\"seq\"]"},{"identifier":"OrderField","path":"reporting/models.py","snippet":"class OrderField(DataspacedModel):\n query = models.ForeignKey(\n to=\"reporting.Query\",\n on_delete=models.CASCADE,\n related_name=\"order_fields\",\n )\n\n field_name = models.TextField()\n\n SORT_CHOICES = (\n (\"ascending\", \"ascending\"),\n (\"descending\", \"descending\"),\n )\n\n sort = models.TextField(\n choices=SORT_CHOICES,\n default=\"ascending\",\n )\n\n seq = models.PositiveSmallIntegerField()\n\n class Meta:\n unique_together = (\"dataspace\", \"uuid\")\n ordering = (\"seq\",)\n\n def __str__(self):\n return f\"<{self.query.name}>: ({self.seq}) {self.field_name} {self.sort}\"\n\n def save(self, *args, **kwargs):\n self.dataspace = self.query.dataspace\n super().save(*args, **kwargs)"},{"identifier":"Query","path":"reporting/models.py","snippet":"class Query(HistoryFieldsMixin, DataspacedModel):\n name = models.CharField(\n max_length=100,\n help_text=_(\"A unique, descriptive title for your query.\"),\n )\n\n description = models.TextField(\n blank=True,\n help_text=_(\"The purpose of your query.\"),\n )\n\n content_type = models.ForeignKey(\n to=ContentType,\n on_delete=models.PROTECT,\n limit_choices_to=CT_LIMIT,\n verbose_name=_(\"object type\"),\n help_text=_(\n \"Choose the primary data source for your query: licenses, components, \" \"or owners.\"\n ),\n )\n\n OPERATOR_CHOICES = (\n (\"and\", \"and\"),\n (\"or\", \"or\"),\n )\n\n operator = models.CharField(\n max_length=5,\n choices=OPERATOR_CHOICES,\n default=\"and\",\n help_text=_(\n \"If you define more that one Filter for your query, indicate \"\n 'if all (\"and\") or any (\"or\") of the Filter conditions must be true.'\n ),\n )\n\n objects = DataspacedManager.from_queryset(QueryQuerySet)()\n\n class Meta:\n unique_together = ((\"dataspace\", \"name\"), (\"dataspace\", \"uuid\"))\n ordering = (\"name\",)\n verbose_name_plural = _(\"queries\")\n\n def __str__(self):\n return f\"{self.name} ({self.content_type.model})\"\n\n def get_model(self):\n return self.content_type.model_class()\n\n def get_qs(self, runtime_value_map=None, user=None):\n \"\"\"\n Return a QuerySet created using the assigned Filters.\n The returned QuerySet is not yet evaluated.\n Providing `user` is required for \"secured\" Model Managers.\n \"\"\"\n if runtime_value_map is None:\n runtime_value_map = {}\n\n model = self.get_model()\n manager = model._default_manager\n\n q_objects = []\n for filter_ in self.filters.all():\n runtime_value = runtime_value_map.get(filter_, {}).get(\"value\", None)\n q_object = filter_.get_q(runtime_value, user)\n if q_object:\n q_objects.append(q_object)\n\n if not q_objects: # Return nothing rather than everything when no valid filters\n return manager.none()\n\n order_fields = []\n for order_field in self.order_fields.all():\n prefix = \"-\" if order_field.sort == \"descending\" else \"\"\n order_fields.append(f\"{prefix}{order_field.field_name}\")\n\n if not order_fields: # Force order by primary_key to prevent UnorderedObjectListWarning\n order_fields = [model._meta.pk.name]\n\n if is_secured(manager):\n qs = manager.get_queryset(user)\n elif hasattr(manager, \"product_secured\"): # Special case for the Request manager\n qs = manager.product_secured(user)\n else:\n qs = manager.scope(self.dataspace)\n\n qs = secure_queryset_relational_fields(qs, user)\n\n operator_type = operator.or_ if self.operator == \"or\" else operator.and_\n return qs.filter(reduce(operator_type, q_objects)).order_by(*order_fields).distinct()\n\n def is_valid(self):\n \"\"\"Return True if the Query can be executed without any Exceptions.\"\"\"\n # Warning: do not use count() or exists() since it bypass the validation for order_by()\n # Forcing evaluation with len() but slicing with [:1] for performance\n try:\n len(self.get_qs()[:1])\n except Exception:\n return False\n return True\n\n @staticmethod\n def get_extra_relational_fields():\n return [\"filters\", \"order_fields\"]\n\n def get_order_list_for_url(self, request, model_admin):\n \"\"\"\n Use the order_fields set on the Query instance with the list_display\n of the Query.content_type ModelAdmin class to generate Order\n parameters in the changelist link. If an order_field is not part of\n the list_display of the target changelist, it will be ignored.\n \"\"\"\n list_display = get_changelist_list_display(request, model_admin)\n list_display_order_fields = [\n get_ordering_field(model_admin, field_name) for field_name in list_display\n ]\n\n order_list = []\n for order_field in self.order_fields.all():\n if order_field.field_name in list_display_order_fields:\n index = list_display_order_fields.index(order_field.field_name)\n prefix = \"-\" if order_field.sort == \"descending\" else \"\"\n order_list.append(f\"{prefix}{index}\")\n\n return order_list\n\n def get_changelist_url(self):\n \"\"\"Return the changelist URL of the related Model.\"\"\"\n opts = self.get_model()._meta\n with suppress(NoReverseMatch):\n return reverse(f\"admin:{opts.app_label}_{opts.model_name}_changelist\")\n\n def get_changelist_url_with_filters(self):\n \"\"\"Return the changelist URL of the related Model including a filter for this Query.\"\"\"\n from reporting.filters import ReportingQueryListFilter\n\n params = {ReportingQueryListFilter.parameter_name: self.id}\n url = self.get_changelist_url()\n if url:\n return f\"{url}?{urlencode(params)}\""},{"identifier":"Report","path":"reporting/models.py","snippet":"class Report(HistoryFieldsMixin, DataspacedModel):\n name = models.CharField(\n max_length=100,\n help_text=_(\"The title of your Report.\"),\n )\n\n description = models.TextField(\n blank=True,\n help_text=_(\n \"Provide a description of the report to explain its purpose \" \"to DejaCode users.\"\n ),\n )\n\n query = models.ForeignKey(\n to=\"reporting.Query\",\n on_delete=models.PROTECT,\n help_text=_(\"Choose one of your Queries to select the data for your report.\"),\n )\n\n column_template = models.ForeignKey(\n to=\"reporting.ColumnTemplate\",\n on_delete=models.PROTECT,\n help_text=_(\n \"Choose one of your Column templates to define the data \" \"columns for your report.\"\n ),\n )\n\n user_available = models.BooleanField(\n default=False,\n help_text=_(\"Check this to provide access to non-administrative application users.\"),\n )\n\n report_context = models.TextField(\n blank=True,\n default=\"This DejaCode report was generated from Dataspace \"\n \"{{dataspace}} on {{date-time}} by {{user}}.\",\n help_text=_(\n \"The text in this field will appear at the top of your generated \"\n \"report. You may want to describe the purpose of the report in this field.\"\n ),\n )\n\n group = models.CharField(\n max_length=100,\n blank=True,\n help_text=_(\"Use this field to group reports.\"),\n )\n\n objects = DataspacedManager.from_queryset(ReportQuerySet)()\n\n class Meta:\n unique_together = ((\"dataspace\", \"name\"), (\"dataspace\", \"uuid\"))\n ordering = (\"name\",)\n\n def __str__(self):\n return self.name\n\n def save(self, *args, **kwargs):\n self.dataspace = self.query.dataspace\n super().save(*args, **kwargs)\n\n def get_absolute_url(self):\n return reverse(\"reporting:report_details\", args=[self.uuid])\n\n def get_output(self, queryset=None, user=None, include_view_link=False):\n # Checking if the parameter is given rather than the boolean value of the QuerySet\n if queryset is None:\n queryset = self.query.get_qs(user=user)\n\n icon = format_html('<i class=\"fas fa-external-link-alt\"></i>')\n rows = []\n for instance in queryset:\n cells = [\n field.get_value_for_instance(instance, user=user)\n for field in self.column_template.fields.all()\n ]\n if include_view_link:\n cells.insert(\n 0, instance.get_absolute_link(value=icon, title=\"View\", target=\"_blank\")\n )\n rows.append(cells)\n return rows"}],"string":"[\n {\n \"identifier\": \"DataspacedAdmin\",\n \"path\": \"dje/admin.py\",\n \"snippet\": \"class DataspacedAdmin(\\n DataspacedFKMixin,\\n ProtectedFieldsMixin,\\n AdvancedSearchAdminMixin,\\n HistoryAdminMixin,\\n admin.ModelAdmin,\\n):\\n formfield_overrides = {\\n models.DateField: {\\\"widget\\\": AdminDateWidget(attrs={\\\"placeholder\\\": \\\"YYYY-MM-DD\\\"})},\\n }\\n list_filter = (DataspaceFilter,)\\n readonly_fields = (\\n \\\"dataspace\\\",\\n \\\"uuid\\\",\\n )\\n actions = [\\\"copy_to\\\", \\\"compare_with\\\"]\\n actions_to_remove = []\\n email_notification_on = [ADDITION, CHANGE, DELETION]\\n save_as = True\\n\\n # Display only the current count\\n show_full_result_count = False\\n\\n # Display a warning if any of the identifier_fields has changed\\n identifier_fields_warning = True\\n\\n # Default form, customized form should always extend DataspacedAdminForm\\n form = DataspacedAdminForm\\n\\n # Using extended version of base templates to avoid code duplication\\n change_form_template = \\\"admin/change_form_extended.html\\\"\\n change_list_template = \\\"admin/change_list_extended.html\\\"\\n\\n # Set this to a BaseImporter extension of the Model to enable the import\\n importer_class = None\\n\\n # Set this to a DejacodeMassUpdateForm to enable the mass update action\\n mass_update_form = None\\n\\n # Set this to False to disable the Activity Log feature\\n activity_log = True\\n\\n # Set this to True to enable the Previous and Next buttons in change view\\n navigation_buttons = False\\n\\n preserve_filters = True\\n\\n # Do not display the View on site links by default\\n # Set: view_on_site = DataspacedAdmin.changeform_view_on_site\\n # for the default obj.get_absolute_url()\\n view_on_site = False\\n\\n def __init__(self, model, admin_site):\\n self.form.admin_site = admin_site\\n super().__init__(model, admin_site)\\n\\n def check(self, **kwargs):\\n errors = super().check(**kwargs)\\n\\n has_wrong_form_subclass = all(\\n [\\n not issubclass(self.form, DataspacedAdminForm),\\n self.model._meta.unique_together != ((\\\"dataspace\\\", \\\"uuid\\\"),),\\n ]\\n )\\n\\n if has_wrong_form_subclass:\\n errors.extend(\\n [checks.Error(f\\\"{self.form} is not a subclass of {DataspacedAdminForm}\\\", obj=self)]\\n )\\n\\n return errors\\n\\n def changeform_view_on_site(self, obj):\\n return obj.get_absolute_url()\\n\\n @admin.display(description=_(\\\"View\\\"))\\n def changelist_view_on_site(self, obj):\\n return format_html('<a href=\\\"{}\\\" target=\\\"_blank\\\">View</a>', obj.get_absolute_url())\\n\\n @admin.display(description=_(\\\"URN\\\"))\\n def urn_link(self, instance):\\n \\\"\\\"\\\"Attach the URN link if URN is supported on the Model.\\\"\\\"\\\"\\n if instance.pk:\\n return instance.urn_link\\n return f\\\"URN will be available once the {instance._meta.verbose_name} is saved.\\\"\\n\\n def get_queryset(self, request):\\n qs = super().get_queryset(request)\\n return qs.scope_for_user_in_admin(request.user)\\n\\n def get_changelist(self, request, **kwargs):\\n return DataspacedChangeList\\n\\n def get_list_filter(self, request):\\n \\\"\\\"\\\"Limit the availability of `MissingInFilter` to superusers.\\\"\\\"\\\"\\n list_filter = list(super().get_list_filter(request))\\n\\n if not request.user.is_superuser and MissingInFilter in list_filter:\\n del list_filter[list_filter.index(MissingInFilter)]\\n\\n # Custom LogEntry-based filters when field not available on the model\\n history_filters = {\\n \\\"created_by\\\": CreatedByListFilter,\\n \\\"last_modified_by\\\": None,\\n \\\"created_date\\\": HistoryCreatedActionTimeListFilter,\\n \\\"last_modified_date\\\": HistoryModifiedActionTimeListFilter,\\n }\\n\\n for field_name, default_filter in history_filters.items():\\n try:\\n field = self.model._meta.get_field(field_name)\\n except FieldDoesNotExist:\\n if default_filter:\\n list_filter.append(default_filter)\\n continue\\n\\n filtr = field_name\\n if isinstance(field, models.ForeignKey):\\n filtr = (field_name, LimitToDataspaceListFilter)\\n list_filter.append(filtr)\\n\\n return list_filter\\n\\n def get_readonly_fields(self, request, obj=None):\\n readonly_fields = super().get_readonly_fields(request, obj)\\n\\n if issubclass(self.model, HistoryFieldsMixin):\\n readonly_fields += (\\n \\\"created_date\\\",\\n \\\"created_by\\\",\\n \\\"last_modified_date\\\",\\n \\\"last_modified_by\\\",\\n )\\n\\n return readonly_fields\\n\\n def change_view(self, request, object_id, form_url=\\\"\\\", extra_context=None):\\n \\\"\\\"\\\"\\n Render the changelist using the current preserved filters to gather the\\n previous and next id.\\n \\\"\\\"\\\"\\n context = extra_context or {}\\n\\n # WARNING: request.GET is important as a condition since we do not want to run this\\n # expensive operation in case no given filter/search/sort is applied.\\n # For example when the admin form is reached directly from the user details view.\\n if self.navigation_buttons and request.method == \\\"GET\\\" and request.GET:\\n fake_request = copy(request)\\n query_dict = fake_request.GET.copy()\\n preserved_filters = query_dict.pop(\\\"_changelist_filters\\\", \\\"\\\")\\n if preserved_filters:\\n preserved_filters = force_str(preserved_filters[0])\\n fake_request.GET = QueryDict(preserved_filters)\\n changelist_view = self.changelist_view(fake_request)\\n\\n # Sanity check, if the _changelist_filters were manually changed for example.\\n if hasattr(changelist_view, \\\"context_data\\\"):\\n # Do not use \\\".values_list('id', flat=True)\\\" to avoid an extra query\\n ids_list = [str(obj.id) for obj in changelist_view.context_data[\\\"cl\\\"].result_list]\\n previous_id, next_id = get_previous_next(ids_list, str(object_id))\\n context.update(\\n {\\n \\\"previous_id\\\": previous_id,\\n \\\"next_id\\\": next_id,\\n }\\n )\\n\\n if self.save_as and self.identifier_fields_warning:\\n identifier_fields = self.model.get_identifier_fields()\\n context[\\\"identifier_fields\\\"] = identifier_fields\\n\\n return super().change_view(request, object_id, form_url, context)\\n\\n def render_change_form(self, request, context, add=False, change=False, form_url=\\\"\\\", obj=None):\\n response = super().render_change_form(request, context, add, change, form_url, obj)\\n # De-activating the 'Save as' option if the user is editing an Object\\n # belonging to another Dataspace.\\n # We are able to update the context_data at that point as the\\n # TemplateResponse as not been rendered yet.\\n if obj and obj.dataspace != request.user.dataspace:\\n response.context_data[\\\"save_as\\\"] = False\\n return response\\n\\n @staticmethod\\n def get_selected_ids_from_request(request, queryset):\\n select_across = request.POST.get(\\\"select_across\\\", 0)\\n if int(select_across):\\n # This is the \\\"Selected all\\\" case, we are using the all queryset\\n object_ids = list(queryset.values_list(\\\"id\\\", flat=True))\\n else:\\n object_ids = request.POST.getlist(ACTION_CHECKBOX_NAME)\\n # Converting the ids list in a comma separated string, to be used\\n # in the GET parameters\\n return \\\",\\\".join(str(id_) for id_ in object_ids)\\n\\n def base_action_with_redirect(self, request, queryset, viewname):\\n ids = self.get_selected_ids_from_request(request, queryset)\\n opts = self.model._meta\\n preserved_filters = self.get_preserved_filters(request)\\n view_url = reverse(f\\\"admin:{opts.app_label}_{opts.model_name}_{viewname}\\\")\\n url_with_params = \\\"{}?{}\\\".format(view_url, urlencode({\\\"ids\\\": ids}))\\n redirect_url = add_preserved_filters(\\n {\\\"preserved_filters\\\": preserved_filters, \\\"opts\\\": opts}, url_with_params\\n )\\n return redirect(redirect_url)\\n\\n @admin.display(description=_(\\\"Copy the selected objects\\\"))\\n def copy_to(self, request, queryset):\\n \\\"\\\"\\\"Copy the selected objects to another Dataspace.\\\"\\\"\\\"\\n return self.base_action_with_redirect(request, queryset, \\\"copy\\\")\\n\\n @admin.display(description=_(\\\"Compare the selected object\\\"))\\n def compare_with(self, request, queryset):\\n \\\"\\\"\\\"Compare one selected object with a matching object in another Dataspace.\\\"\\\"\\\"\\n return self.base_action_with_redirect(request, queryset, \\\"compare\\\")\\n\\n @admin.display(description=_(\\\"Check for updates in reference data\\\"))\\n def check_updates_in_reference(self, request, queryset):\\n values = queryset.values_list(\\\"uuid\\\", \\\"last_modified_date\\\")\\n\\n orm_lookups = [\\n models.Q(**{\\\"uuid\\\": uuid, \\\"last_modified_date__gt\\\": last_modified_date})\\n for uuid, last_modified_date in values\\n ]\\n\\n return self.base_check_in_reference_action(request, self.model, orm_lookups)\\n\\n @admin.display(description=_(\\\"Check for newer versions in reference data\\\"))\\n def check_newer_version_in_reference(self, request, queryset):\\n values = queryset.values_list(\\\"name\\\", \\\"version\\\")\\n\\n orm_lookups = [\\n models.Q(**{\\\"name\\\": name, \\\"version__gt\\\": version}) for name, version in values\\n ]\\n\\n return self.base_check_in_reference_action(request, self.model, orm_lookups)\\n\\n @staticmethod\\n def base_check_in_reference_action(request, model_class, orm_lookups):\\n reference_dataspace = Dataspace.objects.get_reference()\\n if not reference_dataspace or not orm_lookups:\\n return\\n\\n updated_qs = model_class.objects.scope(reference_dataspace).filter(\\n reduce(operator.or_, orm_lookups)\\n )\\n\\n params = {DataspaceFilter.parameter_name: reference_dataspace.pk}\\n changelist_href = queryset_to_changelist_href(updated_qs, params)\\n if changelist_href:\\n return redirect(changelist_href)\\n\\n messages.warning(request, \\\"No updates available in the reference dataspace.\\\")\\n\\n @staticmethod\\n def get_changes_details(form):\\n \\\"\\\"\\\"\\n Introspect a given form to collect the changes details.\\n Original values are collected on the DB instance (pre-save value)\\n and New values are collected on the form (post-save value)\\n \\\"\\\"\\\"\\n if not form.instance.pk:\\n return {}\\n\\n model_class = form.instance.__class__\\n original_instance = model_class.objects.get(pk=form.instance.pk)\\n\\n changes_details = []\\n # Using form.changed_data to only iterate on updated fields\\n for field in form.changed_data:\\n original_value = getattr(original_instance, field)\\n new_value = getattr(form.instance, field)\\n changes_details.append((field, original_value, new_value))\\n\\n return {form.instance: changes_details}\\n\\n def save_model(self, request, obj, form, change):\\n \\\"\\\"\\\"Set the created_by and last_modified_by fields at save time.\\\"\\\"\\\"\\n # This have no impact on save() if the model does not declare those fields.\\n obj.last_modified_by = request.user\\n if not change:\\n obj.created_by = request.user\\n\\n # Injecting the results in the request for future use in the\\n # log_change() method. This content will be used to add the changes\\n # details into the notification message.\\n # Using an OrderedDict to keep the main instance details first\\n # The related objects changes (inlines) are gathered in\\n # self.save_formset()\\n request.changes_details = OrderedDict()\\n if change and CHANGE in self.email_notification_on:\\n request.changes_details.update(self.get_changes_details(form))\\n\\n super().save_model(request, obj, form, change)\\n\\n def save_formset(self, request, form, formset, change):\\n \\\"\\\"\\\"\\n Set the Dataspace on the Inline instance before it's saved. Using the\\n Dataspace of the Model instance of this ModelAdmin.\\n Also craft the change details of the Inlines.\\n \\\"\\\"\\\"\\n for f in formset.forms:\\n # Skip if nothing has changed in the current inline form\\n if not f.changed_data:\\n continue\\n\\n # Set the Dataspace on the Inline instance in case of addition of\\n # the current inline.\\n # The Dataspace is taken from the main form instance.\\n if not f.instance.dataspace_id:\\n f.instance.dataspace = form.instance.dataspace\\n\\n # Only in case of a 'change' on the main instance\\n if change and CHANGE in self.email_notification_on:\\n # As the `change` param is only about the main instance, we use\\n # the pk of the inline instance to make sure we are in a\\n # MODIFICATION case.\\n #\\n # If the pk of the inline instance is None, this is an ADDITION,\\n # so skip the details creation. Also, if DELETION_FIELD_NAME is\\n # in changed_data, we are in an inline deletion case, skipping\\n # too.\\n if f.instance.pk and DELETION_FIELD_NAME not in f.changed_data:\\n # request.changes_details is created in self.save_model()\\n request.changes_details.update(self.get_changes_details(f))\\n\\n super().save_formset(request, form, formset, change)\\n\\n def delete_model(self, request, obj):\\n # We are using this rather than self.log_deletion because it's not called\\n # Here, History.log_deletion is called for each object in the bulk.\\n History.log_deletion(request.user, obj)\\n super().delete_model(request, obj)\\n if DELETION in self.email_notification_on:\\n send_notification_email(request.user, obj, DELETION)\\n\\n def delete_queryset(self, request, queryset):\\n \\\"\\\"\\\"\\n Add the email notification on bulk deletion through the default django\\n 'delete_selected' action.\\n \\\"\\\"\\\"\\n send_notification_email_on_queryset(request.user, queryset, DELETION)\\n super().delete_queryset(request, queryset)\\n\\n def get_urls(self):\\n info = self.model._meta.app_label, self.model._meta.model_name\\n urls = []\\n\\n if self.activity_log:\\n urls += [\\n path(\\n \\\"activity_log/\\\",\\n self.admin_site.admin_view(ActivityLog.as_view(model=self.model)),\\n name=\\\"{}_{}_activity_log\\\".format(*info),\\n )\\n ]\\n\\n actions = getattr(self, \\\"actions\\\", [])\\n actions_to_remove = getattr(self, \\\"actions_to_remove\\\", [])\\n\\n if \\\"copy_to\\\" in actions and \\\"copy_to\\\" not in actions_to_remove:\\n urls += [\\n path(\\n \\\"copy/\\\",\\n self.admin_site.admin_view(object_copy_view),\\n name=\\\"{}_{}_copy\\\".format(*info),\\n ),\\n ]\\n\\n if \\\"compare_with\\\" in actions and \\\"compare_with\\\" not in actions_to_remove:\\n urls += [\\n path(\\n \\\"compare/\\\",\\n self.admin_site.admin_view(object_compare_view),\\n name=\\\"{}_{}_compare\\\".format(*info),\\n ),\\n ]\\n\\n if self.importer_class:\\n urls += [\\n path(\\n \\\"import/\\\",\\n self.admin_site.admin_view(import_view),\\n {\\\"importer_class\\\": self.importer_class},\\n name=\\\"{}_{}_import\\\".format(*info),\\n ),\\n ]\\n\\n return urls + super().get_urls()\\n\\n def get_form(self, request, obj=None, **kwargs):\\n \\\"\\\"\\\"\\n Set the `obj` instance on the `request` for future processing.\\n Set the serialized_data of the object on the `request` to be used in the\\n `log_change` method.\\n Set the `request` on the `form_class`.\\n \\\"\\\"\\\"\\n if obj:\\n request._object = obj\\n request._serialized_data = obj.as_json()\\n\\n form_class = super().get_form(request, obj, **kwargs)\\n form_class.request = request\\n return form_class\\n\\n def get_fieldsets(self, request, obj=None):\\n \\\"\\\"\\\"Exclude form fields from the ADMIN_FORMS_CONFIGURATION settings.\\\"\\\"\\\"\\n fieldsets = super().get_fieldsets(request, obj)\\n\\n forms_config = settings.ADMIN_FORMS_CONFIGURATION\\n if not forms_config:\\n return fieldsets\\n\\n model_config = forms_config.get(self.model._meta.model_name, {})\\n exclude = model_config.get(\\\"exclude\\\", [])\\n if not exclude:\\n return fieldsets\\n\\n fieldsets_with_exclude = []\\n for label, entry in fieldsets:\\n fields = entry.get(\\\"fields\\\")\\n if fields:\\n entry[\\\"fields\\\"] = [field for field in fields if field not in exclude]\\n fieldsets_with_exclude.append((label, entry))\\n\\n return fieldsets_with_exclude\\n\\n def get_inline_instances(self, request, obj=None):\\n \\\"\\\"\\\"Injects the ``request`` in each inline form to be used in validation.\\\"\\\"\\\"\\n base_instances = super().get_inline_instances(request, obj)\\n\\n instances = []\\n request._object = obj\\n for inline in base_instances:\\n inline.form.request = request\\n instances.append(inline)\\n\\n return instances\\n\\n def get_actions(self, request):\\n \\\"\\\"\\\"Limit the available actions based on who you are and what you are looking at.\\\"\\\"\\\"\\n if IS_POPUP_VAR in request.GET:\\n return OrderedDict()\\n\\n actions = super().get_actions(request)\\n is_user_dataspace = DataspaceFilter.parameter_name not in request.GET\\n\\n can_mass_update = all(\\n [\\n self.mass_update_form,\\n has_permission(self.model, request.user, \\\"change\\\"),\\n is_user_dataspace or request.user.dataspace.is_reference,\\n ]\\n )\\n\\n if can_mass_update:\\n actions[\\\"mass_update\\\"] = (mass_update_action, \\\"mass_update\\\", \\\"Mass update\\\")\\n\\n if not has_permission(self.model, request.user, \\\"add\\\") and \\\"copy_to\\\" in actions:\\n del actions[\\\"copy_to\\\"]\\n\\n if not request.user.dataspace.is_reference:\\n if is_user_dataspace: # The user is looking at his own Dataspace\\n if \\\"copy_to\\\" in actions:\\n del actions[\\\"copy_to\\\"]\\n if \\\"compare_with\\\" in actions:\\n del actions[\\\"compare_with\\\"]\\n else: # The user is looking at another Dataspace\\n if \\\"delete_selected\\\" in actions:\\n del actions[\\\"delete_selected\\\"]\\n\\n if request.user.dataspace.is_reference or not is_user_dataspace:\\n if \\\"check_updates_in_reference\\\" in actions:\\n del actions[\\\"check_updates_in_reference\\\"]\\n if \\\"check_newer_version_in_reference\\\" in actions:\\n del actions[\\\"check_newer_version_in_reference\\\"]\\n\\n for action in self.actions_to_remove:\\n if action in actions:\\n del actions[action]\\n\\n return actions\\n\\n @admin.display(description=_(\\\"Copy to my Dataspace\\\"))\\n def copy_link(self, obj):\\n return format_html(\\n '<strong><a href=\\\"{}&{}=1\\\">{}</a></strong>',\\n obj.get_copy_url(),\\n IS_POPUP_VAR,\\n _(\\\"Copy to my Dataspace\\\"),\\n )\\n\\n @staticmethod\\n def hide_display_links(request):\\n return all(\\n [\\n DataspaceFilter.parameter_name in request.GET,\\n request.GET.get(DataspaceFilter.parameter_name) != str(request.user.dataspace_id),\\n ]\\n )\\n\\n def get_list_display(self, request):\\n \\\"\\\"\\\"\\n Remove the view_on_site and hierarchy links in popup mode.\\n Also insert the copy link when looking at another dataspace.\\n \\\"\\\"\\\"\\n list_display = super().get_list_display(request)\\n\\n if IS_POPUP_VAR in request.GET:\\n list_display = list(list_display)\\n if \\\"changelist_view_on_site\\\" in list_display:\\n list_display.remove(\\\"changelist_view_on_site\\\")\\n if get_hierarchy_link in list_display:\\n list_display.remove(get_hierarchy_link)\\n\\n if self.hide_display_links(request):\\n list_display = list(list_display)\\n if \\\"copy_to\\\" not in self.actions_to_remove:\\n list_display.insert(0, \\\"copy_link\\\")\\n if get_hierarchy_link in list_display:\\n list_display.remove(get_hierarchy_link)\\n\\n return list_display\\n\\n def get_list_display_links(self, request, list_display):\\n \\\"\\\"\\\"Remove all the display_links when looking at another dataspace.\\\"\\\"\\\"\\n if not self.hide_display_links(request):\\n return super().get_list_display_links(request, list_display)\\n\\n def response_change(self, request, obj):\\n \\\"\\\"\\\"Add the logic for the \\\"Save and go to next\\\" feature.\\\"\\\"\\\"\\n next_id = request.POST.get(\\\"next_id\\\")\\n if \\\"_next\\\" in request.POST and next_id:\\n opts = self.model._meta\\n preserved_filters = self.get_preserved_filters(request)\\n\\n msg_dict = {\\n \\\"name\\\": str(opts.verbose_name),\\n \\\"obj\\\": str(obj),\\n }\\n msg = 'The {name} \\\"{obj}\\\" was changed successfully.'.format(**msg_dict)\\n self.message_user(request, msg, messages.SUCCESS)\\n\\n viewname = f\\\"admin:{opts.app_label}_{opts.model_name}_change\\\"\\n next_url = reverse(viewname, args=[next_id], current_app=self.admin_site.name)\\n redirect_url = add_preserved_filters(\\n {\\\"preserved_filters\\\": preserved_filters, \\\"opts\\\": opts}, next_url\\n )\\n return redirect(redirect_url)\\n\\n return super().response_change(request, obj)\\n\\n def lookup_allowed(self, lookup, value):\\n if lookup in [EXTERNAL_SOURCE_LOOKUP]:\\n return True\\n return super().lookup_allowed(lookup, value)\\n\\n @staticmethod\\n def _limited_permission(request, obj, has_perm):\\n # Model permission\\n if not has_perm:\\n return False\\n\\n # Object instance permission\\n if obj and obj.dataspace_id != request.user.dataspace_id:\\n return request.user.dataspace.is_reference\\n return True\\n\\n def has_add_permission(self, request):\\n has_perm = super().has_add_permission(request)\\n # Do not display the \\\"Add\\\" link in filter lookup popup mode\\n if IS_FILTER_LOOKUP_VAR in request.GET:\\n return False\\n return has_perm\\n\\n def has_change_permission(self, request, obj=None):\\n has_perm = super().has_change_permission(request, obj)\\n return self._limited_permission(request, obj, has_perm)\\n\\n def has_delete_permission(self, request, obj=None):\\n has_perm = super().has_delete_permission(request, obj)\\n return self._limited_permission(request, obj, has_perm)\\n\\n def has_view_permission(self, request, obj=None):\\n has_perm = super().has_view_permission(request, obj)\\n return self._limited_permission(request, obj, has_perm)\\n\\n def has_importer(self):\\n \\\"\\\"\\\"Return True if the importer_class has been set.\\\"\\\"\\\"\\n if self.importer_class:\\n return True\\n\\n def has_activity_log(self):\\n \\\"\\\"\\\"Return True if the activity_log has been set.\\\"\\\"\\\"\\n if self.activity_log:\\n return True\"\n },\n {\n \"identifier\": \"DataspacedFKMixin\",\n \"path\": \"dje/admin.py\",\n \"snippet\": \"class DataspacedFKMixin:\\n \\\"\\\"\\\"\\n Limit the QuerySet of ForeignKeys to the current Dataspace,\\n or to the parent object in case of Inlines.\\n On ADDITION, the Dataspace is taken from the User\\n On MODIFICATION, it's taken on the current object instance or parent\\n instance in case of Inlines.\\n This class can be applied to ModelAdmins and Inlines.\\n The declared limit_choices_to on the model field will be respected.\\n \\\"\\\"\\\"\\n\\n # The QuerySet for the fields in this list will be scoped by the Model content_type\\n content_type_scope_fields = []\\n\\n def formfield_for_foreignkey(self, db_field, request=None, **kwargs):\\n # If a QuerySet was given in the kwargs of the calling method, we then\\n # assume that the filtering was done and we skip further processing.\\n qs = kwargs.get(\\\"queryset\\\", None)\\n if qs is not None:\\n return super().formfield_for_foreignkey(db_field, request, **kwargs)\\n\\n related_model = db_field.related_model\\n if is_dataspace_related(related_model):\\n # No instance, ADDITION, get dataspace from user\\n if not getattr(request, \\\"_object\\\", None):\\n dataspace = request.user.dataspace\\n # Parent instance, MODIFICATION, dataspace from instance\\n else:\\n dataspace = request._object.dataspace\\n\\n kwargs[\\\"queryset\\\"] = db_field.related_model.objects.scope(dataspace).complex_filter(\\n db_field.remote_field.limit_choices_to\\n )\\n\\n if db_field.name in self.content_type_scope_fields:\\n kwargs[\\\"queryset\\\"] = kwargs[\\\"queryset\\\"].filter(\\n content_type=ContentType.objects.get_for_model(self.model)\\n )\\n\\n return super().formfield_for_foreignkey(db_field, request, **kwargs)\"\n },\n {\n \"identifier\": \"dejacode_site\",\n \"path\": \"dje/admin.py\",\n \"snippet\": \"EXTERNAL_SOURCE_LOOKUP = \\\"external_references__external_source_id\\\"\\nADDITION = History.ADDITION\\nCHANGE = History.CHANGE\\nDELETION = History.DELETION\\n HIDDEN_VALUE = \\\"*******\\\"\\nclass DejaCodeAdminSite(AdminSite):\\nclass ReferenceOnlyPermissions:\\nclass DataspacedFKMixin:\\nclass ProtectedFieldsMixin:\\nclass ChangelistPopupPermissionMixin:\\nclass ProhibitDataspaceLookupMixin:\\nclass AdvancedSearchAdminMixin:\\nclass HistoryAdminMixin:\\nclass ColoredIconAdminMixin:\\n class Media:\\nclass DataspacedChangeList(ChangeList):\\nclass DataspacedAdmin(\\n DataspacedFKMixin,\\n ProtectedFieldsMixin,\\n AdvancedSearchAdminMixin,\\n HistoryAdminMixin,\\n admin.ModelAdmin,\\n):\\nclass HiddenValueWidget(forms.TextInput):\\nclass DataspaceConfigurationForm(forms.ModelForm):\\nclass DataspaceConfigurationInline(DataspacedFKMixin, admin.StackedInline):\\nclass DataspaceAdmin(\\n ReferenceOnlyPermissions,\\n HistoryAdminMixin,\\n admin.ModelAdmin,\\n):\\nclass ChildRelationshipInline(DataspacedFKMixin, admin.TabularInline):\\nclass ExternalReferenceInline(DataspacedFKMixin, GenericTabularInline):\\nclass ExternalSourceAdmin(DataspacedAdmin):\\nclass DejacodeUserChangeForm(forms.ModelForm):\\n class Meta:\\nclass DejacodeUserCreationForm(DejacodeUserChangeForm):\\nclass DejacodeUserAdmin(\\n DataspacedFKMixin,\\n AdvancedSearchAdminMixin,\\n HistoryAdminMixin,\\n UserAdmin,\\n):\\nclass GroupAdmin(ReferenceOnlyPermissions, HistoryAdminMixin, GroupAdmin):\\n class ReferenceAccessAttemptAdmin(ReferenceOnlyPermissions, AccessAttemptAdmin):\\n def get_urls(self):\\ndef get_hierarchy_link(obj):\\ndef get_additional_information_fieldset(pre_fields=None):\\n def has_add_permission(self, request):\\n def has_change_permission(self, request, obj=None):\\n def has_delete_permission(self, request, obj=None):\\n def has_view_permission(self, request, obj=None):\\n def formfield_for_foreignkey(self, db_field, request=None, **kwargs):\\n def get_readonly_fields(self, request, obj=None):\\n def has_change_permission(self, request, obj=None):\\n def lookup_allowed(self, lookup, value):\\n def check(self, **kwargs):\\n def get_queryset(self, request):\\n def get_search_results(self, request, queryset, search_term):\\n def log_addition(self, request, object, change_message=None):\\n def log_change(self, request, object, message):\\n def log_deletion(self, request, object, object_repr):\\n def history_view(self, request, object_id, extra_context=None):\\n def colored_icon(self, obj):\\n def get_results(self, request):\\n def has_filters_activated(self):\\n def get_filters_params(self, params=None):\\n def set_reference_link(self, request):\\n def __init__(self, model, admin_site):\\n def check(self, **kwargs):\\n def changeform_view_on_site(self, obj):\\n def changelist_view_on_site(self, obj):\\n def urn_link(self, instance):\\n def get_queryset(self, request):\\n def get_changelist(self, request, **kwargs):\\n def get_list_filter(self, request):\\n def get_readonly_fields(self, request, obj=None):\\n def change_view(self, request, object_id, form_url=\\\"\\\", extra_context=None):\\n def render_change_form(self, request, context, add=False, change=False, form_url=\\\"\\\", obj=None):\\n def get_selected_ids_from_request(request, queryset):\\n def base_action_with_redirect(self, request, queryset, viewname):\\n def copy_to(self, request, queryset):\\n def compare_with(self, request, queryset):\\n def check_updates_in_reference(self, request, queryset):\\n def check_newer_version_in_reference(self, request, queryset):\\n def base_check_in_reference_action(request, model_class, orm_lookups):\\n def get_changes_details(form):\\n def save_model(self, request, obj, form, change):\\n def save_formset(self, request, form, formset, change):\\n def delete_model(self, request, obj):\\n def delete_queryset(self, request, queryset):\\n def get_urls(self):\\n def get_form(self, request, obj=None, **kwargs):\\n def get_fieldsets(self, request, obj=None):\\n def get_inline_instances(self, request, obj=None):\\n def get_actions(self, request):\\n def copy_link(self, obj):\\n def hide_display_links(request):\\n def get_list_display(self, request):\\n def get_list_display_links(self, request, list_display):\\n def response_change(self, request, obj):\\n def lookup_allowed(self, lookup, value):\\n def _limited_permission(request, obj, has_perm):\\n def has_add_permission(self, request):\\n def has_change_permission(self, request, obj=None):\\n def has_delete_permission(self, request, obj=None):\\n def has_view_permission(self, request, obj=None):\\n def has_importer(self):\\n def has_activity_log(self):\\n def render(self, name, value, attrs=None, renderer=None):\\n def __init__(self, *args, **kwargs):\\n def clean(self):\\n def has_change_permission(self, request, obj=None):\\n def get_readonly_fields(self, request, obj=None):\\n def get_urls(self):\\n def get_queryset(self, request):\\n def get_actions(self, request):\\n def changeform_view(self, request, object_id=None, form_url=\\\"\\\", extra_context=None):\\n def references(self, obj):\\ndef send_activation_email(user, request):\\n def __init__(self, *args, **kwargs):\\n def save(self, commit=True):\\n def get_form(self, request, obj=None, **kwargs):\\n def get_queryset(self, request):\\n def formfield_for_foreignkey(self, db_field, request=None, **kwargs):\\n def user_change_password(self, request, id, form_url=\\\"\\\"):\\n def get_list_filter(self, request):\\n def has_activity_log(self):\\n def get_urls(self):\\n def log_addition(self, request, object, change_message=None):\\n def delete_model(self, request, obj):\\n def get_actions(self, request):\\n def set_inactive(self, request, queryset):\\n def export_as_csv(self, request, queryset):\\n def send_activation_email(self, request, object_id):\\n def get_queryset(self, request):\\n def get_permissions(self, obj):\\n def formfield_for_manytomany(self, db_field, request=None, **kwargs):\\n def get_urls(self):\\n def get_permission_group_mapping():\\n def permission_details_view(self, request):\\n def permission_export_csv(self, request):\\ndef register_axes_admin():\"\n },\n {\n \"identifier\": \"get_additional_information_fieldset\",\n \"path\": \"dje/admin.py\",\n \"snippet\": \"def get_additional_information_fieldset(pre_fields=None):\\n fields = (\\n \\\"dataspace\\\",\\n \\\"uuid\\\",\\n \\\"created_date\\\",\\n \\\"created_by\\\",\\n \\\"last_modified_date\\\",\\n \\\"last_modified_by\\\",\\n )\\n\\n if pre_fields:\\n fields = pre_fields + fields\\n\\n return (\\\"Additional Information\\\", {\\\"classes\\\": (\\\"grp-collapse grp-closed\\\",), \\\"fields\\\": fields})\"\n },\n {\n \"identifier\": \"add_client_data\",\n \"path\": \"dje/client_data.py\",\n \"snippet\": \"def add_client_data(request, **kwargs):\\n \\\"\\\"\\\"\\n Set values on the request, to be available in the JavaScript client data object.\\n On the client side, the values are accessible through ``NEXB.client_data``.\\n \\\"\\\"\\\"\\n if not hasattr(request, 'client_data'):\\n request.client_data = {}\\n request.client_data.update(kwargs)\"\n },\n {\n \"identifier\": \"MissingInFilter\",\n \"path\": \"dje/filters.py\",\n \"snippet\": \"class MissingInFilter(BaseDataspaceLookupsFilter):\\n \\\"\\\"\\\"\\n Filter by objects missing in the given dataspace, compared with the\\n current `DataspaceFilter.parameter_name` or user dataspace.\\n Both values for reference and target Dataspace are validated against the\\n self.lookup_choices to make sure the user has the proper access permissions.\\n This filter is only available to superusers, this is enforced in\\n DataspacedAdmin.get_list_filter()\\n \\\"\\\"\\\"\\n\\n title = _(\\\"missing in\\\")\\n parameter_name = \\\"missing_in\\\"\\n\\n def queryset(self, request, queryset):\\n if not self.value():\\n return\\n\\n valid_choices = [str(choice) for choice, _ in self.lookup_choices]\\n if str(self.value()) not in valid_choices:\\n raise IncorrectLookupParameters()\\n\\n return queryset.exclude(uuid__in=get_uuids_list_sorted(self.value(), queryset.model))\"\n },\n {\n \"identifier\": \"AsJoinList\",\n \"path\": \"dje/list_display.py\",\n \"snippet\": \"class AsJoinList(ListDisplayItem):\\n def __init__(self, name, join_str, **kwargs):\\n self.join_str = join_str\\n kwargs[\\\"admin_order_field\\\"] = None\\n super().__init__(name, **kwargs)\\n\\n def to_representation(self, value):\\n return format_html(self.join_str.join(value))\"\n },\n {\n \"identifier\": \"AsLink\",\n \"path\": \"dje/list_display.py\",\n \"snippet\": \"class AsLink(ListDisplayItem):\\n def to_representation(self, value):\\n return value.get_admin_link(target=\\\"_blank\\\")\"\n },\n {\n \"identifier\": \"CHANGELIST_LINK_TEMPLATE\",\n \"path\": \"dje/utils.py\",\n \"snippet\": \"CHANGELIST_LINK_TEMPLATE = (\\n '<strong>See the <a href=\\\"{}\\\" target=\\\"_blank\\\">{} {}</a> in changelist</strong>'\\n)\"\n },\n {\n \"identifier\": \"queryset_to_html_list\",\n \"path\": \"dje/utils.py\",\n \"snippet\": \"def queryset_to_html_list(queryset, url_params, qs_limit=None):\\n \\\"\\\"\\\"\\n Return an HTML <ul> of a given queryset.\\n A link to access the full list, in a changelist, of results is added.\\n A limit can be specified.\\n \\\"\\\"\\\"\\n # Using len() to evaluate the qs rather than a count() that will cost an\\n # extra query per row.\\n count = len(queryset)\\n if not count:\\n return\\n\\n opts = queryset.model._meta\\n url = reverse(f\\\"admin:{opts.app_label}_{opts.model_name}_changelist\\\")\\n href = f\\\"{url}?{urlencode(url_params)}\\\"\\n changelist_link = format_html(CHANGELIST_LINK_TEMPLATE, href, count, opts.verbose_name_plural)\\n\\n list_items = [\\n \\\"<li>{}</li>\\\".format(instance.get_admin_link(target=\\\"_blank\\\"))\\n for instance in queryset[:qs_limit]\\n ]\\n\\n return format_html(\\n '<ul class=\\\"with-disc\\\">{}</ul>{}', mark_safe(\\\"\\\".join(list_items)), changelist_link\\n )\"\n },\n {\n \"identifier\": \"ReportingQueryListFilter\",\n \"path\": \"reporting/filters.py\",\n \"snippet\": \"class ReportingQueryListFilter(admin.SimpleListFilter):\\n \\\"\\\"\\\"\\n Allows to filter a changelist given a reporting.Query instance\\n This can only be used on a ModelAdmin for which the Model is supported by\\n the reporting app.\\n Only available on the user dataspace objects for security reason.\\n If `order_fields` are available on this Query, the ordering will be added in\\n the filter parameters.\\n \\\"\\\"\\\"\\n\\n title = _(\\\"reporting query\\\")\\n parameter_name = \\\"reporting_query\\\"\\n\\n def lookups(self, request, model_admin):\\n # Limit the availability of this filter to current user dataspace objects\\n if DataspaceFilter.parameter_name in request.GET:\\n return\\n\\n query_qs = (\\n Query.objects.scope(request.user.dataspace)\\n .get_for_model(model_admin.model)\\n .prefetch_related(\\\"order_fields\\\")\\n )\\n\\n lookups = []\\n for query in query_qs:\\n param_dict = {\\n self.parameter_name: query._get_pk_val(),\\n }\\n\\n ordering_from_query = query.get_order_list_for_url(request, model_admin)\\n if ordering_from_query:\\n param_dict[ORDER_VAR] = \\\".\\\".join(ordering_from_query)\\n\\n lookups.append((query.name, param_dict))\\n\\n return lookups\\n\\n def choices(self, changelist):\\n yield {\\n \\\"selected\\\": self.value() is None,\\n \\\"query_string\\\": changelist.get_query_string({}, [self.parameter_name, ORDER_VAR]),\\n \\\"display\\\": _(\\\"All\\\"),\\n }\\n for title, param_dict in self.lookup_choices:\\n yield {\\n \\\"selected\\\": str(param_dict.get(self.parameter_name)) == str(self.value()),\\n \\\"query_string\\\": changelist.get_query_string(param_dict, [ORDER_VAR]),\\n \\\"display\\\": title,\\n }\\n\\n def queryset(self, request, queryset):\\n if not self.value():\\n return queryset\\n\\n # This filter is only available on the user dataspace objects\\n query_instance = get_object_or_404(\\n Query,\\n pk=self.value(),\\n dataspace=request.user.dataspace,\\n )\\n\\n try:\\n qs = query_instance.get_qs(user=request.user)\\n except Exception as e: # Broad exception as get_qs is fairly unstable\\n messages.error(request, f\\\"{self.title} filter error: {e}\\\")\\n return\\n\\n msg = f\\\"{capfirst(self.title)} filter active. Other filters may be ignored.\\\"\\n messages.warning(request, msg)\\n\\n return qs\"\n },\n {\n \"identifier\": \"ColumnTemplateForm\",\n \"path\": \"reporting/forms.py\",\n \"snippet\": \"class ColumnTemplateForm(CleanContentTypeFormMixin, DataspacedAdminForm):\\n class Meta:\\n model = ColumnTemplate\\n fields = \\\"__all__\\\"\"\n },\n {\n \"identifier\": \"QueryForm\",\n \"path\": \"reporting/forms.py\",\n \"snippet\": \"class QueryForm(CleanContentTypeFormMixin, DataspacedAdminForm):\\n class Meta:\\n model = Query\\n fields = \\\"__all__\\\"\"\n },\n {\n \"identifier\": \"ReportForm\",\n \"path\": \"reporting/forms.py\",\n \"snippet\": \"class ReportForm(DataspacedAdminForm):\\n class Meta:\\n model = Report\\n fields = \\\"__all__\\\"\\n\\n def clean(self):\\n cleaned_data = super().clean()\\n\\n query = cleaned_data.get(\\\"query\\\")\\n column_template = cleaned_data.get(\\\"column_template\\\")\\n\\n if query and column_template:\\n # Only do something if both fields are valid so far.\\n if query.content_type != column_template.content_type:\\n msg = \\\"The query and column template must have matching object types.\\\"\\n self.add_error(\\\"query\\\", msg)\\n self.add_error(\\\"column_template\\\", msg)\\n\\n raise ValidationError(\\n \\\"{} The query has an object type of {}. The column \\\"\\n \\\"template has an object type of {}.\\\".format(\\n msg,\\n query.content_type.model_class()._meta.verbose_name,\\n column_template.content_type.model_class()._meta.verbose_name,\\n )\\n )\\n\\n return cleaned_data\"\n },\n {\n \"identifier\": \"ReportMassUpdateForm\",\n \"path\": \"reporting/forms.py\",\n \"snippet\": \"class ReportMassUpdateForm(DejacodeMassUpdateForm):\\n class Meta:\\n fields = [\\n \\\"group\\\",\\n ]\"\n },\n {\n \"identifier\": \"get_model_data_for_column_template\",\n \"path\": \"reporting/forms.py\",\n \"snippet\": \"def get_model_data_for_column_template(dataspace=None):\\n \\\"\\\"\\\"\\n Return a dict-based data structure of the models and their fields available\\n in the ColumnTemplate system.\\n An optional dataspace can be given, the LicenseTag will not be included\\n if the dataspace is not specified.\\n \\\"\\\"\\\"\\n model_classes = introspector.get_related_models(get_reportable_models())\\n model_data = introspector.get_model_data(\\n model_classes=model_classes,\\n model_whitelist=MODEL_WHITELIST,\\n get_m2m=True,\\n # Do not display the related many-to-many fields because they don't\\n # make sense as selectable columns\\n get_related_m2m=False,\\n get_related=True,\\n get_generic_relation=True,\\n field_whitelist=FIELDS_WHITELIST,\\n )\\n\\n # Extend model_data with some properties\\n extended_model_data = {\\n \\\"component_catalog:component\\\": {\\n \\\"Properties\\\": [\\n \\\"urn\\\",\\n \\\"details_url\\\",\\n \\\"primary_license\\\",\\n \\\"attribution_required\\\",\\n \\\"redistribution_required\\\",\\n \\\"change_tracking_required\\\",\\n \\\"where_used\\\",\\n ],\\n },\\n \\\"component_catalog:package\\\": {\\n \\\"Properties\\\": [\\n \\\"identifier\\\",\\n \\\"urn\\\",\\n \\\"details_url\\\",\\n \\\"primary_license\\\",\\n \\\"attribution_required\\\",\\n \\\"redistribution_required\\\",\\n \\\"change_tracking_required\\\",\\n \\\"package_url\\\",\\n \\\"short_package_url\\\",\\n \\\"where_used\\\",\\n \\\"inferred_url\\\",\\n ],\\n },\\n \\\"license_library:license\\\": {\\n \\\"Properties\\\": [\\n \\\"urn\\\",\\n \\\"details_url\\\",\\n \\\"spdx_url\\\",\\n \\\"attribution_required\\\",\\n \\\"redistribution_required\\\",\\n \\\"change_tracking_required\\\",\\n \\\"where_used\\\",\\n \\\"language_code\\\",\\n ],\\n },\\n \\\"organization:owner\\\": {\\n \\\"Properties\\\": [\\n \\\"urn\\\",\\n ],\\n },\\n \\\"workflow:request\\\": {\\n \\\"Properties\\\": [\\n \\\"serialized_data_html\\\",\\n \\\"details_url\\\",\\n \\\"content_object\\\",\\n ],\\n },\\n }\\n\\n if dataspace:\\n qs = LicenseTag.objects.scope(dataspace)\\n extended_model_data[\\\"license_library:license\\\"].update(\\n {\\n \\\"License Tags\\\": [f\\\"{LICENSE_TAG_PREFIX}{tag.label}\\\" for tag in qs],\\n }\\n )\\n\\n for model in get_reportable_models():\\n model_label = get_model_label(model)\\n\\n if model_label not in model_data:\\n continue\\n\\n fields = model_data[model_label][\\\"fields\\\"]\\n grouped_fields = model_data[model_label][\\\"grouped_fields\\\"]\\n meta = model_data[model_label][\\\"meta\\\"]\\n extra_groups = []\\n\\n for group, labels in extended_model_data.get(model_label, {}).items():\\n for label in labels:\\n fields.append(label)\\n meta[label] = {}\\n extra_groups.append({\\\"group\\\": group, \\\"label\\\": label, \\\"value\\\": label})\\n\\n grouped_fields.extend(extra_groups)\\n\\n return model_data\"\n },\n {\n \"identifier\": \"get_model_data_for_order_field\",\n \"path\": \"reporting/forms.py\",\n \"snippet\": \"@functools.lru_cache(maxsize=None)\\ndef get_model_data_for_order_field():\\n \\\"\\\"\\\"\\n Return a dict-based data structure of the models and their fields available\\n in the OrderField system.\\n \\\"\\\"\\\"\\n model_classes = get_reportable_models()\\n return introspector.get_model_data(\\n model_classes=model_classes,\\n model_whitelist=MODEL_WHITELIST,\\n omit_foreign_key_fields=False,\\n get_m2m=False,\\n get_related_m2m=False,\\n get_related=False,\\n get_generic_relation=False,\\n field_whitelist=FIELDS_WHITELIST,\\n )\"\n },\n {\n \"identifier\": \"get_model_data_for_query\",\n \"path\": \"reporting/forms.py\",\n \"snippet\": \"@functools.lru_cache(maxsize=None)\\ndef get_model_data_for_query():\\n \\\"\\\"\\\"\\n Return a dict-based data structure of the models and their fields available\\n in the Query system.\\n \\\"\\\"\\\"\\n model_classes = introspector.get_related_models(get_reportable_models())\\n return introspector.get_model_data(\\n model_classes=model_classes,\\n model_whitelist=MODEL_WHITELIST,\\n get_m2m=True,\\n # Do not display the related many-to-many fields because there is no\\n # need to query against them\\n get_related_m2m=False,\\n get_related=True,\\n get_generic_relation=True,\\n field_whitelist=FIELDS_WHITELIST,\\n )\"\n },\n {\n \"identifier\": \"ColumnTemplateAssignedFieldInline\",\n \"path\": \"reporting/inlines.py\",\n \"snippet\": \"class ColumnTemplateAssignedFieldInline(admin.TabularInline):\\n model = ColumnTemplateAssignedField\\n # Delegate to the Ember-based inline UI the responsibility of rendering, so\\n # instantiate 0 extra forms\\n extra = 0\\n formset = ColumnTemplateAssignedFieldFormSet\\n\\n def get_formset(self, request, obj=None, **kwargs):\\n \\\"\\\"\\\"\\n Injecting the request in the FormSets, required for the validation in\\n ColumnTemplateAssignedFieldFormSet.clean()\\n \\\"\\\"\\\"\\n FormSet = super().get_formset(request, obj, **kwargs)\\n FormSet._request = request\\n return FormSet\"\n },\n {\n \"identifier\": \"FilterInline\",\n \"path\": \"reporting/inlines.py\",\n \"snippet\": \"class FilterInline(admin.TabularInline):\\n model = Filter\\n fk_name = \\\"query\\\"\\n # Delegate to the Ember-based inline UI the responsibility of rendering, so\\n # instantiate 0 extra forms\\n extra = 0\\n form = FilterForm\"\n },\n {\n \"identifier\": \"OrderFieldInline\",\n \"path\": \"reporting/inlines.py\",\n \"snippet\": \"class OrderFieldInline(admin.TabularInline):\\n model = OrderField\\n fk_name = \\\"query\\\"\\n # Delegate to the Ember-based inline UI the responsibility of rendering, so\\n # instantiate 0 extra forms\\n extra = 0\\n form = OrderFieldForm\"\n },\n {\n \"identifier\": \"get_model_label\",\n \"path\": \"reporting/introspection.py\",\n \"snippet\": \"def get_model_label(model):\\n return f\\\"{model._meta.app_label}:{model._meta.model_name}\\\"\"\n },\n {\n \"identifier\": \"Card\",\n \"path\": \"reporting/models.py\",\n \"snippet\": \"class Card(HistoryFieldsMixin, DataspacedModel):\\n title = models.CharField(\\n max_length=1024,\\n help_text=_(\\\"A concise and unique description of your Card.\\\"),\\n )\\n query = models.ForeignKey(\\n to=\\\"reporting.Query\\\",\\n on_delete=models.CASCADE,\\n related_name=\\\"cards\\\",\\n help_text=_(\\n \\\"The Query that obtains the data to show in the Card. \\\"\\n \\\"The best kind of Query for this purpose is one that filters by a \\\"\\n \\\"status or a modification date, in order to alert the user to \\\"\\n \\\"recent activity that may need reviewing.\\\"\\n ),\\n )\\n number_of_results = models.PositiveSmallIntegerField(\\n default=5,\\n help_text=_(\\\"The number of results to display in the Card.\\\"),\\n )\\n display_changelist_link = models.BooleanField(\\n default=False,\\n help_text=_(\\\"Display a link to the filtered changelist for admin users.\\\"),\\n )\\n\\n class Meta:\\n unique_together = (\\\"dataspace\\\", \\\"title\\\")\\n ordering = [\\\"title\\\"]\\n\\n def __str__(self):\\n return self.title\\n\\n def get_object_list(self, user):\\n qs = self.query.get_qs(user=user)[: self.number_of_results]\\n return [obj.get_absolute_link() or obj for obj in qs]\"\n },\n {\n \"identifier\": \"CardLayout\",\n \"path\": \"reporting/models.py\",\n \"snippet\": \"class CardLayout(HistoryFieldsMixin, DataspacedModel):\\n name = models.CharField(\\n max_length=100,\\n help_text=_(\\n \\\"A concise and unique description of the Card layout that indicates \\\"\\n \\\"the theme or purpose of the layout.\\\"\\n ),\\n )\\n cards = models.ManyToManyField(\\n to=\\\"reporting.Card\\\",\\n through=\\\"reporting.LayoutAssignedCard\\\",\\n )\\n\\n class Meta:\\n unique_together = (\\\"dataspace\\\", \\\"name\\\")\\n ordering = [\\\"name\\\"]\\n\\n def __str__(self):\\n return self.name\\n\\n def get_ordered_cards(self):\\n \\\"\\\"\\\"Return the Cards of this Layout ordered by sequence.\\\"\\\"\\\"\\n return self.cards.all().order_by(\\\"layoutassignedcard__seq\\\")\\n\\n @property\\n def cards_title(self):\\n return [card.title for card in self.get_ordered_cards()]\\n\\n def cards_with_objects(self, user):\\n cards = self.get_ordered_cards()\\n for card in cards:\\n card.object_list = card.get_object_list(user=user)\\n\\n return cards\"\n },\n {\n \"identifier\": \"ColumnTemplate\",\n \"path\": \"reporting/models.py\",\n \"snippet\": \"class ColumnTemplate(HistoryFieldsMixin, DataspacedModel):\\n name = models.CharField(\\n max_length=100,\\n help_text=_(\\\"A unique, descriptive title for your column template.\\\"),\\n )\\n\\n description = models.TextField(\\n blank=True,\\n help_text=_(\\\"The purpose of your column template.\\\"),\\n )\\n\\n content_type = models.ForeignKey(\\n to=ContentType,\\n limit_choices_to=CT_LIMIT,\\n on_delete=models.PROTECT,\\n verbose_name=_(\\\"object type\\\"),\\n help_text=_(\\n \\\"Choose the primary data source for your column template: \\\"\\n \\\"licenses, components, or owners.\\\"\\n ),\\n )\\n\\n class Meta:\\n unique_together = (\\n (\\\"dataspace\\\", \\\"name\\\"),\\n (\\\"dataspace\\\", \\\"uuid\\\"),\\n )\\n ordering = (\\\"name\\\",)\\n\\n def __str__(self):\\n return f\\\"{self.name} ({self.content_type.model})\\\"\\n\\n def is_valid(self):\\n \\\"\\\"\\\"Return True each fields of the ColumnTemplate is valid.\\\"\\\"\\\"\\n return all(field.is_valid() for field in self.fields.all())\\n\\n def get_model_class(self):\\n return self.content_type.model_class()\\n\\n @staticmethod\\n def get_extra_relational_fields():\\n return [\\\"fields\\\"]\\n\\n def as_headers(self, include_view_link=False):\\n \\\"\\\"\\\"Return a list of field name, usable as Report results headers.\\\"\\\"\\\"\\n headers = [field.display_name or field.field_name for field in self.fields.all()]\\n if include_view_link:\\n headers.insert(0, format_html(\\\" \\\"))\\n return headers\"\n },\n {\n \"identifier\": \"Filter\",\n \"path\": \"reporting/models.py\",\n \"snippet\": \"class Filter(DataspacedModel):\\n query = models.ForeignKey(\\n to=\\\"reporting.Query\\\",\\n on_delete=models.CASCADE,\\n related_name=\\\"filters\\\",\\n )\\n\\n field_name = models.TextField()\\n\\n LOOKUP_CHOICES = (\\n (\\\"exact\\\", \\\"Exact match. (e.g.: apache-2.0)\\\"),\\n (\\\"iexact\\\", \\\"Case-insensitive exact match. (e.g.: APACHE-2.0)\\\"),\\n (\\\"contains\\\", \\\"Case-sensitive containment test. (e.g.: apache)\\\"),\\n (\\\"icontains\\\", \\\"Case-insensitive containment test. (e.g.: Apache)\\\"),\\n (\\\"in\\\", 'In a given list. (e.g.: [\\\"apache-1.1\\\", \\\"apache-2.0\\\"])'),\\n (\\\"startswith\\\", \\\"Case-sensitive starts-with.\\\"),\\n (\\\"istartswith\\\", \\\"Case-insensitive starts-with.\\\"),\\n (\\\"endswith\\\", \\\"Case-sensitive ends-with.\\\"),\\n (\\\"iendswith\\\", \\\"Case-insensitive ends-with.\\\"),\\n (\\\"gt\\\", \\\"Greater than.\\\"),\\n (\\\"gte\\\", \\\"Greater than or equal to.\\\"),\\n (\\\"lt\\\", \\\"Less than.\\\"),\\n (\\\"lte\\\", \\\"Less than or equal to.\\\"),\\n (\\\"year\\\", \\\"Exact year match.\\\"),\\n (\\\"month\\\", \\\"Exact month match.\\\"),\\n (\\\"day\\\", \\\"Exact day match.\\\"),\\n (\\\"isnull\\\", \\\"IS NULL. Takes either True or False.\\\"),\\n (\\\"isempty\\\", \\\"IS EMPTY. Takes either True or False.\\\"),\\n (\\\"regex\\\", 'Case-sensitive regular expression match. (e.g.: r\\\"^(A?)+\\\")'),\\n (\\\"descendant\\\", \\\"Hierarchy traversal: Descendant of (id). (e.g.: 1337)\\\"),\\n (\\n \\\"product_descendant\\\",\\n \\\"Product Hierarchy traversal. Takes product identifier name:version or id\\\",\\n ),\\n )\\n\\n lookup = models.CharField(\\n max_length=30,\\n choices=LOOKUP_CHOICES,\\n )\\n\\n value = models.TextField(\\n blank=True,\\n )\\n\\n runtime_parameter = models.BooleanField(\\n default=False,\\n )\\n\\n negate = models.BooleanField(\\n default=False,\\n help_text=(\\n 'Check to negate this lookup, as in \\\"does NOT match\\\". '\\n \\\"This can be combined with regular lookups.\\\"\\n ),\\n )\\n\\n class Meta:\\n unique_together = (\\\"dataspace\\\", \\\"uuid\\\")\\n ordering = (\\\"pk\\\",)\\n\\n def __str__(self):\\n return f\\\"{self.field_name} {self.lookup} {self.value}\\\"\\n\\n def save(self, *args, **kwargs):\\n self.dataspace = self.query.dataspace\\n super().save(*args, **kwargs)\\n\\n def get_coerced_value(self, value):\\n \\\"\\\"\\\"\\n Return a Python object that corresponds to ``value``. This is\\n accomplished by introspecting fields of models and using their\\n corresponding form fields to convert strings to Python objects.\\n\\n For example, the value 'True' for a ``BooleanField`` is coerced to True.\\n \\\"\\\"\\\"\\n field_parts = self.field_name.split(\\\"__\\\") # Split field into list\\n\\n # Use the field parts to derive the model field instance\\n model = self.query.get_model()\\n query_name_map = introspector.get_query_name_map(\\n model_class=model,\\n get_fields=True,\\n get_m2m=True,\\n get_related_m2m=True,\\n get_related=True,\\n get_generic_relation=True,\\n )\\n for index, part in enumerate(field_parts):\\n if index == len(field_parts) - 1:\\n final_part = field_parts[-1]\\n model_field_instance = model._meta.get_field(final_part)\\n\\n # For non-RelatedFields use the model field's form field to\\n # coerce the value to a Python object\\n if not isinstance(model_field_instance, RelatedField):\\n # Skip validation for containment filters since the value may not be valid.\\n if self.lookup in [\\\"contains\\\", \\\"icontains\\\"]:\\n return value\\n # Runs the Field.clean() method to validate the value, this\\n # is required to run the custom validators declared on the\\n # Model field.\\n model_field_instance.clean(value, model)\\n # We must check if ``fields_for_model()`` Return the field\\n # we are considering. For example ``AutoField`` returns\\n # None for its form field and thus will not be in the\\n # dictionary returned by ``fields_for_model()``.\\n form_field_instance = fields_for_model(model).get(final_part)\\n if form_field_instance:\\n widget_value = form_field_instance.widget.value_from_datadict(\\n data={final_part: value}, files={}, name=final_part\\n )\\n # Set ``required`` to False to allow empty values\\n form_field_instance.required = False\\n return form_field_instance.clean(widget_value)\\n else:\\n return value\\n elif part in query_name_map:\\n # Set the next model and query name map to work with\\n model = query_name_map[part]\\n query_name_map = introspector.get_query_name_map(\\n model_class=model,\\n get_fields=True,\\n get_m2m=True,\\n get_related_m2m=True,\\n get_related=True,\\n get_generic_relation=True,\\n )\\n return value\\n\\n def get_value_as_list(self, value):\\n try:\\n # `ast.literal_eval()` allows to safely evaluate Python expressions\\n return ast.literal_eval(value)\\n except SyntaxError:\\n return []\\n\\n def get_q(self, runtime_value=None, user=None):\\n value = runtime_value or self.value\\n if not value:\\n return\\n\\n if value == BooleanSelect.ALL_CHOICE_VALUE:\\n return\\n\\n # Hack to support special values for date filtering, see #9049\\n if value in [choice[0] for choice in DATE_FILTER_CHOICES]:\\n value = DateFieldFilterSelect().value_from_datadict(\\n data={\\\"value\\\": value}, files=None, name=\\\"value\\\"\\n )\\n\\n left_hand_side = f\\\"{self.field_name}__{self.lookup}\\\"\\n\\n # The in lookup is special because it must parse a comma-separated string\\n if self.lookup == \\\"in\\\":\\n right_hand_side = self.get_value_as_list(value)\\n\\n elif self.lookup == \\\"descendant\\\":\\n model_class = self.query.content_type.model_class()\\n root_instance = get_by_reporting_key(model_class, self.dataspace, value)\\n if not root_instance:\\n return\\n left_hand_side = \\\"id__in\\\"\\n right_hand_side = root_instance.get_descendant_ids()\\n\\n elif self.lookup == \\\"product_descendant\\\":\\n from product_portfolio.models import Product\\n\\n # Requires a `user` to be provided for secured Product scoping\\n product_secured_qs = Product.objects.get_queryset(user)\\n product = get_by_reporting_key(product_secured_qs, self.dataspace, value)\\n if not product:\\n return\\n left_hand_side = \\\"id__in\\\"\\n right_hand_side = product.get_merged_descendant_ids()\\n\\n elif self.lookup == \\\"isnull\\\":\\n right_hand_side = ISNULL_LOOKUP_CHOICES.get(value, None)\\n # WARNING '== None' matters as False is a valid value!\\n if right_hand_side is None:\\n return\\n\\n elif self.lookup == \\\"isempty\\\":\\n if bool(ISNULL_LOOKUP_CHOICES.get(value, False)):\\n left_hand_side = f\\\"{self.field_name}__in\\\"\\n right_hand_side = [\\\"\\\", [], {}] # Support for JSONfield\\n else:\\n # Using \\\"greater than\\\" as a workaround to filter by non-empty values.\\n left_hand_side = f\\\"{self.field_name}__gt\\\"\\n right_hand_side = \\\"\\\"\\n\\n elif value == \\\"None\\\":\\n right_hand_side = None\\n\\n else:\\n right_hand_side = self.get_coerced_value(value)\\n\\n q_object = Q(**{left_hand_side: right_hand_side})\\n\\n return ~q_object if self.negate else q_object\"\n },\n {\n \"identifier\": \"LayoutAssignedCard\",\n \"path\": \"reporting/models.py\",\n \"snippet\": \"class LayoutAssignedCard(DataspacedModel):\\n layout = models.ForeignKey(\\n \\\"reporting.CardLayout\\\",\\n on_delete=models.CASCADE,\\n )\\n card = models.ForeignKey(\\n \\\"reporting.Card\\\",\\n on_delete=models.CASCADE,\\n )\\n seq = models.PositiveSmallIntegerField(\\n default=0,\\n db_index=True,\\n )\\n\\n class Meta:\\n unique_together = (\\\"dataspace\\\", \\\"uuid\\\")\\n ordering = [\\\"seq\\\"]\"\n },\n {\n \"identifier\": \"OrderField\",\n \"path\": \"reporting/models.py\",\n \"snippet\": \"class OrderField(DataspacedModel):\\n query = models.ForeignKey(\\n to=\\\"reporting.Query\\\",\\n on_delete=models.CASCADE,\\n related_name=\\\"order_fields\\\",\\n )\\n\\n field_name = models.TextField()\\n\\n SORT_CHOICES = (\\n (\\\"ascending\\\", \\\"ascending\\\"),\\n (\\\"descending\\\", \\\"descending\\\"),\\n )\\n\\n sort = models.TextField(\\n choices=SORT_CHOICES,\\n default=\\\"ascending\\\",\\n )\\n\\n seq = models.PositiveSmallIntegerField()\\n\\n class Meta:\\n unique_together = (\\\"dataspace\\\", \\\"uuid\\\")\\n ordering = (\\\"seq\\\",)\\n\\n def __str__(self):\\n return f\\\"<{self.query.name}>: ({self.seq}) {self.field_name} {self.sort}\\\"\\n\\n def save(self, *args, **kwargs):\\n self.dataspace = self.query.dataspace\\n super().save(*args, **kwargs)\"\n },\n {\n \"identifier\": \"Query\",\n \"path\": \"reporting/models.py\",\n \"snippet\": \"class Query(HistoryFieldsMixin, DataspacedModel):\\n name = models.CharField(\\n max_length=100,\\n help_text=_(\\\"A unique, descriptive title for your query.\\\"),\\n )\\n\\n description = models.TextField(\\n blank=True,\\n help_text=_(\\\"The purpose of your query.\\\"),\\n )\\n\\n content_type = models.ForeignKey(\\n to=ContentType,\\n on_delete=models.PROTECT,\\n limit_choices_to=CT_LIMIT,\\n verbose_name=_(\\\"object type\\\"),\\n help_text=_(\\n \\\"Choose the primary data source for your query: licenses, components, \\\" \\\"or owners.\\\"\\n ),\\n )\\n\\n OPERATOR_CHOICES = (\\n (\\\"and\\\", \\\"and\\\"),\\n (\\\"or\\\", \\\"or\\\"),\\n )\\n\\n operator = models.CharField(\\n max_length=5,\\n choices=OPERATOR_CHOICES,\\n default=\\\"and\\\",\\n help_text=_(\\n \\\"If you define more that one Filter for your query, indicate \\\"\\n 'if all (\\\"and\\\") or any (\\\"or\\\") of the Filter conditions must be true.'\\n ),\\n )\\n\\n objects = DataspacedManager.from_queryset(QueryQuerySet)()\\n\\n class Meta:\\n unique_together = ((\\\"dataspace\\\", \\\"name\\\"), (\\\"dataspace\\\", \\\"uuid\\\"))\\n ordering = (\\\"name\\\",)\\n verbose_name_plural = _(\\\"queries\\\")\\n\\n def __str__(self):\\n return f\\\"{self.name} ({self.content_type.model})\\\"\\n\\n def get_model(self):\\n return self.content_type.model_class()\\n\\n def get_qs(self, runtime_value_map=None, user=None):\\n \\\"\\\"\\\"\\n Return a QuerySet created using the assigned Filters.\\n The returned QuerySet is not yet evaluated.\\n Providing `user` is required for \\\"secured\\\" Model Managers.\\n \\\"\\\"\\\"\\n if runtime_value_map is None:\\n runtime_value_map = {}\\n\\n model = self.get_model()\\n manager = model._default_manager\\n\\n q_objects = []\\n for filter_ in self.filters.all():\\n runtime_value = runtime_value_map.get(filter_, {}).get(\\\"value\\\", None)\\n q_object = filter_.get_q(runtime_value, user)\\n if q_object:\\n q_objects.append(q_object)\\n\\n if not q_objects: # Return nothing rather than everything when no valid filters\\n return manager.none()\\n\\n order_fields = []\\n for order_field in self.order_fields.all():\\n prefix = \\\"-\\\" if order_field.sort == \\\"descending\\\" else \\\"\\\"\\n order_fields.append(f\\\"{prefix}{order_field.field_name}\\\")\\n\\n if not order_fields: # Force order by primary_key to prevent UnorderedObjectListWarning\\n order_fields = [model._meta.pk.name]\\n\\n if is_secured(manager):\\n qs = manager.get_queryset(user)\\n elif hasattr(manager, \\\"product_secured\\\"): # Special case for the Request manager\\n qs = manager.product_secured(user)\\n else:\\n qs = manager.scope(self.dataspace)\\n\\n qs = secure_queryset_relational_fields(qs, user)\\n\\n operator_type = operator.or_ if self.operator == \\\"or\\\" else operator.and_\\n return qs.filter(reduce(operator_type, q_objects)).order_by(*order_fields).distinct()\\n\\n def is_valid(self):\\n \\\"\\\"\\\"Return True if the Query can be executed without any Exceptions.\\\"\\\"\\\"\\n # Warning: do not use count() or exists() since it bypass the validation for order_by()\\n # Forcing evaluation with len() but slicing with [:1] for performance\\n try:\\n len(self.get_qs()[:1])\\n except Exception:\\n return False\\n return True\\n\\n @staticmethod\\n def get_extra_relational_fields():\\n return [\\\"filters\\\", \\\"order_fields\\\"]\\n\\n def get_order_list_for_url(self, request, model_admin):\\n \\\"\\\"\\\"\\n Use the order_fields set on the Query instance with the list_display\\n of the Query.content_type ModelAdmin class to generate Order\\n parameters in the changelist link. If an order_field is not part of\\n the list_display of the target changelist, it will be ignored.\\n \\\"\\\"\\\"\\n list_display = get_changelist_list_display(request, model_admin)\\n list_display_order_fields = [\\n get_ordering_field(model_admin, field_name) for field_name in list_display\\n ]\\n\\n order_list = []\\n for order_field in self.order_fields.all():\\n if order_field.field_name in list_display_order_fields:\\n index = list_display_order_fields.index(order_field.field_name)\\n prefix = \\\"-\\\" if order_field.sort == \\\"descending\\\" else \\\"\\\"\\n order_list.append(f\\\"{prefix}{index}\\\")\\n\\n return order_list\\n\\n def get_changelist_url(self):\\n \\\"\\\"\\\"Return the changelist URL of the related Model.\\\"\\\"\\\"\\n opts = self.get_model()._meta\\n with suppress(NoReverseMatch):\\n return reverse(f\\\"admin:{opts.app_label}_{opts.model_name}_changelist\\\")\\n\\n def get_changelist_url_with_filters(self):\\n \\\"\\\"\\\"Return the changelist URL of the related Model including a filter for this Query.\\\"\\\"\\\"\\n from reporting.filters import ReportingQueryListFilter\\n\\n params = {ReportingQueryListFilter.parameter_name: self.id}\\n url = self.get_changelist_url()\\n if url:\\n return f\\\"{url}?{urlencode(params)}\\\"\"\n },\n {\n \"identifier\": \"Report\",\n \"path\": \"reporting/models.py\",\n \"snippet\": \"class Report(HistoryFieldsMixin, DataspacedModel):\\n name = models.CharField(\\n max_length=100,\\n help_text=_(\\\"The title of your Report.\\\"),\\n )\\n\\n description = models.TextField(\\n blank=True,\\n help_text=_(\\n \\\"Provide a description of the report to explain its purpose \\\" \\\"to DejaCode users.\\\"\\n ),\\n )\\n\\n query = models.ForeignKey(\\n to=\\\"reporting.Query\\\",\\n on_delete=models.PROTECT,\\n help_text=_(\\\"Choose one of your Queries to select the data for your report.\\\"),\\n )\\n\\n column_template = models.ForeignKey(\\n to=\\\"reporting.ColumnTemplate\\\",\\n on_delete=models.PROTECT,\\n help_text=_(\\n \\\"Choose one of your Column templates to define the data \\\" \\\"columns for your report.\\\"\\n ),\\n )\\n\\n user_available = models.BooleanField(\\n default=False,\\n help_text=_(\\\"Check this to provide access to non-administrative application users.\\\"),\\n )\\n\\n report_context = models.TextField(\\n blank=True,\\n default=\\\"This DejaCode report was generated from Dataspace \\\"\\n \\\"{{dataspace}} on {{date-time}} by {{user}}.\\\",\\n help_text=_(\\n \\\"The text in this field will appear at the top of your generated \\\"\\n \\\"report. You may want to describe the purpose of the report in this field.\\\"\\n ),\\n )\\n\\n group = models.CharField(\\n max_length=100,\\n blank=True,\\n help_text=_(\\\"Use this field to group reports.\\\"),\\n )\\n\\n objects = DataspacedManager.from_queryset(ReportQuerySet)()\\n\\n class Meta:\\n unique_together = ((\\\"dataspace\\\", \\\"name\\\"), (\\\"dataspace\\\", \\\"uuid\\\"))\\n ordering = (\\\"name\\\",)\\n\\n def __str__(self):\\n return self.name\\n\\n def save(self, *args, **kwargs):\\n self.dataspace = self.query.dataspace\\n super().save(*args, **kwargs)\\n\\n def get_absolute_url(self):\\n return reverse(\\\"reporting:report_details\\\", args=[self.uuid])\\n\\n def get_output(self, queryset=None, user=None, include_view_link=False):\\n # Checking if the parameter is given rather than the boolean value of the QuerySet\\n if queryset is None:\\n queryset = self.query.get_qs(user=user)\\n\\n icon = format_html('<i class=\\\"fas fa-external-link-alt\\\"></i>')\\n rows = []\\n for instance in queryset:\\n cells = [\\n field.get_value_for_instance(instance, user=user)\\n for field in self.column_template.fields.all()\\n ]\\n if include_view_link:\\n cells.insert(\\n 0, instance.get_absolute_link(value=icon, title=\\\"View\\\", target=\\\"_blank\\\")\\n )\\n rows.append(cells)\\n return rows\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from django.contrib import admin\nfrom django.contrib.admin.views.main import ORDER_VAR\nfrom django.contrib.contenttypes.models import ContentType\nfrom django.core.exceptions import NON_FIELD_ERRORS\nfrom django.db.models import PositiveSmallIntegerField\nfrom django.forms import HiddenInput\nfrom django.utils.html import format_html\nfrom django.utils.http import urlencode\nfrom django.utils.translation import gettext_lazy as _\nfrom dje.admin import DataspacedAdmin\nfrom dje.admin import DataspacedFKMixin\nfrom dje.admin import dejacode_site\nfrom dje.admin import get_additional_information_fieldset\nfrom dje.client_data import add_client_data\nfrom dje.filters import MissingInFilter\nfrom dje.list_display import AsJoinList\nfrom dje.list_display import AsLink\nfrom dje.utils import CHANGELIST_LINK_TEMPLATE\nfrom dje.utils import queryset_to_html_list\nfrom reporting.filters import ReportingQueryListFilter\nfrom reporting.forms import ColumnTemplateForm\nfrom reporting.forms import QueryForm\nfrom reporting.forms import ReportForm\nfrom reporting.forms import ReportMassUpdateForm\nfrom reporting.forms import get_model_data_for_column_template\nfrom reporting.forms import get_model_data_for_order_field\nfrom reporting.forms import get_model_data_for_query\nfrom reporting.inlines import ColumnTemplateAssignedFieldInline\nfrom reporting.inlines import FilterInline\nfrom reporting.inlines import OrderFieldInline\nfrom reporting.introspection import get_model_label\nfrom reporting.models import Card\nfrom reporting.models import CardLayout\nfrom reporting.models import ColumnTemplate\nfrom reporting.models import Filter\nfrom reporting.models import LayoutAssignedCard\nfrom reporting.models import OrderField\nfrom reporting.models import Query\nfrom reporting.models import Report"},"token_num":{"kind":"number","value":18290,"string":"18,290"},"cropped_code":{"kind":"string","value":" data = form.cleaned_data\n # The 'id' field is a ModelChoiceField which validates to a model instance\n id = form.cleaned_data.get(\"id\")\n if id:\n pk = id.pk\n\n d = {\n \"pk\": pk,\n \"field_name\": data.get(\"field_name\", \"\"),\n \"lookup\": data.get(\"lookup\", \"\"),\n \"value\": data.get(\"value\", \"\"),\n \"runtime_parameter\": data.get(\"runtime_parameter\", \"\"),\n \"negate\": data.get(\"negate\", \"\"),\n }\n filters.append(d)\n return filters\n\n @staticmethod\n def get_order_fields_as_dicts(request, forms):\n order_fields = []\n\n for form in forms:\n pk = None\n if request.method == \"GET\":\n data = form.initial\n pk = form.instance.pk\n if request.method == \"POST\":\n data = form.cleaned_data\n # The 'id' field is a ModelChoiceField which validates to a\n # model instance\n id = form.cleaned_data.get(\"id\")\n if id:\n pk = id.pk\n\n d = {\n \"pk\": pk,\n \"field_name\": data.get(\"field_name\", \"\"),\n \"seq\": data.get(\"seq\", \"\"),\n \"sort\": data.get(\"sort\", \"\"),\n }\n order_fields.append(d)\n return order_fields\n\n def _changeform_view(self, request, object_id, form_url, extra_context):\n response = super()._changeform_view(request, object_id, form_url, extra_context)\n\n if response.status_code == 200:\n if request.method == \"POST\" and \"_popup\" in request.GET:\n return response\n\n add_client_data(request, **self.get_client_data(request))\n\n inline_admin_formsets = response.context_data[\"inline_admin_formsets\"]\n filter_admin_formsets = [\n formset\n for formset in inline_admin_formsets\n if formset.opts.__class__ == FilterInline\n ]\n if not filter_admin_formsets:\n return response\n filter_formset = filter_admin_formsets[0].formset\n\n order_field_admin_formsets = [\n formset\n for formset in inline_admin_formsets\n if formset.opts.__class__ == OrderFieldInline\n ]\n if not order_field_admin_formsets:\n return response\n order_field_formset = order_field_admin_formsets[0].formset\n\n add_client_data(\n request,\n filter_formset_prefix=filter_formset.prefix,\n filter_formset_initial_form_count=filter_formset.initial_form_count(),\n filter_formset_has_errors=any(filter_formset.errors),\n filter_formset_all_errors=flatten_errors(filter_formset.errors),\n order_field_formset_prefix=order_field_formset.prefix,\n order_field_formset_initial_form_count=order_field_formset.initial_form_count(),\n filters=self.get_filters_as_dicts(request, filter_formset.forms),\n order_fields=self.get_order_fields_as_dicts(request, order_field_formset.forms),\n )\n\n return response\n\n\n@admin.register(ColumnTemplate, site=dejacode_site)\nclass ColumnTemplateAdmin(DataspacedAdmin):\n form = ColumnTemplateForm\n list_display = (\"name\", \"description\", \"content_type\", \"get_field_names\", \"get_dataspace\")\n list_filter = DataspacedAdmin.list_filter + (\n \"content_type\",\n MissingInFilter,\n )\n fieldsets = (\n (\"\", {\"fields\": (\"name\", \"description\", \"content_type\")}),\n get_additional_information_fieldset(),\n )\n search_fields = (\"name\",)\n inlines = (ColumnTemplateAssignedFieldInline,)\n change_form_template = \"admin/reporting/columntemplate/change_form.html\"\n\n long_description = (\n \"A Column template provides you with the ability to identify the data \"\n \"columns, with your own labels, to appear in a report using the column \"\n \"order that you specify. You can combine a column template with any \"\n \"query of the same object type (license, component, owner) to create \"\n \"your own Reports.\"\n )\n\n @admin.display(description=_(\"Assigned fields\"))\n def get_field_names(self, instance):\n field_names = [assigned_field.field_name for assigned_field in instance.fields.all()]\n return format_html(\"<br>\".join(field_names))\n\n def get_queryset(self, request):\n qs = super().get_queryset(request)\n return qs.select_related(\"content_type\").prefetch_related(\"fields\")\n\n def get_client_data(self, request):\n"},"all_code":{"kind":"string","value":"#\n# Copyright (c) nexB Inc. and others. All rights reserved.\n# DejaCode is a trademark of nexB Inc.\n# SPDX-License-Identifier: AGPL-3.0-only\n# See https://github.com/nexB/dejacode for support or download.\n# See https://aboutcode.org for more information about AboutCode FOSS projects.\n#\n\n\n\n\ndef get_content_type_map():\n return dict(\n [\n (c.pk, get_model_label(c.model_class()))\n for c in ContentType.objects.all()\n if c.model_class()\n ]\n )\n\n\ndef flatten_errors(formset_errors):\n \"\"\"\n Convert a FormSet.errors, which is a list of dicts, into a flat list of\n error messages.\n \"\"\"\n flattened = []\n for error_dict in formset_errors:\n for field_name, errors in error_dict.items():\n for error in errors.as_data():\n message = list(error)[0]\n if field_name != NON_FIELD_ERRORS:\n val = f'Field \"{field_name}\": {message}'\n else:\n val = message\n flattened.append(val)\n return flattened\n\n\n@admin.register(Query, site=dejacode_site)\nclass QueryAdmin(DataspacedAdmin):\n form = QueryForm\n change_form_template = \"admin/reporting/query/change_form.html\"\n # We are using an inline for ``Filter``, but are not rendering the standard\n # Django inline UI in favor of a custom Ember-based inline UI.\n inlines = [FilterInline, OrderFieldInline]\n fieldsets = (\n (\"\", {\"fields\": (\"name\", \"description\", \"content_type\", \"operator\")}),\n get_additional_information_fieldset(),\n (\"Preview\", {\"fields\": (\"get_preview\",)}),\n )\n readonly_fields = DataspacedAdmin.readonly_fields + (\"get_preview\",)\n list_display = (\"name\", \"description\", \"content_type\", \"operator\", \"get_dataspace\")\n list_filter = DataspacedAdmin.list_filter + (\n \"content_type\",\n MissingInFilter,\n )\n search_fields = (\"name\",)\n\n long_description = (\n \"A Query provides you with the ability to select data from application \"\n \"licenses, components, and owners using the criteria that meet your \"\n \"business requirements. You can access a changelist of the data you \"\n \"select using the Preview feature, and you can also combine a query \"\n \"with a column template to create your own Report.\"\n )\n\n def get_queryset(self, request):\n return (\n super()\n .get_queryset(request)\n .select_related(\n \"content_type\",\n )\n .prefetch_related(\n \"filters\",\n \"order_fields\",\n )\n )\n\n def get_object(self, request, object_id, from_field=None):\n \"\"\"\n Injects the `request` on the object instance.\n Required for `get_preview()`.\n \"\"\"\n obj = super().get_object(request, object_id, from_field)\n if obj:\n obj._request = request\n return obj\n\n @admin.display(description=_(\"Results\"))\n def get_preview(self, query_instance):\n \"\"\"\n Return a preview of the Query results.\n The logic starts with a count and will not eval/render the QuerySet\n if over 100 results.\n Between 1 and 100 results, a 5 items list will be display, next to a\n link to the changelist for the QuerySet. See #9248.\n \"\"\"\n if query_instance.filters.count() == 0:\n return \"No filters defined\"\n\n request = getattr(query_instance, \"_request\", None)\n if not request:\n return\n\n try:\n qs = query_instance.get_qs(user=request.user)\n qs_count = qs.count()\n except Exception as e:\n return f\"Error: {e}\"\n\n if not qs_count:\n return \"No results.\"\n\n model = query_instance.content_type.model_class()\n model_admin = dejacode_site._registry.get(model)\n\n if not model_admin: # Models like Request do not have a ModelAdmin.\n return f\"{qs_count} results.\"\n\n params = {ReportingQueryListFilter.parameter_name: query_instance.id}\n\n order_list = query_instance.get_order_list_for_url(request, model_admin)\n if order_list:\n params[ORDER_VAR] = \".\".join(order_list)\n\n if qs_count >= 100:\n url = query_instance.get_changelist_url()\n href = f\"{url}?{urlencode(params)}\"\n return format_html(\n CHANGELIST_LINK_TEMPLATE, href, qs_count, model._meta.verbose_name_plural\n )\n\n return queryset_to_html_list(qs, params, qs_limit=5)\n\n def get_query_options(self, request):\n \"\"\"\n Return a dictionary of Query options to be injected in the client_data\n and user for the \"Use a query as value\" list of choices.\n The QuerySet is reused from self.get_queryset() and scoped to the\n current object dataspace on edition, or on the current user dataspace\n on addition.\n \"\"\"\n # The object instance is set on the request in the DataspacedAdmin.get_form() method\n if request._object: # Edition\n dataspace = request._object.dataspace\n else: # Addition\n dataspace = request.user.dataspace\n\n queryset = self.get_queryset(request).scope(dataspace)\n\n return [\n {\n \"id\": query.pk,\n \"name\": query.name,\n \"content_type\": get_model_label(query.content_type.model_class()),\n }\n for query in queryset\n ]\n\n def get_client_data(self, request):\n return {\n \"model_data\": get_model_data_for_query(),\n \"order_field_model_data\": get_model_data_for_order_field(),\n \"content_type_map\": get_content_type_map(),\n \"lookups\": [\n {\n \"label\": v,\n \"value\": k,\n }\n for k, v in Filter.LOOKUP_CHOICES\n ],\n \"query_options\": self.get_query_options(request),\n \"sort_options\": [v for k, v in OrderField.SORT_CHOICES],\n }\n\n @staticmethod\n def get_filters_as_dicts(request, forms):\n filters = []\n\n for form in forms:\n pk = None\n if request.method == \"GET\":\n data = form.initial\n pk = form.instance.pk\n if request.method == \"POST\":\n data = form.cleaned_data\n # The 'id' field is a ModelChoiceField which validates to a model instance\n id = form.cleaned_data.get(\"id\")\n if id:\n pk = id.pk\n\n d = {\n \"pk\": pk,\n \"field_name\": data.get(\"field_name\", \"\"),\n \"lookup\": data.get(\"lookup\", \"\"),\n \"value\": data.get(\"value\", \"\"),\n \"runtime_parameter\": data.get(\"runtime_parameter\", \"\"),\n \"negate\": data.get(\"negate\", \"\"),\n }\n filters.append(d)\n return filters\n\n @staticmethod\n def get_order_fields_as_dicts(request, forms):\n order_fields = []\n\n for form in forms:\n pk = None\n if request.method == \"GET\":\n data = form.initial\n pk = form.instance.pk\n if request.method == \"POST\":\n data = form.cleaned_data\n # The 'id' field is a ModelChoiceField which validates to a\n # model instance\n id = form.cleaned_data.get(\"id\")\n if id:\n pk = id.pk\n\n d = {\n \"pk\": pk,\n \"field_name\": data.get(\"field_name\", \"\"),\n \"seq\": data.get(\"seq\", \"\"),\n \"sort\": data.get(\"sort\", \"\"),\n }\n order_fields.append(d)\n return order_fields\n\n def _changeform_view(self, request, object_id, form_url, extra_context):\n response = super()._changeform_view(request, object_id, form_url, extra_context)\n\n if response.status_code == 200:\n if request.method == \"POST\" and \"_popup\" in request.GET:\n return response\n\n add_client_data(request, **self.get_client_data(request))\n\n inline_admin_formsets = response.context_data[\"inline_admin_formsets\"]\n filter_admin_formsets = [\n formset\n for formset in inline_admin_formsets\n if formset.opts.__class__ == FilterInline\n ]\n if not filter_admin_formsets:\n return response\n filter_formset = filter_admin_formsets[0].formset\n\n order_field_admin_formsets = [\n formset\n for formset in inline_admin_formsets\n if formset.opts.__class__ == OrderFieldInline\n ]\n if not order_field_admin_formsets:\n return response\n order_field_formset = order_field_admin_formsets[0].formset\n\n add_client_data(\n request,\n filter_formset_prefix=filter_formset.prefix,\n filter_formset_initial_form_count=filter_formset.initial_form_count(),\n filter_formset_has_errors=any(filter_formset.errors),\n filter_formset_all_errors=flatten_errors(filter_formset.errors),\n order_field_formset_prefix=order_field_formset.prefix,\n order_field_formset_initial_form_count=order_field_formset.initial_form_count(),\n filters=self.get_filters_as_dicts(request, filter_formset.forms),\n order_fields=self.get_order_fields_as_dicts(request, order_field_formset.forms),\n )\n\n return response\n\n\n@admin.register(ColumnTemplate, site=dejacode_site)\nclass ColumnTemplateAdmin(DataspacedAdmin):\n form = ColumnTemplateForm\n list_display = (\"name\", \"description\", \"content_type\", \"get_field_names\", \"get_dataspace\")\n list_filter = DataspacedAdmin.list_filter + (\n \"content_type\",\n MissingInFilter,\n )\n fieldsets = (\n (\"\", {\"fields\": (\"name\", \"description\", \"content_type\")}),\n get_additional_information_fieldset(),\n )\n search_fields = (\"name\",)\n inlines = (ColumnTemplateAssignedFieldInline,)\n change_form_template = \"admin/reporting/columntemplate/change_form.html\"\n\n long_description = (\n \"A Column template provides you with the ability to identify the data \"\n \"columns, with your own labels, to appear in a report using the column \"\n \"order that you specify. You can combine a column template with any \"\n \"query of the same object type (license, component, owner) to create \"\n \"your own Reports.\"\n )\n\n @admin.display(description=_(\"Assigned fields\"))\n def get_field_names(self, instance):\n field_names = [assigned_field.field_name for assigned_field in instance.fields.all()]\n return format_html(\"<br>\".join(field_names))\n\n def get_queryset(self, request):\n qs = super().get_queryset(request)\n return qs.select_related(\"content_type\").prefetch_related(\"fields\")\n\n def get_client_data(self, request):"},"next_line":{"kind":"string","value":" model_data = get_model_data_for_column_template(request.user.dataspace)"},"gold_snippet_index":{"kind":"number","value":15,"string":"15"},"created_at":{"kind":"string","value":"2023-12-07 16:57:42+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5977,"cells":{"repo_name":{"kind":"string","value":"wusize/CLIM"},"file_path":{"kind":"string","value":"src/open_clip/model.py"},"context":{"kind":"list like","value":[{"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: int,\n config: PretrainedConfig = None,\n pooler_type: str = None,\n proj: str = None,\n pretrained: bool = True,\n output_tokens: bool = False,\n ):\n super().__init__()\n self.output_tokens = output_tokens\n self.output_dim = output_dim\n\n # TODO: find better way to get this information\n uses_transformer_pooler = (pooler_type == \"cls_pooler\")\n\n if transformers is None:\n raise RuntimeError(\"Please `pip install transformers` to use pre-trained HuggingFace models\")\n if config is None:\n self.config = AutoConfig.from_pretrained(model_name_or_path)\n create_func, model_args = (AutoModel.from_pretrained, model_name_or_path) if pretrained else (\n AutoModel.from_config, self.config)\n # TODO: do all model configs have this attribute? PretrainedConfig does so yes??\n if hasattr(self.config, \"is_encoder_decoder\") and self.config.is_encoder_decoder:\n self.transformer = create_func(model_args)\n self.transformer = self.transformer.encoder\n else:\n self.transformer = create_func(model_args, add_pooling_layer=uses_transformer_pooler)\n else:\n self.config = config\n self.transformer = AutoModel.from_config(config)\n if pooler_type is None: # get default arch pooler\n pooler_type = (arch_dict[self.config.model_type][\"pooler\"])\n \n self.pooler = _POOLERS[pooler_type]()\n\n d_model = getattr(self.config, arch_dict[self.config.model_type][\"config_names\"][\"width\"])\n if (d_model == output_dim) and (proj is None): # do we always need a proj?\n self.proj = nn.Identity()\n elif proj == 'linear':\n self.proj = nn.Linear(d_model, output_dim, bias=False)\n elif proj == 'mlp':\n hidden_size = (d_model + output_dim) // 2\n self.proj = nn.Sequential(\n nn.Linear(d_model, hidden_size, bias=False),\n nn.GELU(),\n nn.Linear(hidden_size, output_dim, bias=False),\n )\n\n def forward(self, x: TensorType):\n attn_mask = (x != self.config.pad_token_id).long()\n out = self.transformer(input_ids=x, attention_mask=attn_mask)\n pooled_out = self.pooler(out, attn_mask)\n projected = self.proj(pooled_out)\n\n seq_len = out.last_hidden_state.shape[1]\n tokens = (\n out.last_hidden_state[:, torch.arange(seq_len) != self.pooler.cls_token_position, :] \n if type(self.pooler) == ClsPooler \n else out.last_hidden_state\n )\n \n if self.output_tokens:\n return projected, tokens\n return projected\n\n def lock(self, unlocked_layers: int = 0, freeze_layer_norm: bool = True):\n if not unlocked_layers: # full freezing\n for n, p in self.transformer.named_parameters():\n p.requires_grad = (not freeze_layer_norm) if \"LayerNorm\" in n.split(\".\") else False\n return\n\n encoder = self.transformer.encoder if hasattr(self.transformer, 'encoder') else self.transformer\n layer_list = getattr(encoder, arch_dict[self.config.model_type][\"config_names\"][\"layer_attr\"])\n print(f\"Unlocking {unlocked_layers}/{len(layer_list) + 1} layers of hf model\")\n embeddings = getattr(\n self.transformer, arch_dict[self.config.model_type][\"config_names\"][\"token_embeddings_attr\"])\n modules = [embeddings, *layer_list][:-unlocked_layers]\n # freeze layers\n for module in modules:\n for n, p in module.named_parameters():\n p.requires_grad = (not freeze_layer_norm) if \"LayerNorm\" in n.split(\".\") else False\n\n @torch.jit.ignore\n def set_grad_checkpointing(self, enable=True):\n self.transformer.gradient_checkpointing_enable()\n\n def init_parameters(self):\n pass"},{"identifier":"ModifiedResNet","path":"src/open_clip/modified_resnet.py","snippet":"class ModifiedResNet(nn.Module):\n \"\"\"\n A ResNet class that is similar to torchvision's but contains the following changes:\n - There are now 3 \"stem\" convolutions as opposed to 1, with an average pool instead of a max pool.\n - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1\n - The final pooling layer is a QKV attention instead of an average pool\n \"\"\"\n\n def __init__(self, layers, output_dim, heads, image_size=224, width=64,\n freeze_output=True,\n freeze_all_bns=True):\n super().__init__()\n self.output_dim = output_dim\n self.image_size = image_size\n self.freeze_output = freeze_output\n self.freeze_all_bns = freeze_all_bns\n # the 3-layer stem\n self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)\n self.bn1 = nn.BatchNorm2d(width // 2)\n self.act1 = nn.ReLU(inplace=True)\n self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False)\n self.bn2 = nn.BatchNorm2d(width // 2)\n self.act2 = nn.ReLU(inplace=True)\n self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)\n self.bn3 = nn.BatchNorm2d(width)\n self.act3 = nn.ReLU(inplace=True)\n self.avgpool = nn.AvgPool2d(2)\n\n # residual layers\n self._inplanes = width # this is a *mutable* variable used during construction\n self.layer1 = self._make_layer(width, layers[0])\n self.layer2 = self._make_layer(width * 2, layers[1], stride=2)\n self.layer3 = self._make_layer(width * 4, layers[2], stride=2)\n self.layer4 = self._make_layer(width * 8, layers[3], stride=2)\n\n embed_dim = width * 32 # the ResNet feature dimension\n self.attnpool = AttentionPool2d(image_size // 32, embed_dim, heads, output_dim, freeze_output)\n self.attnpool_input_size = image_size // 32\n\n def _make_layer(self, planes, blocks, stride=1):\n layers = [Bottleneck(self._inplanes, planes, stride)]\n\n self._inplanes = planes * Bottleneck.expansion\n for _ in range(1, blocks):\n layers.append(Bottleneck(self._inplanes, planes))\n\n return nn.Sequential(*layers)\n\n def lock(self, unlocked_groups=0, freeze_bn_stats=True):\n assert freeze_bn_stats\n def _lock(module):\n for param in module.parameters():\n param.requires_grad = False\n if freeze_bn_stats:\n freeze_batch_norm_2d(module)\n module.eval()\n\n freeze_at = 5 - unlocked_groups\n print(f'Freeze the resnet at {freeze_at}', flush=True)\n\n if freeze_at >= 1: # stem\n _lock(self.conv1)\n _lock(self.bn1)\n _lock(self.conv2)\n _lock(self.bn2)\n _lock(self.conv3)\n _lock(self.bn3)\n # each stage is a torch.nn.modules.container.Sequential\n for idx, stage in enumerate([self.layer1, self.layer2, self.layer3, self.layer4], start=2):\n if freeze_at >= idx:\n for block in stage.children(): # each block is a Bottleneck\n _lock(block)\n if self.freeze_all_bns:\n print(f'Freeze all bn layers', flush=True) # TODO: study if this is necessary\n freeze_batch_norm_2d(self)\n\n @torch.jit.ignore\n def set_grad_checkpointing(self, enable=True):\n # FIXME support for non-transformer\n pass\n\n def stem(self, x):\n x = self.act1(self.bn1(self.conv1(x)))\n x = self.act2(self.bn2(self.conv2(x)))\n x = self.act3(self.bn3(self.conv3(x)))\n x = self.avgpool(x)\n return x\n\n def forward(self, x):\n with torch.no_grad():\n x = self.stem(x)\n x = self.layer1(x)\n x = self.layer2(x)\n x = self.layer3(x)\n x = self.layer4(x)\n x = self.attnpool(x)\n\n return x\n\n @staticmethod\n def _denormalize_boxes(normed_boxes, x):\n h, w = x.shape[-2:]\n denormed_boxes = []\n for boxes in normed_boxes:\n new_boxes = boxes.clone() # FIXME: do not change the value in normed_boxes!\n new_boxes[:, [0, 2]] *= w\n new_boxes[:, [1, 3]] *= h\n denormed_boxes.append(new_boxes)\n return denormed_boxes\n\n def extract_roi_features(self, x, normed_boxes, extract_type='v2'):\n if extract_type == 'v1':\n return self._extract_roi_features_v1(x, normed_boxes)\n else:\n assert extract_type == 'v2'\n return self._extract_roi_features_v2(x, normed_boxes)\n\n def mask_attn_pool(self, image, masks):\n return self.mask_pool(image, masks)\n\n def mask_pool(self, image, masks):\n x = self.stem(image)\n x = self.layer1(x)\n x = self.layer2(x)\n x = self.layer3(x)\n x = self.layer4(x)\n\n feature_map = self.attnpool.forward_dense(x)\n feature_map = F.normalize(feature_map, dim=1) # remember to normalize!\n\n feature_map = feature_map.flatten(-2, -1) # bs, c, h*w\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\n masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w\n feature_map = torch.repeat_interleave(\n feature_map, torch.tensor(num_masks_per_image, device=feature_map.device), dim=0)\n features = (feature_map * masks[:, None]).sum(-1) / (masks.sum(1, keepdim=True) + 1e-12)\n\n return features\n\n def _extract_roi_features_v1(self, x, normed_boxes, **kwargs):\n with torch.no_grad():\n x = self.stem(x)\n x = self.layer1(x)\n x = self.layer2(x)\n x = self.layer3(x)\n x = self.layer4(x)\n\n x = self.attnpool.forward_dense(x)\n x = F.normalize(x, dim=1) # remember to normalize!\n # TODO: debug\n roi_feats = roi_align(x, self._denormalize_boxes(normed_boxes, x),\n (1, 1), 1.0, -1, True)[:, :, 0, 0]\n return roi_feats\n\n def _extract_roi_features_v2(self, x, normed_boxes, **kwargs):\n with torch.no_grad():\n x = self.stem(x)\n x = self.layer1(x)\n x = self.layer2(x)\n x = self.layer3(x)\n x = self.layer4(x) # only the last layer is finetuned in our implementation\n\n tar_size = self.attnpool_input_size\n # TODO: debug\n roi_feats = roi_align(x, self._denormalize_boxes(normed_boxes, x),\n (tar_size, tar_size), 1.0, -1, True)\n\n roi_feats = self.attnpool(roi_feats)\n\n return roi_feats\n\n def encode_dense(self, x, keep_shape=True):\n x = self.stem(x)\n x = self.layer1(x)\n x = self.layer2(x)\n x = self.layer3(x)\n x = self.layer4(x)\n\n feature_map = self.attnpool.forward_dense(x)\n feature_map = F.normalize(feature_map, dim=1) # remember to normalize!\n\n return feature_map"},{"identifier":"TimmModel","path":"src/open_clip/timm_model.py","snippet":"class TimmModel(nn.Module):\n \"\"\" timm model adapter\n \"\"\"\n\n def __init__(\n self,\n model_name,\n embed_dim,\n image_size=224,\n pool='avg',\n proj='linear',\n proj_bias=False,\n drop=0.,\n drop_path=None,\n patch_drop=None,\n pretrained=False,\n ):\n super().__init__()\n if timm is None:\n raise RuntimeError(\"Please `pip install timm` to use timm models.\")\n self.image_size = to_2tuple(image_size)\n\n # setup kwargs that may not be common across all models\n timm_kwargs = {}\n if drop_path is not None:\n timm_kwargs['drop_path_rate'] = drop_path\n if patch_drop is not None:\n timm_kwargs['patch_drop_rate'] = patch_drop\n\n custom_pool = pool in ('abs_attn', 'rot_attn')\n if not proj and not custom_pool:\n # use network classifier head as projection if no proj specified and no custom pooling used\n self.trunk = timm.create_model(\n model_name,\n num_classes=embed_dim,\n global_pool=pool,\n pretrained=pretrained,\n **timm_kwargs,\n )\n prev_chs = embed_dim\n else:\n self.trunk = timm.create_model(\n model_name,\n pretrained=pretrained,\n **timm_kwargs,\n )\n feat_size = self.trunk.default_cfg.get('pool_size', None)\n feature_ndim = 1 if not feat_size else 2\n if custom_pool:\n assert feature_ndim == 2\n # if attn pooling used, remove both classifier and default pool\n self.trunk.reset_classifier(0, global_pool='')\n else:\n # reset global pool if pool config set, otherwise leave as network default\n reset_kwargs = dict(global_pool=pool) if pool else {}\n self.trunk.reset_classifier(0, **reset_kwargs)\n prev_chs = self.trunk.num_features\n\n head_layers = OrderedDict()\n\n # Add custom pooling to head\n if pool == 'abs_attn':\n head_layers['pool'] = AbsAttentionPool2d(prev_chs, feat_size=feat_size, out_features=embed_dim)\n prev_chs = embed_dim\n elif pool == 'rot_attn':\n head_layers['pool'] = RotAttentionPool2d(prev_chs, out_features=embed_dim)\n prev_chs = embed_dim\n\n # NOTE attention pool ends with a projection layer, so proj should usually be set to '' if such pooling is used\n if proj == 'linear':\n head_layers['drop'] = nn.Dropout(drop)\n head_layers['proj'] = nn.Linear(prev_chs, embed_dim, bias=proj_bias)\n elif proj == 'mlp':\n head_layers['mlp'] = Mlp(prev_chs, 2 * embed_dim, embed_dim, drop=(drop, 0), bias=(True, proj_bias))\n else:\n assert not proj, f'Unknown projection type {proj}.'\n\n self.head = nn.Sequential(head_layers)\n\n def lock(self, unlocked_groups=0, freeze_bn_stats=False):\n \"\"\" lock modules\n Args:\n unlocked_groups (int): leave last n layer groups unlocked (default: 0)\n \"\"\"\n if not unlocked_groups:\n # lock full model\n for param in self.trunk.parameters():\n param.requires_grad = False\n if freeze_bn_stats:\n freeze_batch_norm_2d(self.trunk)\n else:\n # NOTE: partial freeze requires latest timm (master) branch and is subject to change\n try:\n # FIXME import here until API stable and in an official release\n from timm.models.helpers import group_parameters, group_modules\n except ImportError:\n raise RuntimeError(\n 'Please install latest timm `pip install git+https://github.com/rwightman/pytorch-image-models`')\n matcher = self.trunk.group_matcher()\n gparams = group_parameters(self.trunk, matcher)\n max_layer_id = max(gparams.keys())\n max_layer_id = max_layer_id - unlocked_groups\n for group_idx in range(max_layer_id + 1):\n group = gparams[group_idx]\n for param in group:\n self.trunk.get_parameter(param).requires_grad = False\n if freeze_bn_stats:\n gmodules = group_modules(self.trunk, matcher, reverse=True)\n gmodules = {k for k, v in gmodules.items() if v <= max_layer_id}\n freeze_batch_norm_2d(self.trunk, gmodules)\n\n @torch.jit.ignore\n def set_grad_checkpointing(self, enable=True):\n try:\n self.trunk.set_grad_checkpointing(enable)\n except Exception as e:\n logging.warning('grad checkpointing not supported for this timm image tower, continuing without...')\n\n def forward(self, x):\n x = self.trunk(x)\n x = self.head(x)\n return x\n\n @staticmethod\n def _denormalize_boxes(normed_boxes, x):\n h, w = x.shape[-2:]\n denormed_boxes = []\n for boxes in normed_boxes:\n new_boxes = boxes.clone() # FIXME: do not change the value in normed_boxes!\n new_boxes[:, [0, 2]] *= w\n new_boxes[:, [1, 3]] *= h\n denormed_boxes.append(new_boxes)\n return denormed_boxes\n\n def _extract_roi_features_v1(self, x, normed_boxes, **kwargs):\n h, w = x.shape[-2:]\n x = self.trunk.forward_features(x)\n h_f, w_f = x.shape[-2:]\n tar_h = (self.image_size[0] * h_f) // h\n tar_w = (self.image_size[1] * w_f) // w\n x = roi_align(x, self._denormalize_boxes(normed_boxes, x), (tar_h, tar_w),\n 1.0, -1, True)\n\n x = self.trunk.forward_head(x)\n x = self.head(x)\n\n return x\n\n def encode_dense(self, x, **kwargs):\n x = self.trunk.forward_features(x)\n x = self.dense_trunk_head(x)\n x = self.head(x)\n x = x.permute(0, 3, 1, 2)\n\n return x\n\n def dense_trunk_head(self, x):\n x = self.trunk.head.norm(x)\n x = x.permute(0, 2, 3, 1)\n x = self.trunk.head.drop(x)\n # x = x.permute(0, 3, 1, 2)\n\n return x\n\n def mask_pool(self, image, masks):\n feature_map = self.encode_dense(image)\n feature_map = F.normalize(feature_map, dim=1) # remember to normalize!\n feature_map = feature_map.flatten(-2, -1) # bs, c, h*w\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\n masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w\n feature_map = torch.repeat_interleave(\n feature_map, torch.tensor(num_masks_per_image, device=feature_map.device), dim=0)\n features = (feature_map * masks[:, None]).sum(-1) / (masks.sum(1, keepdim=True) + 1e-12)\n\n return features\n\n def extract_roi_features(self, x, normed_boxes, extract_type='v1'):\n assert extract_type == \"v1\"\n if extract_type == 'v1':\n return self._extract_roi_features_v1(x, normed_boxes)\n else:\n assert extract_type == 'v2'\n return self._extract_roi_features_v2(x, normed_boxes)\n\n def _extract_roi_features_v2(self, x, normed_boxes, **kwargs):\n x = self.encode_dense(x)\n x = F.normalize(x, dim=1) # remember to normalize!\n\n roi_feats = roi_align(x, self._denormalize_boxes(normed_boxes, x), (1, 1),\n 1.0, -1, True)[..., 0, 0]\n return roi_feats\n\n def encode_rois_and_image(self, x, normed_boxes, **kwargs):\n h, w = x.shape[-2:]\n x = self.trunk.forward_features(x)\n h_f, w_f = x.shape[-2:]\n tar_h = (self.image_size[0] * h_f) // h\n tar_w = (self.image_size[1] * w_f) // w\n x_image = x\n x_rois = roi_align(x, self._denormalize_boxes(normed_boxes, x), (tar_h, tar_w),\n 1.0, -1, True)\n\n x_rois = self.trunk.forward_head(x_rois)\n x_rois = self.head(x_rois)\n x_rois = F.normalize(x_rois, dim=-1)\n\n x_image = self.trunk.forward_head(x_image)\n x_image = self.head(x_image)\n x_image = F.normalize(x_image, dim=-1)\n\n return x_rois, x_image"},{"identifier":"LayerNormFp32","path":"src/open_clip/transformer.py","snippet":"class LayerNormFp32(nn.LayerNorm):\n \"\"\"Subclass torch's LayerNorm to handle fp16 (by casting to float32 and back).\"\"\"\n\n def forward(self, x: torch.Tensor):\n orig_type = x.dtype\n x = F.layer_norm(x.to(torch.float32), self.normalized_shape, self.weight, self.bias, self.eps)\n return x.to(orig_type)"},{"identifier":"LayerNorm","path":"src/open_clip/transformer.py","snippet":"class LayerNorm(nn.LayerNorm):\n \"\"\"Subclass torch's LayerNorm (with cast back to input dtype).\"\"\"\n\n def forward(self, x: torch.Tensor):\n orig_type = x.dtype\n x = F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)\n return x.to(orig_type)"},{"identifier":"QuickGELU","path":"src/open_clip/transformer.py","snippet":"class QuickGELU(nn.Module):\n # NOTE This is slower than nn.GELU or nn.SiLU and uses more GPU memory\n def forward(self, x: torch.Tensor):\n return x * torch.sigmoid(1.702 * x)"},{"identifier":"Attention","path":"src/open_clip/transformer.py","snippet":"class Attention(nn.Module):\n def __init__(\n self,\n dim,\n num_heads=8,\n qkv_bias=True,\n scaled_cosine=False,\n scale_heads=False,\n logit_scale_max=math.log(1. / 0.01),\n attn_drop=0.,\n proj_drop=0.\n ):\n super().__init__()\n self.scaled_cosine = scaled_cosine\n self.scale_heads = scale_heads\n assert dim % num_heads == 0, 'dim should be divisible by num_heads'\n self.num_heads = num_heads\n self.head_dim = dim // num_heads\n self.scale = self.head_dim ** -0.5\n self.logit_scale_max = logit_scale_max\n\n # keeping in_proj in this form (instead of nn.Linear) to match weight scheme of original\n self.in_proj_weight = nn.Parameter(torch.randn((dim * 3, dim)) * self.scale)\n if qkv_bias:\n self.in_proj_bias = nn.Parameter(torch.zeros(dim * 3))\n else:\n self.in_proj_bias = None\n\n if self.scaled_cosine:\n self.logit_scale = nn.Parameter(torch.log(10 * torch.ones((num_heads, 1, 1))))\n else:\n self.logit_scale = None\n self.attn_drop = nn.Dropout(attn_drop)\n if self.scale_heads:\n self.head_scale = nn.Parameter(torch.ones((num_heads, 1, 1)))\n else:\n self.head_scale = None\n self.out_proj = nn.Linear(dim, dim)\n self.out_drop = nn.Dropout(proj_drop)\n\n def forward(self, x, attn_mask: Optional[torch.Tensor] = None):\n L, N, C = x.shape\n q, k, v = F.linear(x, self.in_proj_weight, self.in_proj_bias).chunk(3, dim=-1)\n q = q.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1)\n k = k.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1)\n v = v.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1)\n\n if self.logit_scale is not None:\n attn = torch.bmm(F.normalize(q, dim=-1), F.normalize(k, dim=-1).transpose(-1, -2))\n logit_scale = torch.clamp(self.logit_scale, max=self.logit_scale_max).exp()\n attn = attn.view(N, self.num_heads, L, L) * logit_scale\n attn = attn.view(-1, L, L)\n else:\n q = q * self.scale\n attn = torch.bmm(q, k.transpose(-1, -2))\n\n if attn_mask is not None:\n if attn_mask.dtype == torch.bool:\n new_attn_mask = torch.zeros_like(attn_mask, dtype=q.dtype)\n new_attn_mask.masked_fill_(attn_mask, float(\"-inf\"))\n attn_mask = new_attn_mask\n attn += attn_mask\n\n attn = attn.softmax(dim=-1)\n attn = self.attn_drop(attn)\n\n x = torch.bmm(attn, v)\n if self.head_scale is not None:\n x = x.view(N, self.num_heads, L, C) * self.head_scale\n x = x.view(-1, L, C)\n x = x.transpose(0, 1).reshape(L, N, C)\n x = self.out_proj(x)\n x = self.out_drop(x)\n return x"},{"identifier":"VisionTransformer","path":"src/open_clip/transformer.py","snippet":"class VisionTransformer(nn.Module):\n output_tokens: torch.jit.Final[bool]\n\n def __init__(\n self,\n image_size: int,\n patch_size: int,\n width: int,\n layers: int,\n heads: int,\n mlp_ratio: float,\n ls_init_value: float = None,\n global_average_pool: bool = False,\n attentional_pool: bool = False,\n n_queries: int = 256,\n attn_pooler_heads: int = 8,\n output_dim: int = 512,\n patch_dropout: float = 0.,\n input_patchnorm: bool = False,\n act_layer: Callable = nn.GELU,\n norm_layer: Callable = LayerNorm,\n output_tokens: bool = False\n ):\n super().__init__()\n self.output_tokens = output_tokens\n image_height, image_width = self.image_size = to_2tuple(image_size)\n patch_height, patch_width = self.patch_size = to_2tuple(patch_size)\n self.grid_size = (image_height // patch_height, image_width // patch_width)\n self.output_dim = output_dim\n\n # whether to layernorm each patch, as done in dual patchnorm paper - https://arxiv.org/abs/2302.01327v1\n self.input_patchnorm = input_patchnorm\n assert not input_patchnorm\n if input_patchnorm:\n patch_input_dim = patch_height * patch_width * 3\n self.patchnorm_pre_ln = LayerNorm(patch_input_dim)\n self.conv1 = nn.Linear(patch_input_dim, width)\n else:\n self.patchnorm_pre_ln = nn.Identity()\n self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)\n\n # class embeddings and positional embeddings\n scale = width ** -0.5\n self.class_embedding = nn.Parameter(scale * torch.randn(width))\n self.positional_embedding = nn.Parameter(scale * torch.randn(self.grid_size[0] * self.grid_size[1] + 1, width))\n\n # setting a patch_dropout of 0. would mean it is disabled and this function would be the identity fn\n self.patch_dropout = PatchDropout(patch_dropout) if patch_dropout > 0. else nn.Identity()\n\n self.ln_pre = norm_layer(width)\n self.transformer = Transformer(\n width,\n layers,\n heads,\n mlp_ratio,\n ls_init_value=ls_init_value,\n act_layer=act_layer,\n norm_layer=norm_layer,\n )\n self.num_heads = heads\n\n self.global_average_pool = global_average_pool\n if attentional_pool:\n self.attn_pool = AttentionalPooler(output_dim, width, n_head=attn_pooler_heads, n_queries=n_queries)\n self.ln_post = norm_layer(output_dim)\n self.proj = nn.Parameter(scale * torch.randn(output_dim, output_dim))\n else:\n self.attn_pool = None\n self.ln_post = norm_layer(width)\n self.proj = nn.Parameter(scale * torch.randn(width, output_dim))\n\n self.init_parameters()\n\n def lock(self, unlocked_groups=0, freeze_bn_stats=False):\n for param in self.parameters():\n param.requires_grad = False\n\n if unlocked_groups != 0:\n groups = [\n [\n self.conv1,\n self.class_embedding,\n self.ln_pre,\n ],\n self.positional_embedding,\n *self.transformer.resblocks[:-1],\n [\n self.transformer.resblocks[-1],\n # self.ln_post, # fix layer norm\n ],\n # self.proj, # fix output layers\n ]\n\n def _unlock(x):\n if isinstance(x, Sequence):\n for g in x:\n _unlock(g)\n else:\n if isinstance(x, torch.nn.Parameter):\n x.requires_grad = True\n else:\n for p in x.parameters():\n p.requires_grad = True\n\n _unlock(groups[-unlocked_groups:])\n\n def attention_lock(self, **kwargs):\n for name, params in self.named_parameters():\n params.requires_grad = True if \"attn\" in name or \"position\" in name else False\n\n def init_parameters(self):\n # FIXME OpenAI CLIP did not define an init for the VisualTransformer\n # TODO experiment if default PyTorch init, below, or alternate init is best.\n pass\n\n @torch.jit.ignore\n def set_grad_checkpointing(self, enable=True):\n self.transformer.grad_checkpointing = enable\n\n def _global_pool(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n if self.global_average_pool:\n return x.mean(dim=1), x\n else:\n return x[:, 0], x[:, 1:]\n\n def forward(self, x: torch.Tensor):\n\n # to patches - whether to use dual patchnorm - https://arxiv.org/abs/2302.01327v1\n # if self.input_patchnorm:\n # # einops - rearrange(x, 'b c (h p1) (w p2) -> b (h w) (c p1 p2)')\n # x = x.reshape(x.shape[0], x.shape[1], self.grid_size[0], self.patch_size[0], self.grid_size[1], self.patch_size[1])\n # x = x.permute(0, 2, 4, 1, 3, 5)\n # x = x.reshape(x.shape[0], self.grid_size[0] * self.grid_size[1], -1)\n # x = self.patchnorm_pre_ln(x)\n # x = self.conv1(x)\n # else:\n x = self.conv1(x) # shape = [*, width, grid, grid]\n bs, _, h, w = x.shape\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\n\n # class embeddings and positional embeddings\n x = torch.cat(\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\n # TODO: Allow interpolating the positional embeddings\n\n if (h, w) == self.grid_size:\n pe = self.positional_embedding.to(x.dtype)\n else:\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\n\n x = x + pe\n\n # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in\n x = self.patch_dropout(x)\n x = self.ln_pre(x)\n\n x = x.permute(1, 0, 2) # NLD -> LND\n x = self.transformer(x)\n x = x.permute(1, 0, 2) # LND -> NLD\n\n if self.attn_pool is not None:\n x = self.attn_pool(x)\n x = self.ln_post(x)\n pooled, tokens = self._global_pool(x)\n else:\n pooled, tokens = self._global_pool(x)\n pooled = self.ln_post(pooled)\n\n if self.proj is not None:\n pooled = pooled @ self.proj\n\n if self.output_tokens:\n return pooled, tokens\n \n return pooled\n\n def post_attention(self, x):\n x = x.permute(1, 0, 2) # LND -> NLD\n\n if self.attn_pool is not None:\n x = self.attn_pool(x)\n x = self.ln_post(x)\n pooled, tokens = self._global_pool(x)\n else:\n pooled, tokens = self._global_pool(x)\n pooled = self.ln_post(pooled)\n\n if self.proj is not None:\n pooled = pooled @ self.proj\n\n if self.output_tokens:\n return pooled, tokens\n\n return pooled\n\n def extract_roi_features(self, x, normed_boxes, extract_type='v2'):\n if extract_type == 'v1':\n return self._extract_roi_features_v1(x, normed_boxes)\n elif extract_type == 'v2':\n return self._extract_roi_features_v2(x, normed_boxes)\n else:\n raise NotImplementedError\n # assert extract_type == 'v3'\n # return self._extract_roi_features_v3(x, normed_boxes)\n\n def mask_pool(self, x, masks):\n feature_map = self.encode_dense(x)\n feature_map = F.normalize(feature_map, dim=-1)\n\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\n masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w\n feature_map = torch.repeat_interleave(\n feature_map, torch.tensor(num_masks_per_image, device=feature_map.device), dim=0)\n features = (feature_map * masks.unsqueeze(-1)).sum(1) / (masks.sum(1, keepdim=True) + 1e-12)\n\n return features\n\n def mask_features(self, x, masks):\n feature_map = self.encode_dense(x)\n feature_map = F.normalize(feature_map, dim=-1)\n\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\n masks = torch.cat(masks).flatten(-2, -1) > 0 # bs, h*w\n feature_map = torch.repeat_interleave(\n feature_map, torch.tensor(num_masks_per_image, device=feature_map.device), dim=0)\n\n mask_features = [f[m] for m, f in zip(masks, feature_map)]\n\n return mask_features\n\n def encode_dense(self, x, keep_shape=False):\n x = self.conv1(x) # shape = [*, width, grid, grid]\n bs, _, h, w = x.shape\n # assert h == w # TODO: support input of any shape, need to change the normed boxes to real boxes\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\n x = torch.cat(\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\n if (h, w) == self.grid_size:\n pe = self.positional_embedding.to(x.dtype)\n else:\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\n\n x = x + pe\n\n # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in\n x = self.patch_dropout(x)\n x = self.ln_pre(x)\n\n x = x.permute(1, 0, 2) # NLD -> LND\n x = self.transformer.extract_feature_map(x)\n x = x.permute(1, 0, 2) # LND -> NLD\n\n if self.attn_pool is not None:\n x = self.attn_pool(x)\n x = self.ln_post(x)\n _, tokens = self._global_pool(x)\n else:\n _, tokens = self._global_pool(x)\n tokens = self.ln_post(tokens)\n\n if self.proj is not None:\n tokens = tokens @ self.proj\n\n feature_map = tokens.view(bs, h * w, -1) # .permute(0, 3, 1, 2)\n feature_map = F.normalize(feature_map, dim=-1) # normalize at the last dimension\n if keep_shape:\n feature_map = feature_map.view(bs, h, w, -1).permute(0, 3, 1, 2)\n return feature_map\n\n def mask_crop(self, x, masks):\n x = self.conv1(x) # shape = [*, width, grid, grid]\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\n masks = torch.cat(masks).to(x) # bs, h, w\n x = torch.repeat_interleave(\n x, torch.tensor(num_masks_per_image, device=x.device), dim=0)\n x = x * masks[:, None]\n bs, _, h, w = x.shape\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\n\n # class embeddings and positional embeddings\n x = torch.cat(\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\n # TODO: Allow interpolating the positional embeddings\n\n if (h, w) == self.grid_size:\n pe = self.positional_embedding.to(x.dtype)\n else:\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\n\n x = x + pe\n\n x = self.patch_dropout(x)\n x = self.ln_pre(x)\n\n x = x.permute(1, 0, 2) # NLD -> LND\n x = self.transformer(x)\n x = x.permute(1, 0, 2) # LND -> NLD\n\n if self.attn_pool is not None:\n x = self.attn_pool(x)\n x = self.ln_post(x)\n pooled, tokens = self._global_pool(x)\n else:\n pooled, tokens = self._global_pool(x)\n pooled = self.ln_post(pooled)\n\n if self.proj is not None:\n pooled = pooled @ self.proj\n\n return pooled\n\n @staticmethod\n def _generate_masks_per_image(normed_boxes, mask_h, mask_w):\n num_boxes = len(normed_boxes)\n boxes = normed_boxes * torch.tensor(\n [[mask_w, mask_h, mask_w, mask_h]], device=normed_boxes.device)\n masks = torch.zeros(num_boxes, mask_h, mask_w,\n dtype=torch.bool, device=normed_boxes.device)\n for i, box in enumerate(boxes):\n x0, y0, x1, y1 = box.long().tolist()\n masks[i, y0:y1, x0:x1] = True\n\n return masks\n \n @staticmethod\n def _denormalize_boxes(normed_boxes, x):\n h, w = x.shape[-2:]\n denormed_boxes = []\n for boxes in normed_boxes:\n new_boxes = boxes.clone() # FIXME: do not change the value in normed_boxes!\n new_boxes[:, [0, 2]] *= w\n new_boxes[:, [1, 3]] *= h\n denormed_boxes.append(new_boxes)\n return denormed_boxes\n\n def _extract_roi_features_v1(self, x, normed_boxes):\n # used masks\n bs, _, h, w = x.shape\n patch_height, patch_width = self.patch_size\n mask_h, mask_w = h // patch_height, w // patch_width\n masks = [self._generate_masks_per_image(normed_boxes_, mask_h, mask_w)\n for normed_boxes_ in normed_boxes]\n\n return self.mask_attn_pool(x, masks)\n\n def _extract_roi_features_v3(self, x, normed_boxes): # v3 for extract two types\n # used masks\n bs, _, h, w = x.shape\n patch_height, patch_width = self.patch_size\n mask_h, mask_w = h // patch_height, w // patch_width\n masks = [self._generate_masks_per_image(normed_boxes_, mask_h, mask_w)\n for normed_boxes_ in normed_boxes]\n\n roi_features_v1, dense_x = self.mask_attn_pool(x, masks, return_dense=True)\n dense_x = F.normalize(dense_x, dim=-1) # normalize along last dimension\n dense_x = dense_x.permute(0, 3, 1, 2)\n roi_features_v2 = roi_align(dense_x, self._denormalize_boxes(normed_boxes, dense_x), \n (1, 1), 1.0, -1, True)[..., 0, 0]\n\n return roi_features_v1, roi_features_v2\n\n def _extract_roi_features_v2(self, x, normed_boxes):\n x = self.conv1(x) # shape = [*, width, grid, grid]\n bs, _, h, w = x.shape\n # assert h == w # TODO: support input of any shape, need to change the normed boxes to real boxes\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\n x = torch.cat(\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\n if (h, w) == self.grid_size:\n pe = self.positional_embedding.to(x.dtype)\n else:\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\n\n x = x + pe\n\n # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in\n x = self.patch_dropout(x)\n x = self.ln_pre(x)\n\n x = x.permute(1, 0, 2) # NLD -> LND\n x = self.transformer.extract_feature_map(x)\n x = x.permute(1, 0, 2) # LND -> NLD\n\n if self.attn_pool is not None:\n x = self.attn_pool(x)\n x = self.ln_post(x)\n _, tokens = self._global_pool(x)\n else:\n _, tokens = self._global_pool(x)\n tokens = self.ln_post(tokens)\n\n if self.proj is not None:\n tokens = tokens @ self.proj\n tokens = F.normalize(tokens, dim=-1) # normalize along last dimension\n tokens = tokens.view(bs, h, w, -1).permute(0, 3, 1, 2)\n return roi_align(tokens, self._denormalize_boxes(normed_boxes, tokens),\n (1, 1), 1.0, -1, True)[..., 0, 0]\n\n def rescale_positional_embedding(self, out_size, dtype):\n h, w = out_size\n rescaled_positional_embedding = \\\n self.positional_embedding.new_zeros(1 + h*w, self.positional_embedding.shape[1])\n rescaled_positional_embedding[0] = self.positional_embedding[0]\n pe_2d = self.positional_embedding[1:].T.contiguous().view(\n 1, -1, *self.grid_size)\n pe_2d = F.interpolate(pe_2d, out_size, mode='bicubic', align_corners=False).view(-1, h*w)\n rescaled_positional_embedding[1:] = pe_2d.T.contiguous()\n\n return rescaled_positional_embedding.to(dtype=dtype)\n\n def _mask_attn_pool(self, x: torch.Tensor, attn_mask: torch.Tensor, num_mask_tokens: int, return_dense=False):\n x = self.conv1(x) # shape = [*, width, grid, grid]\n bs, _, h, w = x.shape\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\n x = torch.cat(\n [\n self.class_embedding.to(x.dtype)\n + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\n x,\n ],\n dim=1,\n ) # shape = [*, grid ** 2 + 1, width]\n if (h, w) == self.grid_size:\n pe = self.positional_embedding.to(x.dtype)\n else:\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\n\n x = x + pe\n x = self.ln_pre(x)\n\n x = x.permute(1, 0, 2) # NLD -> LND\n cls_embed = x[0:1]\n cls_embed = cls_embed.expand(num_mask_tokens, -1, -1)\n x = torch.cat([cls_embed, x], dim=0)\n if return_dense:\n x, x_dense = self.transformer.forward_image_dense(x, attn_mask)\n x_dense = x_dense.permute(1, 0, 2) # LND -> NLD\n x_dense = x_dense[:, num_mask_tokens + 1:]\n\n x_dense = self.ln_post(x_dense)\n\n if self.proj is not None:\n x_dense = x_dense @ self.proj\n x_dense = F.normalize(x_dense, dim=-1) # normalize along last dimension\n x_dense = x_dense.view(bs, h, w, -1)\n else:\n x = self.transformer(x, attn_mask)\n x_dense = None\n x = x.permute(1, 0, 2) # LND -> NLD\n\n # [N, L, D]\n x = self.ln_post(x[:, :num_mask_tokens, :])\n\n if self.proj is not None:\n x = torch.einsum(\"nld,dc->nlc\", x, self.proj)\n\n return x, x_dense\n\n def mask_attn_pool(self, image, masks, return_dense=False):\n assert hasattr(self, \"positional_embedding\")\n batch_size = image.shape[0]\n assert batch_size == len(masks)\n num_masks_per_image = [mask.shape[0] for mask in masks]\n num_queries = max(num_masks_per_image)\n mask_h, mask_w = masks[0].shape[1:]\n\n batch_masks = torch.ones(batch_size, num_queries, mask_h, mask_w, dtype=torch.bool).to(image.device)\n for batch_id, mask in enumerate(masks):\n batch_masks[batch_id, :mask.shape[0]] = mask\n\n mask_token_attn_mask = torch.logical_not(batch_masks)\n # [B, Q, H//P x W//P]\n mask_token_attn_mask = mask_token_attn_mask.reshape(batch_size, num_queries, -1)\n\n num_mask_token = num_queries\n num_image_cls_token = (mask_h * mask_w + 1)\n num_image_token = num_image_cls_token - 1\n num_all_token = num_mask_token + num_image_cls_token\n\n # we start with no mask out\n attn_mask = torch.zeros(\n (num_all_token, num_all_token), dtype=torch.bool, device=image.device\n )\n\n # mask+cls+image token to mask token attention is masked out\n attn_mask[:, :num_mask_token] = True\n\n attn_mask = attn_mask.unsqueeze(0).repeat_interleave(batch_size, dim=0)\n attn_mask[:, :num_mask_token, -num_image_token:] = mask_token_attn_mask\n num_heads = self.num_heads # head width 64\n attn_mask = attn_mask.unsqueeze(1).expand(-1, num_heads, -1, -1)\n attn_mask = attn_mask.reshape(batch_size * num_heads, num_all_token, num_all_token)\n\n batch_mask_features, x_dense = self._mask_attn_pool(image, attn_mask, num_mask_token,\n return_dense=return_dense)\n\n mask_features = [batch_mask_features[batch_id, :num_masks]\n for batch_id, num_masks, in enumerate(num_masks_per_image)]\n if return_dense:\n # x_dense = F.normalize(x_dense, dim=-1).flatten(1, 2) # bs, h*w, c\n # masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w\n # x_dense = torch.repeat_interleave(\n # x_dense, torch.tensor(num_masks_per_image, device=x_dense.device), dim=0)\n # x_dense = (x_dense * masks.unsqueeze(-1)).sum(1) / masks.sum(1, keepdim=True)\n\n return torch.cat(mask_features), x_dense\n else:\n return torch.cat(mask_features)\n\n def encode_rois_and_image(self, x, normed_boxes):\n x = self.conv1(x) # shape = [*, width, grid, grid]\n bs, _, h, w = x.shape\n # assert h == w # TODO: support input of any shape, need to change the normed boxes to real boxes\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\n x = torch.cat(\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\n if (h, w) == self.grid_size:\n pe = self.positional_embedding.to(x.dtype)\n else:\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\n\n x = x + pe\n\n # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in\n x = self.patch_dropout(x)\n x = self.ln_pre(x)\n\n x = x.permute(1, 0, 2) # NLD -> LND\n x, x_image = self.transformer.extract_feature_map(x, return_forward=True)\n x = x.permute(1, 0, 2) # LND -> NLD\n\n if self.attn_pool is not None:\n x = self.attn_pool(x)\n x = self.ln_post(x)\n _, tokens = self._global_pool(x)\n else:\n _, tokens = self._global_pool(x)\n tokens = self.ln_post(tokens)\n\n if self.proj is not None:\n tokens = tokens @ self.proj\n\n feature_map = tokens.view(bs, h * w, -1) # .permute(0, 3, 1, 2)\n feature_map = F.normalize(feature_map, dim=-1)\n feature_map = feature_map.view(bs, h, w, -1).permute(0, 3, 1, 2)\n x_rois = roi_align(feature_map, self._denormalize_boxes(normed_boxes, feature_map),\n (1, 1), 1.0, -1, True)[..., 0, 0]\n x_rois = F.normalize(x_rois, dim=-1)\n\n x_image = self.post_attention(x_image)\n x_image = F.normalize(x_image, dim=-1)\n\n return x_rois, x_image"},{"identifier":"TextTransformer","path":"src/open_clip/transformer.py","snippet":"class TextTransformer(nn.Module):\n output_tokens: torch.jit.Final[bool]\n\n def __init__(\n self,\n context_length: int = 77,\n vocab_size: int = 49408,\n width: int = 512,\n heads: int = 8,\n layers: int = 12,\n ls_init_value: float = None,\n output_dim: int = 512,\n act_layer: Callable = nn.GELU,\n norm_layer: Callable = LayerNorm,\n embed_cls: bool = False,\n pad_id: int = 0,\n output_tokens: bool = False,\n ):\n super().__init__()\n self.output_tokens = output_tokens\n self.num_pos = self.context_length = context_length\n self.vocab_size = vocab_size\n self.width = width\n self.output_dim = output_dim\n self.heads = heads\n self.pad_id = pad_id\n\n self.text_projection = nn.Parameter(torch.empty(width, output_dim))\n\n if embed_cls:\n self.cls_emb = nn.Parameter(torch.empty(width))\n self.num_pos += 1\n else:\n self.cls_emb = None\n\n self.token_embedding = nn.Embedding(vocab_size, width)\n self.positional_embedding = nn.Parameter(torch.empty(self.num_pos, width))\n self.transformer = Transformer(\n width=width,\n layers=layers,\n heads=heads,\n ls_init_value=ls_init_value,\n act_layer=act_layer,\n norm_layer=norm_layer,\n )\n self.ln_final = norm_layer(width)\n\n self.register_buffer('attn_mask', self.build_attention_mask(), persistent=False)\n\n self.init_parameters()\n\n def init_parameters(self):\n nn.init.normal_(self.token_embedding.weight, std=0.02)\n nn.init.normal_(self.positional_embedding, std=0.01)\n if self.cls_emb is not None:\n nn.init.normal_(self.cls_emb, std=0.01)\n\n proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5)\n attn_std = self.transformer.width ** -0.5\n fc_std = (2 * self.transformer.width) ** -0.5\n for block in self.transformer.resblocks:\n nn.init.normal_(block.attn.in_proj_weight, std=attn_std)\n nn.init.normal_(block.attn.out_proj.weight, std=proj_std)\n nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)\n nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)\n\n if self.text_projection is not None:\n nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5)\n\n def lock(self, unlocked_layers: int = 0, freeze_layer_norm: bool = True):\n assert unlocked_layers == 0 and freeze_layer_norm\n print(f'Freeze the text encoder', flush=True)\n for p in self.parameters():\n p.requires_grad = False\n\n @torch.jit.ignore\n def set_grad_checkpointing(self, enable=True):\n self.transformer.grad_checkpointing = enable\n\n def build_attention_mask(self):\n # lazily create causal attention mask, with full attention between the tokens\n # pytorch uses additive attention mask; fill with -inf\n mask = torch.empty(self.num_pos, self.num_pos)\n mask.fill_(float(\"-inf\"))\n mask.triu_(1) # zero out the lower diagonal\n return mask\n\n def build_cls_mask(self, text, cast_dtype: torch.dtype):\n cls_mask = (text != self.pad_id).unsqueeze(1)\n cls_mask = F.pad(cls_mask, (1, 0, cls_mask.shape[2], 0), value=1.0)\n additive_mask = torch.empty(cls_mask.shape, dtype=cast_dtype, device=cls_mask.device)\n additive_mask.fill_(0)\n additive_mask.masked_fill_(~cls_mask, float(\"-inf\"))\n additive_mask = torch.repeat_interleave(additive_mask, self.heads, 0)\n return additive_mask\n\n def _repeat(self, t, N: int):\n return t.reshape(1, 1, -1).repeat(N, 1, 1)\n\n def forward(self, text):\n cast_dtype = self.transformer.get_cast_dtype()\n seq_len = text.shape[1]\n\n x = self.token_embedding(text).to(cast_dtype) # [batch_size, n_ctx, d_model]\n attn_mask = self.attn_mask\n if self.cls_emb is not None:\n seq_len += 1\n x = torch.cat([x, self._repeat(self.cls_emb, x.shape[0])], dim=1)\n cls_mask = self.build_cls_mask(text, cast_dtype)\n attn_mask = attn_mask[None, :seq_len, :seq_len] + cls_mask[:, :seq_len, :seq_len]\n\n x = x + self.positional_embedding[:seq_len].to(cast_dtype)\n x = x.permute(1, 0, 2) # NLD -> LND\n x = self.transformer(x, attn_mask=attn_mask)\n x = x.permute(1, 0, 2) # LND -> NLD\n\n # x.shape = [batch_size, n_ctx, transformer.width]\n # take features from the eot embedding (eot_token is the highest number in each sequence)\n if self.cls_emb is not None:\n pooled, tokens = x[:, -1], x[:, :-1]\n pooled = self.ln_final(pooled)\n else:\n x = self.ln_final(x)\n pooled, tokens = x[torch.arange(x.shape[0]), text.argmax(dim=-1)], x\n\n if self.text_projection is not None:\n pooled = pooled @ self.text_projection\n\n if self.output_tokens:\n return pooled, tokens\n\n return pooled"},{"identifier":"to_2tuple","path":"src/open_clip/utils.py","snippet":"def freeze_batch_norm_2d(module, module_match={}, name=''):\ndef _ntuple(n):\n def parse(x):"}],"string":"[\n {\n \"identifier\": \"HFTextEncoder\",\n \"path\": \"src/open_clip/hf_model.py\",\n \"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: int,\\n config: PretrainedConfig = None,\\n pooler_type: str = None,\\n proj: str = None,\\n pretrained: bool = True,\\n output_tokens: bool = False,\\n ):\\n super().__init__()\\n self.output_tokens = output_tokens\\n self.output_dim = output_dim\\n\\n # TODO: find better way to get this information\\n uses_transformer_pooler = (pooler_type == \\\"cls_pooler\\\")\\n\\n if transformers is None:\\n raise RuntimeError(\\\"Please `pip install transformers` to use pre-trained HuggingFace models\\\")\\n if config is None:\\n self.config = AutoConfig.from_pretrained(model_name_or_path)\\n create_func, model_args = (AutoModel.from_pretrained, model_name_or_path) if pretrained else (\\n AutoModel.from_config, self.config)\\n # TODO: do all model configs have this attribute? PretrainedConfig does so yes??\\n if hasattr(self.config, \\\"is_encoder_decoder\\\") and self.config.is_encoder_decoder:\\n self.transformer = create_func(model_args)\\n self.transformer = self.transformer.encoder\\n else:\\n self.transformer = create_func(model_args, add_pooling_layer=uses_transformer_pooler)\\n else:\\n self.config = config\\n self.transformer = AutoModel.from_config(config)\\n if pooler_type is None: # get default arch pooler\\n pooler_type = (arch_dict[self.config.model_type][\\\"pooler\\\"])\\n \\n self.pooler = _POOLERS[pooler_type]()\\n\\n d_model = getattr(self.config, arch_dict[self.config.model_type][\\\"config_names\\\"][\\\"width\\\"])\\n if (d_model == output_dim) and (proj is None): # do we always need a proj?\\n self.proj = nn.Identity()\\n elif proj == 'linear':\\n self.proj = nn.Linear(d_model, output_dim, bias=False)\\n elif proj == 'mlp':\\n hidden_size = (d_model + output_dim) // 2\\n self.proj = nn.Sequential(\\n nn.Linear(d_model, hidden_size, bias=False),\\n nn.GELU(),\\n nn.Linear(hidden_size, output_dim, bias=False),\\n )\\n\\n def forward(self, x: TensorType):\\n attn_mask = (x != self.config.pad_token_id).long()\\n out = self.transformer(input_ids=x, attention_mask=attn_mask)\\n pooled_out = self.pooler(out, attn_mask)\\n projected = self.proj(pooled_out)\\n\\n seq_len = out.last_hidden_state.shape[1]\\n tokens = (\\n out.last_hidden_state[:, torch.arange(seq_len) != self.pooler.cls_token_position, :] \\n if type(self.pooler) == ClsPooler \\n else out.last_hidden_state\\n )\\n \\n if self.output_tokens:\\n return projected, tokens\\n return projected\\n\\n def lock(self, unlocked_layers: int = 0, freeze_layer_norm: bool = True):\\n if not unlocked_layers: # full freezing\\n for n, p in self.transformer.named_parameters():\\n p.requires_grad = (not freeze_layer_norm) if \\\"LayerNorm\\\" in n.split(\\\".\\\") else False\\n return\\n\\n encoder = self.transformer.encoder if hasattr(self.transformer, 'encoder') else self.transformer\\n layer_list = getattr(encoder, arch_dict[self.config.model_type][\\\"config_names\\\"][\\\"layer_attr\\\"])\\n print(f\\\"Unlocking {unlocked_layers}/{len(layer_list) + 1} layers of hf model\\\")\\n embeddings = getattr(\\n self.transformer, arch_dict[self.config.model_type][\\\"config_names\\\"][\\\"token_embeddings_attr\\\"])\\n modules = [embeddings, *layer_list][:-unlocked_layers]\\n # freeze layers\\n for module in modules:\\n for n, p in module.named_parameters():\\n p.requires_grad = (not freeze_layer_norm) if \\\"LayerNorm\\\" in n.split(\\\".\\\") else False\\n\\n @torch.jit.ignore\\n def set_grad_checkpointing(self, enable=True):\\n self.transformer.gradient_checkpointing_enable()\\n\\n def init_parameters(self):\\n pass\"\n },\n {\n \"identifier\": \"ModifiedResNet\",\n \"path\": \"src/open_clip/modified_resnet.py\",\n \"snippet\": \"class ModifiedResNet(nn.Module):\\n \\\"\\\"\\\"\\n A ResNet class that is similar to torchvision's but contains the following changes:\\n - There are now 3 \\\"stem\\\" convolutions as opposed to 1, with an average pool instead of a max pool.\\n - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1\\n - The final pooling layer is a QKV attention instead of an average pool\\n \\\"\\\"\\\"\\n\\n def __init__(self, layers, output_dim, heads, image_size=224, width=64,\\n freeze_output=True,\\n freeze_all_bns=True):\\n super().__init__()\\n self.output_dim = output_dim\\n self.image_size = image_size\\n self.freeze_output = freeze_output\\n self.freeze_all_bns = freeze_all_bns\\n # the 3-layer stem\\n self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)\\n self.bn1 = nn.BatchNorm2d(width // 2)\\n self.act1 = nn.ReLU(inplace=True)\\n self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False)\\n self.bn2 = nn.BatchNorm2d(width // 2)\\n self.act2 = nn.ReLU(inplace=True)\\n self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)\\n self.bn3 = nn.BatchNorm2d(width)\\n self.act3 = nn.ReLU(inplace=True)\\n self.avgpool = nn.AvgPool2d(2)\\n\\n # residual layers\\n self._inplanes = width # this is a *mutable* variable used during construction\\n self.layer1 = self._make_layer(width, layers[0])\\n self.layer2 = self._make_layer(width * 2, layers[1], stride=2)\\n self.layer3 = self._make_layer(width * 4, layers[2], stride=2)\\n self.layer4 = self._make_layer(width * 8, layers[3], stride=2)\\n\\n embed_dim = width * 32 # the ResNet feature dimension\\n self.attnpool = AttentionPool2d(image_size // 32, embed_dim, heads, output_dim, freeze_output)\\n self.attnpool_input_size = image_size // 32\\n\\n def _make_layer(self, planes, blocks, stride=1):\\n layers = [Bottleneck(self._inplanes, planes, stride)]\\n\\n self._inplanes = planes * Bottleneck.expansion\\n for _ in range(1, blocks):\\n layers.append(Bottleneck(self._inplanes, planes))\\n\\n return nn.Sequential(*layers)\\n\\n def lock(self, unlocked_groups=0, freeze_bn_stats=True):\\n assert freeze_bn_stats\\n def _lock(module):\\n for param in module.parameters():\\n param.requires_grad = False\\n if freeze_bn_stats:\\n freeze_batch_norm_2d(module)\\n module.eval()\\n\\n freeze_at = 5 - unlocked_groups\\n print(f'Freeze the resnet at {freeze_at}', flush=True)\\n\\n if freeze_at >= 1: # stem\\n _lock(self.conv1)\\n _lock(self.bn1)\\n _lock(self.conv2)\\n _lock(self.bn2)\\n _lock(self.conv3)\\n _lock(self.bn3)\\n # each stage is a torch.nn.modules.container.Sequential\\n for idx, stage in enumerate([self.layer1, self.layer2, self.layer3, self.layer4], start=2):\\n if freeze_at >= idx:\\n for block in stage.children(): # each block is a Bottleneck\\n _lock(block)\\n if self.freeze_all_bns:\\n print(f'Freeze all bn layers', flush=True) # TODO: study if this is necessary\\n freeze_batch_norm_2d(self)\\n\\n @torch.jit.ignore\\n def set_grad_checkpointing(self, enable=True):\\n # FIXME support for non-transformer\\n pass\\n\\n def stem(self, x):\\n x = self.act1(self.bn1(self.conv1(x)))\\n x = self.act2(self.bn2(self.conv2(x)))\\n x = self.act3(self.bn3(self.conv3(x)))\\n x = self.avgpool(x)\\n return x\\n\\n def forward(self, x):\\n with torch.no_grad():\\n x = self.stem(x)\\n x = self.layer1(x)\\n x = self.layer2(x)\\n x = self.layer3(x)\\n x = self.layer4(x)\\n x = self.attnpool(x)\\n\\n return x\\n\\n @staticmethod\\n def _denormalize_boxes(normed_boxes, x):\\n h, w = x.shape[-2:]\\n denormed_boxes = []\\n for boxes in normed_boxes:\\n new_boxes = boxes.clone() # FIXME: do not change the value in normed_boxes!\\n new_boxes[:, [0, 2]] *= w\\n new_boxes[:, [1, 3]] *= h\\n denormed_boxes.append(new_boxes)\\n return denormed_boxes\\n\\n def extract_roi_features(self, x, normed_boxes, extract_type='v2'):\\n if extract_type == 'v1':\\n return self._extract_roi_features_v1(x, normed_boxes)\\n else:\\n assert extract_type == 'v2'\\n return self._extract_roi_features_v2(x, normed_boxes)\\n\\n def mask_attn_pool(self, image, masks):\\n return self.mask_pool(image, masks)\\n\\n def mask_pool(self, image, masks):\\n x = self.stem(image)\\n x = self.layer1(x)\\n x = self.layer2(x)\\n x = self.layer3(x)\\n x = self.layer4(x)\\n\\n feature_map = self.attnpool.forward_dense(x)\\n feature_map = F.normalize(feature_map, dim=1) # remember to normalize!\\n\\n feature_map = feature_map.flatten(-2, -1) # bs, c, h*w\\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\\n masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w\\n feature_map = torch.repeat_interleave(\\n feature_map, torch.tensor(num_masks_per_image, device=feature_map.device), dim=0)\\n features = (feature_map * masks[:, None]).sum(-1) / (masks.sum(1, keepdim=True) + 1e-12)\\n\\n return features\\n\\n def _extract_roi_features_v1(self, x, normed_boxes, **kwargs):\\n with torch.no_grad():\\n x = self.stem(x)\\n x = self.layer1(x)\\n x = self.layer2(x)\\n x = self.layer3(x)\\n x = self.layer4(x)\\n\\n x = self.attnpool.forward_dense(x)\\n x = F.normalize(x, dim=1) # remember to normalize!\\n # TODO: debug\\n roi_feats = roi_align(x, self._denormalize_boxes(normed_boxes, x),\\n (1, 1), 1.0, -1, True)[:, :, 0, 0]\\n return roi_feats\\n\\n def _extract_roi_features_v2(self, x, normed_boxes, **kwargs):\\n with torch.no_grad():\\n x = self.stem(x)\\n x = self.layer1(x)\\n x = self.layer2(x)\\n x = self.layer3(x)\\n x = self.layer4(x) # only the last layer is finetuned in our implementation\\n\\n tar_size = self.attnpool_input_size\\n # TODO: debug\\n roi_feats = roi_align(x, self._denormalize_boxes(normed_boxes, x),\\n (tar_size, tar_size), 1.0, -1, True)\\n\\n roi_feats = self.attnpool(roi_feats)\\n\\n return roi_feats\\n\\n def encode_dense(self, x, keep_shape=True):\\n x = self.stem(x)\\n x = self.layer1(x)\\n x = self.layer2(x)\\n x = self.layer3(x)\\n x = self.layer4(x)\\n\\n feature_map = self.attnpool.forward_dense(x)\\n feature_map = F.normalize(feature_map, dim=1) # remember to normalize!\\n\\n return feature_map\"\n },\n {\n \"identifier\": \"TimmModel\",\n \"path\": \"src/open_clip/timm_model.py\",\n \"snippet\": \"class TimmModel(nn.Module):\\n \\\"\\\"\\\" timm model adapter\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n model_name,\\n embed_dim,\\n image_size=224,\\n pool='avg',\\n proj='linear',\\n proj_bias=False,\\n drop=0.,\\n drop_path=None,\\n patch_drop=None,\\n pretrained=False,\\n ):\\n super().__init__()\\n if timm is None:\\n raise RuntimeError(\\\"Please `pip install timm` to use timm models.\\\")\\n self.image_size = to_2tuple(image_size)\\n\\n # setup kwargs that may not be common across all models\\n timm_kwargs = {}\\n if drop_path is not None:\\n timm_kwargs['drop_path_rate'] = drop_path\\n if patch_drop is not None:\\n timm_kwargs['patch_drop_rate'] = patch_drop\\n\\n custom_pool = pool in ('abs_attn', 'rot_attn')\\n if not proj and not custom_pool:\\n # use network classifier head as projection if no proj specified and no custom pooling used\\n self.trunk = timm.create_model(\\n model_name,\\n num_classes=embed_dim,\\n global_pool=pool,\\n pretrained=pretrained,\\n **timm_kwargs,\\n )\\n prev_chs = embed_dim\\n else:\\n self.trunk = timm.create_model(\\n model_name,\\n pretrained=pretrained,\\n **timm_kwargs,\\n )\\n feat_size = self.trunk.default_cfg.get('pool_size', None)\\n feature_ndim = 1 if not feat_size else 2\\n if custom_pool:\\n assert feature_ndim == 2\\n # if attn pooling used, remove both classifier and default pool\\n self.trunk.reset_classifier(0, global_pool='')\\n else:\\n # reset global pool if pool config set, otherwise leave as network default\\n reset_kwargs = dict(global_pool=pool) if pool else {}\\n self.trunk.reset_classifier(0, **reset_kwargs)\\n prev_chs = self.trunk.num_features\\n\\n head_layers = OrderedDict()\\n\\n # Add custom pooling to head\\n if pool == 'abs_attn':\\n head_layers['pool'] = AbsAttentionPool2d(prev_chs, feat_size=feat_size, out_features=embed_dim)\\n prev_chs = embed_dim\\n elif pool == 'rot_attn':\\n head_layers['pool'] = RotAttentionPool2d(prev_chs, out_features=embed_dim)\\n prev_chs = embed_dim\\n\\n # NOTE attention pool ends with a projection layer, so proj should usually be set to '' if such pooling is used\\n if proj == 'linear':\\n head_layers['drop'] = nn.Dropout(drop)\\n head_layers['proj'] = nn.Linear(prev_chs, embed_dim, bias=proj_bias)\\n elif proj == 'mlp':\\n head_layers['mlp'] = Mlp(prev_chs, 2 * embed_dim, embed_dim, drop=(drop, 0), bias=(True, proj_bias))\\n else:\\n assert not proj, f'Unknown projection type {proj}.'\\n\\n self.head = nn.Sequential(head_layers)\\n\\n def lock(self, unlocked_groups=0, freeze_bn_stats=False):\\n \\\"\\\"\\\" lock modules\\n Args:\\n unlocked_groups (int): leave last n layer groups unlocked (default: 0)\\n \\\"\\\"\\\"\\n if not unlocked_groups:\\n # lock full model\\n for param in self.trunk.parameters():\\n param.requires_grad = False\\n if freeze_bn_stats:\\n freeze_batch_norm_2d(self.trunk)\\n else:\\n # NOTE: partial freeze requires latest timm (master) branch and is subject to change\\n try:\\n # FIXME import here until API stable and in an official release\\n from timm.models.helpers import group_parameters, group_modules\\n except ImportError:\\n raise RuntimeError(\\n 'Please install latest timm `pip install git+https://github.com/rwightman/pytorch-image-models`')\\n matcher = self.trunk.group_matcher()\\n gparams = group_parameters(self.trunk, matcher)\\n max_layer_id = max(gparams.keys())\\n max_layer_id = max_layer_id - unlocked_groups\\n for group_idx in range(max_layer_id + 1):\\n group = gparams[group_idx]\\n for param in group:\\n self.trunk.get_parameter(param).requires_grad = False\\n if freeze_bn_stats:\\n gmodules = group_modules(self.trunk, matcher, reverse=True)\\n gmodules = {k for k, v in gmodules.items() if v <= max_layer_id}\\n freeze_batch_norm_2d(self.trunk, gmodules)\\n\\n @torch.jit.ignore\\n def set_grad_checkpointing(self, enable=True):\\n try:\\n self.trunk.set_grad_checkpointing(enable)\\n except Exception as e:\\n logging.warning('grad checkpointing not supported for this timm image tower, continuing without...')\\n\\n def forward(self, x):\\n x = self.trunk(x)\\n x = self.head(x)\\n return x\\n\\n @staticmethod\\n def _denormalize_boxes(normed_boxes, x):\\n h, w = x.shape[-2:]\\n denormed_boxes = []\\n for boxes in normed_boxes:\\n new_boxes = boxes.clone() # FIXME: do not change the value in normed_boxes!\\n new_boxes[:, [0, 2]] *= w\\n new_boxes[:, [1, 3]] *= h\\n denormed_boxes.append(new_boxes)\\n return denormed_boxes\\n\\n def _extract_roi_features_v1(self, x, normed_boxes, **kwargs):\\n h, w = x.shape[-2:]\\n x = self.trunk.forward_features(x)\\n h_f, w_f = x.shape[-2:]\\n tar_h = (self.image_size[0] * h_f) // h\\n tar_w = (self.image_size[1] * w_f) // w\\n x = roi_align(x, self._denormalize_boxes(normed_boxes, x), (tar_h, tar_w),\\n 1.0, -1, True)\\n\\n x = self.trunk.forward_head(x)\\n x = self.head(x)\\n\\n return x\\n\\n def encode_dense(self, x, **kwargs):\\n x = self.trunk.forward_features(x)\\n x = self.dense_trunk_head(x)\\n x = self.head(x)\\n x = x.permute(0, 3, 1, 2)\\n\\n return x\\n\\n def dense_trunk_head(self, x):\\n x = self.trunk.head.norm(x)\\n x = x.permute(0, 2, 3, 1)\\n x = self.trunk.head.drop(x)\\n # x = x.permute(0, 3, 1, 2)\\n\\n return x\\n\\n def mask_pool(self, image, masks):\\n feature_map = self.encode_dense(image)\\n feature_map = F.normalize(feature_map, dim=1) # remember to normalize!\\n feature_map = feature_map.flatten(-2, -1) # bs, c, h*w\\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\\n masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w\\n feature_map = torch.repeat_interleave(\\n feature_map, torch.tensor(num_masks_per_image, device=feature_map.device), dim=0)\\n features = (feature_map * masks[:, None]).sum(-1) / (masks.sum(1, keepdim=True) + 1e-12)\\n\\n return features\\n\\n def extract_roi_features(self, x, normed_boxes, extract_type='v1'):\\n assert extract_type == \\\"v1\\\"\\n if extract_type == 'v1':\\n return self._extract_roi_features_v1(x, normed_boxes)\\n else:\\n assert extract_type == 'v2'\\n return self._extract_roi_features_v2(x, normed_boxes)\\n\\n def _extract_roi_features_v2(self, x, normed_boxes, **kwargs):\\n x = self.encode_dense(x)\\n x = F.normalize(x, dim=1) # remember to normalize!\\n\\n roi_feats = roi_align(x, self._denormalize_boxes(normed_boxes, x), (1, 1),\\n 1.0, -1, True)[..., 0, 0]\\n return roi_feats\\n\\n def encode_rois_and_image(self, x, normed_boxes, **kwargs):\\n h, w = x.shape[-2:]\\n x = self.trunk.forward_features(x)\\n h_f, w_f = x.shape[-2:]\\n tar_h = (self.image_size[0] * h_f) // h\\n tar_w = (self.image_size[1] * w_f) // w\\n x_image = x\\n x_rois = roi_align(x, self._denormalize_boxes(normed_boxes, x), (tar_h, tar_w),\\n 1.0, -1, True)\\n\\n x_rois = self.trunk.forward_head(x_rois)\\n x_rois = self.head(x_rois)\\n x_rois = F.normalize(x_rois, dim=-1)\\n\\n x_image = self.trunk.forward_head(x_image)\\n x_image = self.head(x_image)\\n x_image = F.normalize(x_image, dim=-1)\\n\\n return x_rois, x_image\"\n },\n {\n \"identifier\": \"LayerNormFp32\",\n \"path\": \"src/open_clip/transformer.py\",\n \"snippet\": \"class LayerNormFp32(nn.LayerNorm):\\n \\\"\\\"\\\"Subclass torch's LayerNorm to handle fp16 (by casting to float32 and back).\\\"\\\"\\\"\\n\\n def forward(self, x: torch.Tensor):\\n orig_type = x.dtype\\n x = F.layer_norm(x.to(torch.float32), self.normalized_shape, self.weight, self.bias, self.eps)\\n return x.to(orig_type)\"\n },\n {\n \"identifier\": \"LayerNorm\",\n \"path\": \"src/open_clip/transformer.py\",\n \"snippet\": \"class LayerNorm(nn.LayerNorm):\\n \\\"\\\"\\\"Subclass torch's LayerNorm (with cast back to input dtype).\\\"\\\"\\\"\\n\\n def forward(self, x: torch.Tensor):\\n orig_type = x.dtype\\n x = F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)\\n return x.to(orig_type)\"\n },\n {\n \"identifier\": \"QuickGELU\",\n \"path\": \"src/open_clip/transformer.py\",\n \"snippet\": \"class QuickGELU(nn.Module):\\n # NOTE This is slower than nn.GELU or nn.SiLU and uses more GPU memory\\n def forward(self, x: torch.Tensor):\\n return x * torch.sigmoid(1.702 * x)\"\n },\n {\n \"identifier\": \"Attention\",\n \"path\": \"src/open_clip/transformer.py\",\n \"snippet\": \"class Attention(nn.Module):\\n def __init__(\\n self,\\n dim,\\n num_heads=8,\\n qkv_bias=True,\\n scaled_cosine=False,\\n scale_heads=False,\\n logit_scale_max=math.log(1. / 0.01),\\n attn_drop=0.,\\n proj_drop=0.\\n ):\\n super().__init__()\\n self.scaled_cosine = scaled_cosine\\n self.scale_heads = scale_heads\\n assert dim % num_heads == 0, 'dim should be divisible by num_heads'\\n self.num_heads = num_heads\\n self.head_dim = dim // num_heads\\n self.scale = self.head_dim ** -0.5\\n self.logit_scale_max = logit_scale_max\\n\\n # keeping in_proj in this form (instead of nn.Linear) to match weight scheme of original\\n self.in_proj_weight = nn.Parameter(torch.randn((dim * 3, dim)) * self.scale)\\n if qkv_bias:\\n self.in_proj_bias = nn.Parameter(torch.zeros(dim * 3))\\n else:\\n self.in_proj_bias = None\\n\\n if self.scaled_cosine:\\n self.logit_scale = nn.Parameter(torch.log(10 * torch.ones((num_heads, 1, 1))))\\n else:\\n self.logit_scale = None\\n self.attn_drop = nn.Dropout(attn_drop)\\n if self.scale_heads:\\n self.head_scale = nn.Parameter(torch.ones((num_heads, 1, 1)))\\n else:\\n self.head_scale = None\\n self.out_proj = nn.Linear(dim, dim)\\n self.out_drop = nn.Dropout(proj_drop)\\n\\n def forward(self, x, attn_mask: Optional[torch.Tensor] = None):\\n L, N, C = x.shape\\n q, k, v = F.linear(x, self.in_proj_weight, self.in_proj_bias).chunk(3, dim=-1)\\n q = q.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1)\\n k = k.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1)\\n v = v.contiguous().view(L, N * self.num_heads, -1).transpose(0, 1)\\n\\n if self.logit_scale is not None:\\n attn = torch.bmm(F.normalize(q, dim=-1), F.normalize(k, dim=-1).transpose(-1, -2))\\n logit_scale = torch.clamp(self.logit_scale, max=self.logit_scale_max).exp()\\n attn = attn.view(N, self.num_heads, L, L) * logit_scale\\n attn = attn.view(-1, L, L)\\n else:\\n q = q * self.scale\\n attn = torch.bmm(q, k.transpose(-1, -2))\\n\\n if attn_mask is not None:\\n if attn_mask.dtype == torch.bool:\\n new_attn_mask = torch.zeros_like(attn_mask, dtype=q.dtype)\\n new_attn_mask.masked_fill_(attn_mask, float(\\\"-inf\\\"))\\n attn_mask = new_attn_mask\\n attn += attn_mask\\n\\n attn = attn.softmax(dim=-1)\\n attn = self.attn_drop(attn)\\n\\n x = torch.bmm(attn, v)\\n if self.head_scale is not None:\\n x = x.view(N, self.num_heads, L, C) * self.head_scale\\n x = x.view(-1, L, C)\\n x = x.transpose(0, 1).reshape(L, N, C)\\n x = self.out_proj(x)\\n x = self.out_drop(x)\\n return x\"\n },\n {\n \"identifier\": \"VisionTransformer\",\n \"path\": \"src/open_clip/transformer.py\",\n \"snippet\": \"class VisionTransformer(nn.Module):\\n output_tokens: torch.jit.Final[bool]\\n\\n def __init__(\\n self,\\n image_size: int,\\n patch_size: int,\\n width: int,\\n layers: int,\\n heads: int,\\n mlp_ratio: float,\\n ls_init_value: float = None,\\n global_average_pool: bool = False,\\n attentional_pool: bool = False,\\n n_queries: int = 256,\\n attn_pooler_heads: int = 8,\\n output_dim: int = 512,\\n patch_dropout: float = 0.,\\n input_patchnorm: bool = False,\\n act_layer: Callable = nn.GELU,\\n norm_layer: Callable = LayerNorm,\\n output_tokens: bool = False\\n ):\\n super().__init__()\\n self.output_tokens = output_tokens\\n image_height, image_width = self.image_size = to_2tuple(image_size)\\n patch_height, patch_width = self.patch_size = to_2tuple(patch_size)\\n self.grid_size = (image_height // patch_height, image_width // patch_width)\\n self.output_dim = output_dim\\n\\n # whether to layernorm each patch, as done in dual patchnorm paper - https://arxiv.org/abs/2302.01327v1\\n self.input_patchnorm = input_patchnorm\\n assert not input_patchnorm\\n if input_patchnorm:\\n patch_input_dim = patch_height * patch_width * 3\\n self.patchnorm_pre_ln = LayerNorm(patch_input_dim)\\n self.conv1 = nn.Linear(patch_input_dim, width)\\n else:\\n self.patchnorm_pre_ln = nn.Identity()\\n self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)\\n\\n # class embeddings and positional embeddings\\n scale = width ** -0.5\\n self.class_embedding = nn.Parameter(scale * torch.randn(width))\\n self.positional_embedding = nn.Parameter(scale * torch.randn(self.grid_size[0] * self.grid_size[1] + 1, width))\\n\\n # setting a patch_dropout of 0. would mean it is disabled and this function would be the identity fn\\n self.patch_dropout = PatchDropout(patch_dropout) if patch_dropout > 0. else nn.Identity()\\n\\n self.ln_pre = norm_layer(width)\\n self.transformer = Transformer(\\n width,\\n layers,\\n heads,\\n mlp_ratio,\\n ls_init_value=ls_init_value,\\n act_layer=act_layer,\\n norm_layer=norm_layer,\\n )\\n self.num_heads = heads\\n\\n self.global_average_pool = global_average_pool\\n if attentional_pool:\\n self.attn_pool = AttentionalPooler(output_dim, width, n_head=attn_pooler_heads, n_queries=n_queries)\\n self.ln_post = norm_layer(output_dim)\\n self.proj = nn.Parameter(scale * torch.randn(output_dim, output_dim))\\n else:\\n self.attn_pool = None\\n self.ln_post = norm_layer(width)\\n self.proj = nn.Parameter(scale * torch.randn(width, output_dim))\\n\\n self.init_parameters()\\n\\n def lock(self, unlocked_groups=0, freeze_bn_stats=False):\\n for param in self.parameters():\\n param.requires_grad = False\\n\\n if unlocked_groups != 0:\\n groups = [\\n [\\n self.conv1,\\n self.class_embedding,\\n self.ln_pre,\\n ],\\n self.positional_embedding,\\n *self.transformer.resblocks[:-1],\\n [\\n self.transformer.resblocks[-1],\\n # self.ln_post, # fix layer norm\\n ],\\n # self.proj, # fix output layers\\n ]\\n\\n def _unlock(x):\\n if isinstance(x, Sequence):\\n for g in x:\\n _unlock(g)\\n else:\\n if isinstance(x, torch.nn.Parameter):\\n x.requires_grad = True\\n else:\\n for p in x.parameters():\\n p.requires_grad = True\\n\\n _unlock(groups[-unlocked_groups:])\\n\\n def attention_lock(self, **kwargs):\\n for name, params in self.named_parameters():\\n params.requires_grad = True if \\\"attn\\\" in name or \\\"position\\\" in name else False\\n\\n def init_parameters(self):\\n # FIXME OpenAI CLIP did not define an init for the VisualTransformer\\n # TODO experiment if default PyTorch init, below, or alternate init is best.\\n pass\\n\\n @torch.jit.ignore\\n def set_grad_checkpointing(self, enable=True):\\n self.transformer.grad_checkpointing = enable\\n\\n def _global_pool(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\\n if self.global_average_pool:\\n return x.mean(dim=1), x\\n else:\\n return x[:, 0], x[:, 1:]\\n\\n def forward(self, x: torch.Tensor):\\n\\n # to patches - whether to use dual patchnorm - https://arxiv.org/abs/2302.01327v1\\n # if self.input_patchnorm:\\n # # einops - rearrange(x, 'b c (h p1) (w p2) -> b (h w) (c p1 p2)')\\n # x = x.reshape(x.shape[0], x.shape[1], self.grid_size[0], self.patch_size[0], self.grid_size[1], self.patch_size[1])\\n # x = x.permute(0, 2, 4, 1, 3, 5)\\n # x = x.reshape(x.shape[0], self.grid_size[0] * self.grid_size[1], -1)\\n # x = self.patchnorm_pre_ln(x)\\n # x = self.conv1(x)\\n # else:\\n x = self.conv1(x) # shape = [*, width, grid, grid]\\n bs, _, h, w = x.shape\\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\\n\\n # class embeddings and positional embeddings\\n x = torch.cat(\\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\\n # TODO: Allow interpolating the positional embeddings\\n\\n if (h, w) == self.grid_size:\\n pe = self.positional_embedding.to(x.dtype)\\n else:\\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\\n\\n x = x + pe\\n\\n # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in\\n x = self.patch_dropout(x)\\n x = self.ln_pre(x)\\n\\n x = x.permute(1, 0, 2) # NLD -> LND\\n x = self.transformer(x)\\n x = x.permute(1, 0, 2) # LND -> NLD\\n\\n if self.attn_pool is not None:\\n x = self.attn_pool(x)\\n x = self.ln_post(x)\\n pooled, tokens = self._global_pool(x)\\n else:\\n pooled, tokens = self._global_pool(x)\\n pooled = self.ln_post(pooled)\\n\\n if self.proj is not None:\\n pooled = pooled @ self.proj\\n\\n if self.output_tokens:\\n return pooled, tokens\\n \\n return pooled\\n\\n def post_attention(self, x):\\n x = x.permute(1, 0, 2) # LND -> NLD\\n\\n if self.attn_pool is not None:\\n x = self.attn_pool(x)\\n x = self.ln_post(x)\\n pooled, tokens = self._global_pool(x)\\n else:\\n pooled, tokens = self._global_pool(x)\\n pooled = self.ln_post(pooled)\\n\\n if self.proj is not None:\\n pooled = pooled @ self.proj\\n\\n if self.output_tokens:\\n return pooled, tokens\\n\\n return pooled\\n\\n def extract_roi_features(self, x, normed_boxes, extract_type='v2'):\\n if extract_type == 'v1':\\n return self._extract_roi_features_v1(x, normed_boxes)\\n elif extract_type == 'v2':\\n return self._extract_roi_features_v2(x, normed_boxes)\\n else:\\n raise NotImplementedError\\n # assert extract_type == 'v3'\\n # return self._extract_roi_features_v3(x, normed_boxes)\\n\\n def mask_pool(self, x, masks):\\n feature_map = self.encode_dense(x)\\n feature_map = F.normalize(feature_map, dim=-1)\\n\\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\\n masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w\\n feature_map = torch.repeat_interleave(\\n feature_map, torch.tensor(num_masks_per_image, device=feature_map.device), dim=0)\\n features = (feature_map * masks.unsqueeze(-1)).sum(1) / (masks.sum(1, keepdim=True) + 1e-12)\\n\\n return features\\n\\n def mask_features(self, x, masks):\\n feature_map = self.encode_dense(x)\\n feature_map = F.normalize(feature_map, dim=-1)\\n\\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\\n masks = torch.cat(masks).flatten(-2, -1) > 0 # bs, h*w\\n feature_map = torch.repeat_interleave(\\n feature_map, torch.tensor(num_masks_per_image, device=feature_map.device), dim=0)\\n\\n mask_features = [f[m] for m, f in zip(masks, feature_map)]\\n\\n return mask_features\\n\\n def encode_dense(self, x, keep_shape=False):\\n x = self.conv1(x) # shape = [*, width, grid, grid]\\n bs, _, h, w = x.shape\\n # assert h == w # TODO: support input of any shape, need to change the normed boxes to real boxes\\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\\n x = torch.cat(\\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\\n if (h, w) == self.grid_size:\\n pe = self.positional_embedding.to(x.dtype)\\n else:\\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\\n\\n x = x + pe\\n\\n # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in\\n x = self.patch_dropout(x)\\n x = self.ln_pre(x)\\n\\n x = x.permute(1, 0, 2) # NLD -> LND\\n x = self.transformer.extract_feature_map(x)\\n x = x.permute(1, 0, 2) # LND -> NLD\\n\\n if self.attn_pool is not None:\\n x = self.attn_pool(x)\\n x = self.ln_post(x)\\n _, tokens = self._global_pool(x)\\n else:\\n _, tokens = self._global_pool(x)\\n tokens = self.ln_post(tokens)\\n\\n if self.proj is not None:\\n tokens = tokens @ self.proj\\n\\n feature_map = tokens.view(bs, h * w, -1) # .permute(0, 3, 1, 2)\\n feature_map = F.normalize(feature_map, dim=-1) # normalize at the last dimension\\n if keep_shape:\\n feature_map = feature_map.view(bs, h, w, -1).permute(0, 3, 1, 2)\\n return feature_map\\n\\n def mask_crop(self, x, masks):\\n x = self.conv1(x) # shape = [*, width, grid, grid]\\n num_masks_per_image = [len(masks_per_image) for masks_per_image in masks]\\n masks = torch.cat(masks).to(x) # bs, h, w\\n x = torch.repeat_interleave(\\n x, torch.tensor(num_masks_per_image, device=x.device), dim=0)\\n x = x * masks[:, None]\\n bs, _, h, w = x.shape\\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\\n\\n # class embeddings and positional embeddings\\n x = torch.cat(\\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\\n # TODO: Allow interpolating the positional embeddings\\n\\n if (h, w) == self.grid_size:\\n pe = self.positional_embedding.to(x.dtype)\\n else:\\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\\n\\n x = x + pe\\n\\n x = self.patch_dropout(x)\\n x = self.ln_pre(x)\\n\\n x = x.permute(1, 0, 2) # NLD -> LND\\n x = self.transformer(x)\\n x = x.permute(1, 0, 2) # LND -> NLD\\n\\n if self.attn_pool is not None:\\n x = self.attn_pool(x)\\n x = self.ln_post(x)\\n pooled, tokens = self._global_pool(x)\\n else:\\n pooled, tokens = self._global_pool(x)\\n pooled = self.ln_post(pooled)\\n\\n if self.proj is not None:\\n pooled = pooled @ self.proj\\n\\n return pooled\\n\\n @staticmethod\\n def _generate_masks_per_image(normed_boxes, mask_h, mask_w):\\n num_boxes = len(normed_boxes)\\n boxes = normed_boxes * torch.tensor(\\n [[mask_w, mask_h, mask_w, mask_h]], device=normed_boxes.device)\\n masks = torch.zeros(num_boxes, mask_h, mask_w,\\n dtype=torch.bool, device=normed_boxes.device)\\n for i, box in enumerate(boxes):\\n x0, y0, x1, y1 = box.long().tolist()\\n masks[i, y0:y1, x0:x1] = True\\n\\n return masks\\n \\n @staticmethod\\n def _denormalize_boxes(normed_boxes, x):\\n h, w = x.shape[-2:]\\n denormed_boxes = []\\n for boxes in normed_boxes:\\n new_boxes = boxes.clone() # FIXME: do not change the value in normed_boxes!\\n new_boxes[:, [0, 2]] *= w\\n new_boxes[:, [1, 3]] *= h\\n denormed_boxes.append(new_boxes)\\n return denormed_boxes\\n\\n def _extract_roi_features_v1(self, x, normed_boxes):\\n # used masks\\n bs, _, h, w = x.shape\\n patch_height, patch_width = self.patch_size\\n mask_h, mask_w = h // patch_height, w // patch_width\\n masks = [self._generate_masks_per_image(normed_boxes_, mask_h, mask_w)\\n for normed_boxes_ in normed_boxes]\\n\\n return self.mask_attn_pool(x, masks)\\n\\n def _extract_roi_features_v3(self, x, normed_boxes): # v3 for extract two types\\n # used masks\\n bs, _, h, w = x.shape\\n patch_height, patch_width = self.patch_size\\n mask_h, mask_w = h // patch_height, w // patch_width\\n masks = [self._generate_masks_per_image(normed_boxes_, mask_h, mask_w)\\n for normed_boxes_ in normed_boxes]\\n\\n roi_features_v1, dense_x = self.mask_attn_pool(x, masks, return_dense=True)\\n dense_x = F.normalize(dense_x, dim=-1) # normalize along last dimension\\n dense_x = dense_x.permute(0, 3, 1, 2)\\n roi_features_v2 = roi_align(dense_x, self._denormalize_boxes(normed_boxes, dense_x), \\n (1, 1), 1.0, -1, True)[..., 0, 0]\\n\\n return roi_features_v1, roi_features_v2\\n\\n def _extract_roi_features_v2(self, x, normed_boxes):\\n x = self.conv1(x) # shape = [*, width, grid, grid]\\n bs, _, h, w = x.shape\\n # assert h == w # TODO: support input of any shape, need to change the normed boxes to real boxes\\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\\n x = torch.cat(\\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\\n if (h, w) == self.grid_size:\\n pe = self.positional_embedding.to(x.dtype)\\n else:\\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\\n\\n x = x + pe\\n\\n # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in\\n x = self.patch_dropout(x)\\n x = self.ln_pre(x)\\n\\n x = x.permute(1, 0, 2) # NLD -> LND\\n x = self.transformer.extract_feature_map(x)\\n x = x.permute(1, 0, 2) # LND -> NLD\\n\\n if self.attn_pool is not None:\\n x = self.attn_pool(x)\\n x = self.ln_post(x)\\n _, tokens = self._global_pool(x)\\n else:\\n _, tokens = self._global_pool(x)\\n tokens = self.ln_post(tokens)\\n\\n if self.proj is not None:\\n tokens = tokens @ self.proj\\n tokens = F.normalize(tokens, dim=-1) # normalize along last dimension\\n tokens = tokens.view(bs, h, w, -1).permute(0, 3, 1, 2)\\n return roi_align(tokens, self._denormalize_boxes(normed_boxes, tokens),\\n (1, 1), 1.0, -1, True)[..., 0, 0]\\n\\n def rescale_positional_embedding(self, out_size, dtype):\\n h, w = out_size\\n rescaled_positional_embedding = \\\\\\n self.positional_embedding.new_zeros(1 + h*w, self.positional_embedding.shape[1])\\n rescaled_positional_embedding[0] = self.positional_embedding[0]\\n pe_2d = self.positional_embedding[1:].T.contiguous().view(\\n 1, -1, *self.grid_size)\\n pe_2d = F.interpolate(pe_2d, out_size, mode='bicubic', align_corners=False).view(-1, h*w)\\n rescaled_positional_embedding[1:] = pe_2d.T.contiguous()\\n\\n return rescaled_positional_embedding.to(dtype=dtype)\\n\\n def _mask_attn_pool(self, x: torch.Tensor, attn_mask: torch.Tensor, num_mask_tokens: int, return_dense=False):\\n x = self.conv1(x) # shape = [*, width, grid, grid]\\n bs, _, h, w = x.shape\\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\\n x = torch.cat(\\n [\\n self.class_embedding.to(x.dtype)\\n + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\\n x,\\n ],\\n dim=1,\\n ) # shape = [*, grid ** 2 + 1, width]\\n if (h, w) == self.grid_size:\\n pe = self.positional_embedding.to(x.dtype)\\n else:\\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\\n\\n x = x + pe\\n x = self.ln_pre(x)\\n\\n x = x.permute(1, 0, 2) # NLD -> LND\\n cls_embed = x[0:1]\\n cls_embed = cls_embed.expand(num_mask_tokens, -1, -1)\\n x = torch.cat([cls_embed, x], dim=0)\\n if return_dense:\\n x, x_dense = self.transformer.forward_image_dense(x, attn_mask)\\n x_dense = x_dense.permute(1, 0, 2) # LND -> NLD\\n x_dense = x_dense[:, num_mask_tokens + 1:]\\n\\n x_dense = self.ln_post(x_dense)\\n\\n if self.proj is not None:\\n x_dense = x_dense @ self.proj\\n x_dense = F.normalize(x_dense, dim=-1) # normalize along last dimension\\n x_dense = x_dense.view(bs, h, w, -1)\\n else:\\n x = self.transformer(x, attn_mask)\\n x_dense = None\\n x = x.permute(1, 0, 2) # LND -> NLD\\n\\n # [N, L, D]\\n x = self.ln_post(x[:, :num_mask_tokens, :])\\n\\n if self.proj is not None:\\n x = torch.einsum(\\\"nld,dc->nlc\\\", x, self.proj)\\n\\n return x, x_dense\\n\\n def mask_attn_pool(self, image, masks, return_dense=False):\\n assert hasattr(self, \\\"positional_embedding\\\")\\n batch_size = image.shape[0]\\n assert batch_size == len(masks)\\n num_masks_per_image = [mask.shape[0] for mask in masks]\\n num_queries = max(num_masks_per_image)\\n mask_h, mask_w = masks[0].shape[1:]\\n\\n batch_masks = torch.ones(batch_size, num_queries, mask_h, mask_w, dtype=torch.bool).to(image.device)\\n for batch_id, mask in enumerate(masks):\\n batch_masks[batch_id, :mask.shape[0]] = mask\\n\\n mask_token_attn_mask = torch.logical_not(batch_masks)\\n # [B, Q, H//P x W//P]\\n mask_token_attn_mask = mask_token_attn_mask.reshape(batch_size, num_queries, -1)\\n\\n num_mask_token = num_queries\\n num_image_cls_token = (mask_h * mask_w + 1)\\n num_image_token = num_image_cls_token - 1\\n num_all_token = num_mask_token + num_image_cls_token\\n\\n # we start with no mask out\\n attn_mask = torch.zeros(\\n (num_all_token, num_all_token), dtype=torch.bool, device=image.device\\n )\\n\\n # mask+cls+image token to mask token attention is masked out\\n attn_mask[:, :num_mask_token] = True\\n\\n attn_mask = attn_mask.unsqueeze(0).repeat_interleave(batch_size, dim=0)\\n attn_mask[:, :num_mask_token, -num_image_token:] = mask_token_attn_mask\\n num_heads = self.num_heads # head width 64\\n attn_mask = attn_mask.unsqueeze(1).expand(-1, num_heads, -1, -1)\\n attn_mask = attn_mask.reshape(batch_size * num_heads, num_all_token, num_all_token)\\n\\n batch_mask_features, x_dense = self._mask_attn_pool(image, attn_mask, num_mask_token,\\n return_dense=return_dense)\\n\\n mask_features = [batch_mask_features[batch_id, :num_masks]\\n for batch_id, num_masks, in enumerate(num_masks_per_image)]\\n if return_dense:\\n # x_dense = F.normalize(x_dense, dim=-1).flatten(1, 2) # bs, h*w, c\\n # masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w\\n # x_dense = torch.repeat_interleave(\\n # x_dense, torch.tensor(num_masks_per_image, device=x_dense.device), dim=0)\\n # x_dense = (x_dense * masks.unsqueeze(-1)).sum(1) / masks.sum(1, keepdim=True)\\n\\n return torch.cat(mask_features), x_dense\\n else:\\n return torch.cat(mask_features)\\n\\n def encode_rois_and_image(self, x, normed_boxes):\\n x = self.conv1(x) # shape = [*, width, grid, grid]\\n bs, _, h, w = x.shape\\n # assert h == w # TODO: support input of any shape, need to change the normed boxes to real boxes\\n x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]\\n x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]\\n x = torch.cat(\\n [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),\\n x], dim=1) # shape = [*, grid ** 2 + 1, width]\\n if (h, w) == self.grid_size:\\n pe = self.positional_embedding.to(x.dtype)\\n else:\\n pe = self.rescale_positional_embedding(out_size=(h, w), dtype=x.dtype)\\n\\n x = x + pe\\n\\n # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in\\n x = self.patch_dropout(x)\\n x = self.ln_pre(x)\\n\\n x = x.permute(1, 0, 2) # NLD -> LND\\n x, x_image = self.transformer.extract_feature_map(x, return_forward=True)\\n x = x.permute(1, 0, 2) # LND -> NLD\\n\\n if self.attn_pool is not None:\\n x = self.attn_pool(x)\\n x = self.ln_post(x)\\n _, tokens = self._global_pool(x)\\n else:\\n _, tokens = self._global_pool(x)\\n tokens = self.ln_post(tokens)\\n\\n if self.proj is not None:\\n tokens = tokens @ self.proj\\n\\n feature_map = tokens.view(bs, h * w, -1) # .permute(0, 3, 1, 2)\\n feature_map = F.normalize(feature_map, dim=-1)\\n feature_map = feature_map.view(bs, h, w, -1).permute(0, 3, 1, 2)\\n x_rois = roi_align(feature_map, self._denormalize_boxes(normed_boxes, feature_map),\\n (1, 1), 1.0, -1, True)[..., 0, 0]\\n x_rois = F.normalize(x_rois, dim=-1)\\n\\n x_image = self.post_attention(x_image)\\n x_image = F.normalize(x_image, dim=-1)\\n\\n return x_rois, x_image\"\n },\n {\n \"identifier\": \"TextTransformer\",\n \"path\": \"src/open_clip/transformer.py\",\n \"snippet\": \"class TextTransformer(nn.Module):\\n output_tokens: torch.jit.Final[bool]\\n\\n def __init__(\\n self,\\n context_length: int = 77,\\n vocab_size: int = 49408,\\n width: int = 512,\\n heads: int = 8,\\n layers: int = 12,\\n ls_init_value: float = None,\\n output_dim: int = 512,\\n act_layer: Callable = nn.GELU,\\n norm_layer: Callable = LayerNorm,\\n embed_cls: bool = False,\\n pad_id: int = 0,\\n output_tokens: bool = False,\\n ):\\n super().__init__()\\n self.output_tokens = output_tokens\\n self.num_pos = self.context_length = context_length\\n self.vocab_size = vocab_size\\n self.width = width\\n self.output_dim = output_dim\\n self.heads = heads\\n self.pad_id = pad_id\\n\\n self.text_projection = nn.Parameter(torch.empty(width, output_dim))\\n\\n if embed_cls:\\n self.cls_emb = nn.Parameter(torch.empty(width))\\n self.num_pos += 1\\n else:\\n self.cls_emb = None\\n\\n self.token_embedding = nn.Embedding(vocab_size, width)\\n self.positional_embedding = nn.Parameter(torch.empty(self.num_pos, width))\\n self.transformer = Transformer(\\n width=width,\\n layers=layers,\\n heads=heads,\\n ls_init_value=ls_init_value,\\n act_layer=act_layer,\\n norm_layer=norm_layer,\\n )\\n self.ln_final = norm_layer(width)\\n\\n self.register_buffer('attn_mask', self.build_attention_mask(), persistent=False)\\n\\n self.init_parameters()\\n\\n def init_parameters(self):\\n nn.init.normal_(self.token_embedding.weight, std=0.02)\\n nn.init.normal_(self.positional_embedding, std=0.01)\\n if self.cls_emb is not None:\\n nn.init.normal_(self.cls_emb, std=0.01)\\n\\n proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5)\\n attn_std = self.transformer.width ** -0.5\\n fc_std = (2 * self.transformer.width) ** -0.5\\n for block in self.transformer.resblocks:\\n nn.init.normal_(block.attn.in_proj_weight, std=attn_std)\\n nn.init.normal_(block.attn.out_proj.weight, std=proj_std)\\n nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)\\n nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)\\n\\n if self.text_projection is not None:\\n nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5)\\n\\n def lock(self, unlocked_layers: int = 0, freeze_layer_norm: bool = True):\\n assert unlocked_layers == 0 and freeze_layer_norm\\n print(f'Freeze the text encoder', flush=True)\\n for p in self.parameters():\\n p.requires_grad = False\\n\\n @torch.jit.ignore\\n def set_grad_checkpointing(self, enable=True):\\n self.transformer.grad_checkpointing = enable\\n\\n def build_attention_mask(self):\\n # lazily create causal attention mask, with full attention between the tokens\\n # pytorch uses additive attention mask; fill with -inf\\n mask = torch.empty(self.num_pos, self.num_pos)\\n mask.fill_(float(\\\"-inf\\\"))\\n mask.triu_(1) # zero out the lower diagonal\\n return mask\\n\\n def build_cls_mask(self, text, cast_dtype: torch.dtype):\\n cls_mask = (text != self.pad_id).unsqueeze(1)\\n cls_mask = F.pad(cls_mask, (1, 0, cls_mask.shape[2], 0), value=1.0)\\n additive_mask = torch.empty(cls_mask.shape, dtype=cast_dtype, device=cls_mask.device)\\n additive_mask.fill_(0)\\n additive_mask.masked_fill_(~cls_mask, float(\\\"-inf\\\"))\\n additive_mask = torch.repeat_interleave(additive_mask, self.heads, 0)\\n return additive_mask\\n\\n def _repeat(self, t, N: int):\\n return t.reshape(1, 1, -1).repeat(N, 1, 1)\\n\\n def forward(self, text):\\n cast_dtype = self.transformer.get_cast_dtype()\\n seq_len = text.shape[1]\\n\\n x = self.token_embedding(text).to(cast_dtype) # [batch_size, n_ctx, d_model]\\n attn_mask = self.attn_mask\\n if self.cls_emb is not None:\\n seq_len += 1\\n x = torch.cat([x, self._repeat(self.cls_emb, x.shape[0])], dim=1)\\n cls_mask = self.build_cls_mask(text, cast_dtype)\\n attn_mask = attn_mask[None, :seq_len, :seq_len] + cls_mask[:, :seq_len, :seq_len]\\n\\n x = x + self.positional_embedding[:seq_len].to(cast_dtype)\\n x = x.permute(1, 0, 2) # NLD -> LND\\n x = self.transformer(x, attn_mask=attn_mask)\\n x = x.permute(1, 0, 2) # LND -> NLD\\n\\n # x.shape = [batch_size, n_ctx, transformer.width]\\n # take features from the eot embedding (eot_token is the highest number in each sequence)\\n if self.cls_emb is not None:\\n pooled, tokens = x[:, -1], x[:, :-1]\\n pooled = self.ln_final(pooled)\\n else:\\n x = self.ln_final(x)\\n pooled, tokens = x[torch.arange(x.shape[0]), text.argmax(dim=-1)], x\\n\\n if self.text_projection is not None:\\n pooled = pooled @ self.text_projection\\n\\n if self.output_tokens:\\n return pooled, tokens\\n\\n return pooled\"\n },\n {\n \"identifier\": \"to_2tuple\",\n \"path\": \"src/open_clip/utils.py\",\n \"snippet\": \"def freeze_batch_norm_2d(module, module_match={}, name=''):\\ndef _ntuple(n):\\n def parse(x):\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from dataclasses import dataclass\nfrom typing import Optional, Tuple, Union\nfrom torch import nn\nfrom torch.utils.checkpoint import checkpoint\nfrom .hf_model import HFTextEncoder\nfrom .modified_resnet import ModifiedResNet\nfrom .timm_model import TimmModel\nfrom .transformer import LayerNormFp32, LayerNorm, QuickGELU, Attention, VisionTransformer, TextTransformer\nfrom .utils import to_2tuple\nimport logging\nimport math\nimport numpy as np\nimport torch\nimport torch.nn.functional as F"},"token_num":{"kind":"number","value":17623,"string":"17,623"},"cropped_code":{"kind":"string","value":" l.bias.data = l.bias.data.to(dtype)\n\n if isinstance(l, (nn.MultiheadAttention, Attention)):\n for attr in [*[f\"{s}_proj_weight\" for s in [\"in\", \"q\", \"k\", \"v\"]], \"in_proj_bias\", \"bias_k\", \"bias_v\"]:\n tensor = getattr(l, attr)\n if tensor is not None:\n tensor.data = tensor.data.to(dtype)\n\n for name in [\"text_projection\", \"proj\"]:\n if hasattr(l, name):\n attr = getattr(l, name)\n if attr is not None:\n attr.data = attr.data.to(dtype)\n\n model.apply(_convert_weights)\n\n\nconvert_weights_to_fp16 = convert_weights_to_lp # backwards compat\n\n\n# used to maintain checkpoint compatibility\ndef convert_to_custom_text_state_dict(state_dict: dict):\n if 'text_projection' in state_dict:\n # old format state_dict, move text tower -> .text\n new_state_dict = {}\n for k, v in state_dict.items():\n if any(k.startswith(p) for p in (\n 'text_projection',\n 'positional_embedding',\n 'token_embedding',\n 'transformer',\n 'ln_final',\n )):\n k = 'text.' + k\n new_state_dict[k] = v\n return new_state_dict\n return state_dict\n\n\ndef build_model_from_openai_state_dict(\n state_dict: dict,\n quick_gelu=True,\n cast_dtype=torch.float16,\n):\n vit = \"visual.proj\" in state_dict\n\n if vit:\n vision_width = state_dict[\"visual.conv1.weight\"].shape[0]\n vision_layers = len(\n [k for k in state_dict.keys() if k.startswith(\"visual.\") and k.endswith(\".attn.in_proj_weight\")])\n vision_patch_size = state_dict[\"visual.conv1.weight\"].shape[-1]\n grid_size = round((state_dict[\"visual.positional_embedding\"].shape[0] - 1) ** 0.5)\n image_size = vision_patch_size * grid_size\n else:\n counts: list = [\n len(set(k.split(\".\")[2] for k in state_dict if k.startswith(f\"visual.layer{b}\"))) for b in [1, 2, 3, 4]]\n vision_layers = tuple(counts)\n vision_width = state_dict[\"visual.layer1.0.conv1.weight\"].shape[0]\n output_width = round((state_dict[\"visual.attnpool.positional_embedding\"].shape[0] - 1) ** 0.5)\n vision_patch_size = None\n assert output_width ** 2 + 1 == state_dict[\"visual.attnpool.positional_embedding\"].shape[0]\n image_size = output_width * 32\n\n embed_dim = state_dict[\"text_projection\"].shape[1]\n context_length = state_dict[\"positional_embedding\"].shape[0]\n vocab_size = state_dict[\"token_embedding.weight\"].shape[0]\n transformer_width = state_dict[\"ln_final.weight\"].shape[0]\n transformer_heads = transformer_width // 64\n transformer_layers = len(set(k.split(\".\")[2] for k in state_dict if k.startswith(f\"transformer.resblocks\")))\n\n vision_cfg = CLIPVisionCfg(\n layers=vision_layers,\n width=vision_width,\n patch_size=vision_patch_size,\n image_size=image_size,\n )\n text_cfg = CLIPTextCfg(\n context_length=context_length,\n vocab_size=vocab_size,\n width=transformer_width,\n heads=transformer_heads,\n layers=transformer_layers,\n )\n model = CLIP(\n embed_dim,\n vision_cfg=vision_cfg,\n text_cfg=text_cfg,\n quick_gelu=quick_gelu, # OpenAI models were trained with QuickGELU\n cast_dtype=cast_dtype,\n )\n\n for key in [\"input_resolution\", \"context_length\", \"vocab_size\"]:\n state_dict.pop(key, None)\n\n convert_weights_to_fp16(model) # OpenAI state dicts are partially converted to float16\n model.load_state_dict(state_dict)\n return model.eval()\n\n\ndef trace_model(model, batch_size=256, device=torch.device('cpu')):\n model.eval()\n image_size = model.visual.image_size\n example_images = torch.ones((batch_size, 3, image_size, image_size), device=device)\n example_text = torch.zeros((batch_size, model.context_length), dtype=torch.int, device=device)\n model = torch.jit.trace_module(\n model,\n inputs=dict(\n forward=(example_images, example_text),\n encode_text=(example_text,),\n encode_image=(example_images,)\n ))\n model.visual.image_size = image_size\n return model\n\n\ndef resize_pos_embed(state_dict, model, interpolation: str = 'bicubic', antialias: bool = True):\n # Rescale the grid of position embeddings when loading from state_dict\n old_pos_embed = state_dict.get('visual.positional_embedding', None)\n if old_pos_embed is None or not hasattr(model.visual, 'grid_size'):\n return\n"},"all_code":{"kind":"string","value":"\"\"\" CLIP Model\n\nAdapted from https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI.\n\"\"\"\n\n\n\n\n@dataclass\nclass CLIPVisionCfg:\n layers: Union[Tuple[int, int, int, int], int] = 12\n width: int = 768\n head_width: int = 64\n mlp_ratio: float = 4.0\n patch_size: int = 16\n image_size: Union[Tuple[int, int], int] = 224\n ls_init_value: Optional[float] = None # layer scale initial value\n 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\n 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\n 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)\n attentional_pool: bool = False # whether to use attentional pooler in the last embedding layer\n n_queries: int = 256 # n_queries for attentional pooler\n attn_pooler_heads: int = 8 # n heads for attentional_pooling\n timm_model_name: str = None # a valid model name overrides layers, width, patch_size\n timm_model_pretrained: bool = False # use (imagenet) pretrained weights for named model\n timm_pool: str = 'avg' # feature pooling for timm model ('abs_attn', 'rot_attn', 'avg', '')\n timm_proj: str = 'linear' # linear projection for timm model output ('linear', 'mlp', '')\n timm_proj_bias: bool = False # enable bias final projection\n timm_drop: float = 0. # head dropout\n timm_drop_path: Optional[float] = None # backbone stochastic depth\n output_tokens: bool = False\n freeze_output = True\n freeze_all_bns = True\n\n\n@dataclass\nclass CLIPTextCfg:\n context_length: int = 77\n vocab_size: int = 49408\n width: int = 512\n heads: int = 8\n layers: int = 12\n ls_init_value: Optional[float] = None # layer scale initial value\n hf_model_name: str = None\n hf_tokenizer_name: str = None\n hf_model_pretrained: bool = True\n proj: str = 'mlp'\n pooler_type: str = 'mean_pooler'\n embed_cls: bool = False\n pad_id: int = 0\n output_tokens: bool = False\n\n\ndef get_cast_dtype(precision: str):\n cast_dtype = None\n if precision == 'bf16':\n cast_dtype = torch.bfloat16\n elif precision == 'fp16':\n cast_dtype = torch.float16\n return cast_dtype\n\n\ndef _build_vision_tower(\n embed_dim: int,\n vision_cfg: CLIPVisionCfg,\n quick_gelu: bool = False,\n cast_dtype: Optional[torch.dtype] = None\n):\n if isinstance(vision_cfg, dict):\n vision_cfg = CLIPVisionCfg(**vision_cfg)\n\n # OpenAI models are pretrained w/ QuickGELU but native nn.GELU is both faster and more\n # memory efficient in recent PyTorch releases (>= 1.10).\n # NOTE: timm models always use native GELU regardless of quick_gelu flag.\n act_layer = QuickGELU if quick_gelu else nn.GELU\n\n if vision_cfg.timm_model_name:\n visual = TimmModel(\n vision_cfg.timm_model_name,\n pretrained=vision_cfg.timm_model_pretrained,\n pool=vision_cfg.timm_pool,\n proj=vision_cfg.timm_proj,\n proj_bias=vision_cfg.timm_proj_bias,\n drop=vision_cfg.timm_drop,\n drop_path=vision_cfg.timm_drop_path,\n patch_drop=vision_cfg.patch_dropout if vision_cfg.patch_dropout > 0 else None,\n embed_dim=embed_dim,\n image_size=vision_cfg.image_size,\n )\n act_layer = nn.GELU # so that text transformer doesn't use QuickGELU w/ timm models\n elif isinstance(vision_cfg.layers, (tuple, list)):\n vision_heads = vision_cfg.width * 32 // vision_cfg.head_width\n visual = ModifiedResNet(\n layers=vision_cfg.layers,\n output_dim=embed_dim,\n heads=vision_heads,\n image_size=vision_cfg.image_size,\n width=vision_cfg.width,\n freeze_output=vision_cfg.freeze_output,\n freeze_all_bns=vision_cfg.freeze_all_bns\n )\n else:\n vision_heads = vision_cfg.width // vision_cfg.head_width\n norm_layer = LayerNormFp32 if cast_dtype in (torch.float16, torch.bfloat16) else LayerNorm\n visual = VisionTransformer(\n image_size=vision_cfg.image_size,\n patch_size=vision_cfg.patch_size,\n width=vision_cfg.width,\n layers=vision_cfg.layers,\n heads=vision_heads,\n mlp_ratio=vision_cfg.mlp_ratio,\n ls_init_value=vision_cfg.ls_init_value,\n patch_dropout=vision_cfg.patch_dropout,\n input_patchnorm=vision_cfg.input_patchnorm,\n global_average_pool=vision_cfg.global_average_pool,\n attentional_pool=vision_cfg.attentional_pool,\n n_queries=vision_cfg.n_queries,\n attn_pooler_heads=vision_cfg.attn_pooler_heads,\n output_tokens=vision_cfg.output_tokens,\n output_dim=embed_dim,\n act_layer=act_layer,\n norm_layer=norm_layer,\n )\n\n return visual\n\n\ndef _build_text_tower(\n embed_dim: int,\n text_cfg: CLIPTextCfg,\n quick_gelu: bool = False,\n cast_dtype: Optional[torch.dtype] = None,\n):\n if isinstance(text_cfg, dict):\n text_cfg = CLIPTextCfg(**text_cfg)\n\n if text_cfg.hf_model_name:\n text = HFTextEncoder(\n text_cfg.hf_model_name,\n output_dim=embed_dim,\n proj=text_cfg.proj,\n pooler_type=text_cfg.pooler_type,\n pretrained=text_cfg.hf_model_pretrained,\n output_tokens=text_cfg.output_tokens,\n )\n else:\n act_layer = QuickGELU if quick_gelu else nn.GELU\n norm_layer = LayerNormFp32 if cast_dtype in (torch.float16, torch.bfloat16) else LayerNorm\n\n text = TextTransformer(\n context_length=text_cfg.context_length,\n vocab_size=text_cfg.vocab_size,\n width=text_cfg.width,\n heads=text_cfg.heads,\n layers=text_cfg.layers,\n ls_init_value=text_cfg.ls_init_value,\n output_dim=embed_dim,\n embed_cls=text_cfg.embed_cls,\n output_tokens=text_cfg.output_tokens,\n pad_id=text_cfg.pad_id,\n act_layer=act_layer,\n norm_layer=norm_layer,\n )\n return text\n\n\nclass CLIP(nn.Module):\n output_dict: torch.jit.Final[bool]\n\n def __init__(\n self,\n embed_dim: int,\n vision_cfg: CLIPVisionCfg,\n text_cfg: CLIPTextCfg,\n quick_gelu: bool = False,\n cast_dtype: Optional[torch.dtype] = None,\n output_dict: bool = False,\n freeze_text=True,\n ):\n assert freeze_text, 'For now we must freeze text'\n super().__init__()\n self.output_dict = output_dict\n self.visual = _build_vision_tower(embed_dim, vision_cfg, quick_gelu, cast_dtype)\n\n text = _build_text_tower(embed_dim, text_cfg, quick_gelu, cast_dtype)\n if freeze_text:\n print(f'Freeze text encoder parameters', flush=True)\n for param in text.parameters():\n param.requires_grad = False\n text.eval()\n self.transformer = text.transformer\n self.vocab_size = text.vocab_size\n self.embed_dim = embed_dim\n self.token_embedding = text.token_embedding\n self.positional_embedding = text.positional_embedding\n self.ln_final = text.ln_final\n self.text_projection = text.text_projection\n self.register_buffer('attn_mask', text.attn_mask, persistent=False)\n\n self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))\n\n def lock_image_tower(self, unlocked_groups=0, freeze_bn_stats=False, **kwargs):\n self.visual.lock(unlocked_groups=unlocked_groups, freeze_bn_stats=freeze_bn_stats)\n\n @torch.jit.ignore\n def set_grad_checkpointing(self, enable=True):\n self.visual.set_grad_checkpointing(enable)\n self.transformer.grad_checkpointing = enable\n\n def encode_image(self, image, normalize: bool = False):\n features = self.visual(image)\n return F.normalize(features, dim=-1) if normalize else features\n\n def encode_dense(self, image, normalize: bool = False, keep_shape=False):\n features = self.visual.encode_dense(image, keep_shape=keep_shape)\n if normalize:\n if keep_shape:\n features = F.normalize(features, dim=1)\n else:\n features = F.normalize(features, dim=-1)\n return features\n\n def encode_pseudo_boxes(self, image, normed_boxes, normalize: bool = False,\n extract_type='v1'):\n features = self.visual.extract_roi_features(image, normed_boxes,\n extract_type=extract_type)\n if normalize:\n features = F.normalize(features, dim=-1)\n return features\n\n def _pool_masks(self, image, masks, normalize, mask_attn=False):\n if mask_attn:\n mask_pooled = self.visual.mask_attn_pool(image, masks)\n else:\n mask_pooled = self.visual.mask_pool(image, masks)\n if normalize:\n mask_pooled = F.normalize(mask_pooled, dim=-1)\n return mask_pooled\n\n def _pool_masks_v3(self, image, masks, normalize):\n mask_pooled_v1, x_dense = self.visual.mask_attn_pool(image, masks, return_dense=True)\n x_dense = F.normalize(x_dense, dim=-1).flatten(1, 2) # bs, h*w, c\n x_dense = torch.repeat_interleave(\n x_dense, torch.tensor([len(m) for m in masks], device=x_dense.device), dim=0)\n masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w\n mask_pooled_v2 = (x_dense * masks.unsqueeze(-1)).sum(1) / masks.sum(1, keepdim=True)\n if normalize:\n mask_pooled_v1 = F.normalize(mask_pooled_v1, dim=-1)\n mask_pooled_v2 = F.normalize(mask_pooled_v2, dim=-1)\n return mask_pooled_v1, mask_pooled_v2\n\n def encode_masks(self, image, masks, normalize=True, mask_attn=False):\n return self._pool_masks(image, masks, normalize, mask_attn)\n\n def encode_text(self, text, normalize: bool = False):\n cast_dtype = self.transformer.get_cast_dtype()\n\n x = self.token_embedding(text).to(cast_dtype) # [batch_size, n_ctx, d_model]\n\n x = x + self.positional_embedding.to(cast_dtype)\n x = x.permute(1, 0, 2) # NLD -> LND\n x = self.transformer(x, attn_mask=self.attn_mask)\n x = x.permute(1, 0, 2) # LND -> NLD\n x = self.ln_final(x) # [batch_size, n_ctx, transformer.width]\n # take features from the eot embedding (eot_token is the highest number in each sequence)\n x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection\n return F.normalize(x, dim=-1) if normalize else x\n\n def forward(self, image, text=None):\n image_features = self.encode_image(image, normalize=True)\n if text is None:\n text_features = None\n else:\n text_features = self.encode_text(text, normalize=True)\n if self.output_dict:\n return {\n \"image_features\": image_features,\n \"text_features\": text_features,\n \"logit_scale\": self.logit_scale.exp()\n }\n return image_features, text_features, self.logit_scale.exp()\n\n def train(self, mode: bool = True):\n if not isinstance(mode, bool):\n raise ValueError(\"training mode is expected to be boolean\")\n self.training = mode\n for name, module in self.named_children():\n if name == 'visual':\n if mode:\n logging.info(f'========Set module {name} as train mode========')\n else:\n logging.info(f'========Set module {name} as eval mode========')\n module.train(mode)\n else:\n logging.info(f'========Set module {name} as eval mode========')\n module.train(mode=False)\n return self\n\n\nclass CustomTextCLIP(nn.Module):\n output_dict: torch.jit.Final[bool]\n\n def __init__(\n self,\n embed_dim: int,\n vision_cfg: CLIPVisionCfg,\n text_cfg: CLIPTextCfg,\n quick_gelu: bool = False,\n cast_dtype: Optional[torch.dtype] = None,\n output_dict: bool = False,\n ):\n super().__init__()\n self.output_dict = output_dict\n self.visual = _build_vision_tower(embed_dim, vision_cfg, quick_gelu, cast_dtype)\n self.text = _build_text_tower(embed_dim, text_cfg, quick_gelu, cast_dtype)\n self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))\n\n def lock_image_tower(self, unlocked_groups=0, freeze_bn_stats=False):\n # lock image tower as per LiT - https://arxiv.org/abs/2111.07991\n self.visual.lock(unlocked_groups=unlocked_groups, freeze_bn_stats=freeze_bn_stats)\n\n def lock_text_tower(self, unlocked_layers: int = 0, freeze_layer_norm: bool = True):\n self.text.lock(unlocked_layers, freeze_layer_norm)\n\n @torch.jit.ignore\n def set_grad_checkpointing(self, enable=True):\n self.visual.set_grad_checkpointing(enable)\n self.text.set_grad_checkpointing(enable)\n\n def encode_pseudo_boxes(self, image, normed_boxes, normalize: bool = False):\n features = self.visual.extract_roi_features(image, normed_boxes)\n return F.normalize(features, dim=-1) if normalize else features\n\n def encode_image(self, image, normalize: bool = False):\n features = self.visual(image)\n return F.normalize(features, dim=-1) if normalize else features\n\n def encode_text(self, text, normalize: bool = False):\n features = self.text(text)\n return F.normalize(features, dim=-1) if normalize else features\n\n def forward(self, image, text):\n image_features = self.encode_image(image, normalize=True)\n if text is None:\n text_features = None\n else:\n text_features = self.encode_text(text, normalize=True)\n if self.output_dict:\n return {\n \"image_features\": image_features,\n \"text_features\": text_features,\n \"logit_scale\": self.logit_scale.exp()\n }\n return image_features, text_features, self.logit_scale.exp()\n\n\ndef convert_weights_to_lp(model: nn.Module, dtype=torch.float16):\n \"\"\"Convert applicable model parameters to low-precision (bf16 or fp16)\"\"\"\n\n def _convert_weights(l):\n if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):\n l.weight.data = l.weight.data.to(dtype)\n if l.bias is not None:\n l.bias.data = l.bias.data.to(dtype)\n\n if isinstance(l, (nn.MultiheadAttention, Attention)):\n for attr in [*[f\"{s}_proj_weight\" for s in [\"in\", \"q\", \"k\", \"v\"]], \"in_proj_bias\", \"bias_k\", \"bias_v\"]:\n tensor = getattr(l, attr)\n if tensor is not None:\n tensor.data = tensor.data.to(dtype)\n\n for name in [\"text_projection\", \"proj\"]:\n if hasattr(l, name):\n attr = getattr(l, name)\n if attr is not None:\n attr.data = attr.data.to(dtype)\n\n model.apply(_convert_weights)\n\n\nconvert_weights_to_fp16 = convert_weights_to_lp # backwards compat\n\n\n# used to maintain checkpoint compatibility\ndef convert_to_custom_text_state_dict(state_dict: dict):\n if 'text_projection' in state_dict:\n # old format state_dict, move text tower -> .text\n new_state_dict = {}\n for k, v in state_dict.items():\n if any(k.startswith(p) for p in (\n 'text_projection',\n 'positional_embedding',\n 'token_embedding',\n 'transformer',\n 'ln_final',\n )):\n k = 'text.' + k\n new_state_dict[k] = v\n return new_state_dict\n return state_dict\n\n\ndef build_model_from_openai_state_dict(\n state_dict: dict,\n quick_gelu=True,\n cast_dtype=torch.float16,\n):\n vit = \"visual.proj\" in state_dict\n\n if vit:\n vision_width = state_dict[\"visual.conv1.weight\"].shape[0]\n vision_layers = len(\n [k for k in state_dict.keys() if k.startswith(\"visual.\") and k.endswith(\".attn.in_proj_weight\")])\n vision_patch_size = state_dict[\"visual.conv1.weight\"].shape[-1]\n grid_size = round((state_dict[\"visual.positional_embedding\"].shape[0] - 1) ** 0.5)\n image_size = vision_patch_size * grid_size\n else:\n counts: list = [\n len(set(k.split(\".\")[2] for k in state_dict if k.startswith(f\"visual.layer{b}\"))) for b in [1, 2, 3, 4]]\n vision_layers = tuple(counts)\n vision_width = state_dict[\"visual.layer1.0.conv1.weight\"].shape[0]\n output_width = round((state_dict[\"visual.attnpool.positional_embedding\"].shape[0] - 1) ** 0.5)\n vision_patch_size = None\n assert output_width ** 2 + 1 == state_dict[\"visual.attnpool.positional_embedding\"].shape[0]\n image_size = output_width * 32\n\n embed_dim = state_dict[\"text_projection\"].shape[1]\n context_length = state_dict[\"positional_embedding\"].shape[0]\n vocab_size = state_dict[\"token_embedding.weight\"].shape[0]\n transformer_width = state_dict[\"ln_final.weight\"].shape[0]\n transformer_heads = transformer_width // 64\n transformer_layers = len(set(k.split(\".\")[2] for k in state_dict if k.startswith(f\"transformer.resblocks\")))\n\n vision_cfg = CLIPVisionCfg(\n layers=vision_layers,\n width=vision_width,\n patch_size=vision_patch_size,\n image_size=image_size,\n )\n text_cfg = CLIPTextCfg(\n context_length=context_length,\n vocab_size=vocab_size,\n width=transformer_width,\n heads=transformer_heads,\n layers=transformer_layers,\n )\n model = CLIP(\n embed_dim,\n vision_cfg=vision_cfg,\n text_cfg=text_cfg,\n quick_gelu=quick_gelu, # OpenAI models were trained with QuickGELU\n cast_dtype=cast_dtype,\n )\n\n for key in [\"input_resolution\", \"context_length\", \"vocab_size\"]:\n state_dict.pop(key, None)\n\n convert_weights_to_fp16(model) # OpenAI state dicts are partially converted to float16\n model.load_state_dict(state_dict)\n return model.eval()\n\n\ndef trace_model(model, batch_size=256, device=torch.device('cpu')):\n model.eval()\n image_size = model.visual.image_size\n example_images = torch.ones((batch_size, 3, image_size, image_size), device=device)\n example_text = torch.zeros((batch_size, model.context_length), dtype=torch.int, device=device)\n model = torch.jit.trace_module(\n model,\n inputs=dict(\n forward=(example_images, example_text),\n encode_text=(example_text,),\n encode_image=(example_images,)\n ))\n model.visual.image_size = image_size\n return model\n\n\ndef resize_pos_embed(state_dict, model, interpolation: str = 'bicubic', antialias: bool = True):\n # Rescale the grid of position embeddings when loading from state_dict\n old_pos_embed = state_dict.get('visual.positional_embedding', None)\n if old_pos_embed is None or not hasattr(model.visual, 'grid_size'):\n return"},"next_line":{"kind":"string","value":" grid_size = to_2tuple(model.visual.grid_size)"},"gold_snippet_index":{"kind":"number","value":9,"string":"9"},"created_at":{"kind":"string","value":"2023-12-09 05:43:08+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5978,"cells":{"repo_name":{"kind":"string","value":"LkPrtctrd/BSL-V53"},"file_path":{"kind":"string","value":"Heart/Logic/LogicLaserMessageFactory.py"},"context":{"kind":"list like","value":[{"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):\n pass\n\n def decode(self):\n fields = {}\n fields[\"Protocol\"] = self.readInt()\n fields[\"KeyVersion\"] = self.readInt()\n fields[\"MajorVersion\"] = self.readInt()\n fields[\"MinorVersion\"] = self.readInt()\n fields[\"Build\"] = self.readInt()\n fields[\"ContentHash\"] = self.readString()\n fields[\"DeviceType\"] = self.readInt()\n fields[\"AppStore\"] = self.readInt()\n super().decode(fields)\n return fields\n\n def execute(message, calling_instance, fields, cryptoInit):\n fields[\"Socket\"] = calling_instance.client\n Messaging.sendMessage(20100, fields, cryptoInit)\n\n def getMessageType(self):\n return 10100\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"LoginMessage","path":"Heart/Packets/Client/Authentification/LoginMessage.py","snippet":"class LoginMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n pass\n\n def decode(self):\n fields = {}\n fields[\"AccountID\"] = self.readLong()\n fields[\"PassToken\"] = self.readString()\n fields[\"ClientMajor\"] = self.readInt()\n fields[\"ClientMinor\"] = self.readInt()\n fields[\"ClientBuild\"] = self.readInt()\n fields[\"ResourceSha\"] = self.readString()\n fields[\"Device\"] = self.readString()\n fields[\"PreferredLanguage\"] = self.readDataReference()\n fields[\"PreferredDeviceLanguage\"] = self.readString()\n fields[\"OSVersion\"] = self.readString()\n fields[\"isAndroid\"] = self.readBoolean()\n fields[\"IMEI\"] = self.readString()\n fields[\"AndroidID\"] = self.readString()\n fields[\"isAdvertisingEnabled\"] = self.readBoolean()\n fields[\"AppleIFV\"] = self.readString()\n fields[\"RndKey\"] = self.readInt()\n fields[\"AppStore\"] = self.readVInt()\n fields[\"ClientVersion\"] = self.readString()\n fields[\"TencentOpenId\"] = self.readString()\n fields[\"TencentToken\"] = self.readString()\n fields[\"TencentPlatform\"] = self.readVInt()\n fields[\"DeviceVerifierResponse\"] = self.readString()\n fields[\"AppLicensingSignature\"] = self.readString()\n fields[\"DeviceVerifierResponse\"] = self.readString()\n super().decode(fields)\n return fields\n\n def execute(message, calling_instance, fields, cryptoInit):\n if fields[\"ClientMajor\"]==53:\n calling_instance.player.ClientVersion = f'{str(fields[\"ClientMajor\"])}.{str(fields[\"ClientBuild\"])}.{str(fields[\"ClientMinor\"])}'\n fields[\"Socket\"] = calling_instance.client\n db_instance = DatabaseHandler()\n if db_instance.playerExist(fields[\"PassToken\"], fields[\"AccountID\"]):\n player_data = json.loads(db_instance.getPlayerEntry(fields[\"AccountID\"])[2])\n db_instance.loadAccount(calling_instance.player, fields[\"AccountID\"])\n else:\n db_instance.createAccount(calling_instance.player.getDataTemplate(fields[\"AccountID\"][0], fields[\"AccountID\"][1], fields[\"PassToken\"]))\n ClientsManager.AddPlayer(calling_instance.player.ID, calling_instance.client)\n Messaging.sendMessage(20104, fields, cryptoInit, calling_instance.player)\n Messaging.sendMessage(24101, fields, cryptoInit, calling_instance.player)\n Messaging.sendMessage(24399, fields, cryptoInit, calling_instance.player)\n\n def getMessageType(self):\n return 10101\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"AskForBattleEndMessage","path":"Heart/Packets/Client/Battle/AskForBattleEndMessage.py","snippet":"class AskForBattleEndMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n pass\n\n def decode(self):\n fields = {}\n fields[\"Unk1\"] = self.readVInt()\n fields[\"Result\"] = self.readVInt()\n fields[\"Rank\"] = self.readVInt()\n fields[\"MapID\"] = self.readDataReference()\n fields[\"HeroesCount\"] = self.readVInt()\n fields[\"Heroes\"] = []\n for i in range(fields[\"HeroesCount\"]): fields[\"Heroes\"].append({\"Brawler\": {\"ID\": self.readDataReference(), \"SkinID\": self.readDataReference()}, \"Team\": self.readVInt(), \"IsPlayer\": self.readBoolean(), \"PlayerName\": self.readString()})\n super().decode(fields)\n return fields\n\n def execute(message, calling_instance, fields, cryptoInit):\n fields[\"Socket\"] = calling_instance.client\n Messaging.sendMessage(23456, fields, cryptoInit, calling_instance.player)\n\n def getMessageType(self):\n return 14110\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"ChangeAvatarNameMessage","path":"Heart/Packets/Client/Home/ChangeAvatarNameMessage.py","snippet":"class ChangeAvatarNameMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n self.writeString(fields[\"Name\"])\n self.writeBoolean(fields[\"NameSetByUser\"])\n\n def decode(self):\n fields = {}\n fields[\"Name\"] = self.readString()\n fields[\"NameSetByUser\"] = self.readBoolean()\n super().decode(fields)\n return fields\n\n def execute(message, calling_instance, fields, cryptoInit):\n db_instance = DatabaseHandler()\n playerData = db_instance.getPlayer(calling_instance.player.ID)\n playerData[\"Name\"] = fields[\"Name\"]\n playerData[\"Registered\"] = True\n db_instance.updatePlayerData(playerData, calling_instance)\n fields[\"Socket\"] = calling_instance.client\n fields[\"Command\"] = {\"ID\": 201}\n Messaging.sendMessage(24111, fields, cryptoInit, calling_instance.player)\n\n def getMessageType(self):\n return 10212\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"EndClientTurnMessage","path":"Heart/Packets/Client/Home/EndClientTurnMessage.py","snippet":"class EndClientTurnMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n pass\n\n def decode(self):\n fields = {}\n self.readBoolean()\n fields[\"Tick\"] = self.readVInt()\n fields[\"Checksum\"] = self.readVInt()\n fields[\"CommandsCount\"] = self.readVInt()\n super().decode(fields)\n fields[\"Commands\"] = []\n for i in range(fields[\"CommandsCount\"]):\n fields[\"Commands\"].append({\"ID\": self.readVInt()})\n if LogicCommandManager.commandExist(fields[\"Commands\"][i][\"ID\"]):\n command = LogicCommandManager.createCommand(fields[\"Commands\"][i][\"ID\"])\n print(\"Command\", LogicCommandManager.getCommandsName(fields[\"Commands\"][i][\"ID\"]))\n if command is not None:\n fields[\"Commands\"][i][\"Fields\"] = command.decode(self)\n fields[\"Commands\"][i][\"Instance\"] = command\n return fields\n\n def execute(message, calling_instance, fields, cryptoInit):\n fields[\"Socket\"] = calling_instance.client\n for command in fields[\"Commands\"]:\n if \"Instance\" not in command.keys():\n return\n\n if hasattr(command[\"Instance\"], 'execute'):\n command[\"Instance\"].execute(calling_instance, command[\"Fields\"], cryptoInit)\n if command[\"ID\"] == 519:\n Messaging.sendMessage(24104, {\"Socket\": calling_instance.client, \"ServerChecksum\": 0, \"ClientChecksum\": 0, \"Tick\": 0}, cryptoInit)\n\n def getMessageType(self):\n return 14102\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"GoHomeFromOfflinePractiseMessage","path":"Heart/Packets/Client/Home/GoHomeFromOfflinePractiseMessage.py","snippet":"class GoHomeFromOfflinePractiseMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n pass\n\n def decode(self):\n fields = {}\n self.readBoolean()\n return fields\n\n def execute(message, calling_instance, fields, cryptoInit):\n fields[\"Socket\"] = calling_instance.client\n Messaging.sendMessage(24101, fields, cryptoInit, calling_instance.player)\n\n def getMessageType(self):\n return 14109\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"GoHomeMessage","path":"Heart/Packets/Client/Home/GoHomeMessage.py","snippet":"class GoHomeMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n pass\n\n def decode(self):\n fields = {}\n self.readBoolean()\n return fields\n\n def execute(message, calling_instance, fields, cryptoInit):\n fields[\"Socket\"] = calling_instance.client\n Messaging.sendMessage(24101, fields, cryptoInit, calling_instance.player)\n\n def getMessageType(self):\n return 17750\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"GetPlayerProfileMessage","path":"Heart/Packets/Client/Home/GetPlayerProfileMessage.py","snippet":"class GetPlayerProfileMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n pass\n\n def decode(self):\n fields = {}\n fields[\"BattleInfoBoolean\"] = self.readBoolean()\n if fields[\"BattleInfoBoolean\"]:\n fields[\"unk1\"] = self.readVInt()\n fields[\"AnotherID\"] = self.readLong()\n fields[\"unk2\"] = self.readVInt()\n for i in self.readVInt():\n fields[\"CsvID\"] = self.readDataReference()\n fields[\"unk3\"] = self.readVInt()\n fields[\"unk4\"] = self.readVInt()\n fields[\"unk5\"] = self.readVInt()\n fields[\"unk6\"] = self.readVInt()\n fields[\"PlayerName\"] = self.readString()\n fields[\"unk7\"] = self.readVInt()\n fields[\"Thumbnail\"] = self.readVInt()\n fields[\"NameColor\"] = self.readVInt()\n fields[\"unk10\"] = self.readVInt()\n fields[\"unk11\"] = self.readVInt()\n fields[\"PlayerHighID\"] = self.readInt()\n fields[\"PlayerLowID\"] = self.readInt()\n super().decode(fields)\n\n\n return fields\n\n def execute(message, calling_instance, fields, cryptoInit):\n fields[\"Socket\"] = calling_instance.client\n Messaging.sendMessage(24113, fields, cryptoInit, calling_instance.player)\n\n def getMessageType(self):\n return 15081\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"AskForAllianceDataMessage","path":"Heart/Packets/Client/Home/AskForAllianceDataMessage.py","snippet":"class AskForAllianceDataMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n pass\n\n def decode(self):\n fields = {}\n fields[\"id\"] = self.readVLong()\n fields[\"isInAlliance\"] = self.readBoolean()\n if fields[\"isInAlliance\"] == True:\n fields[\"anotherIDHigh\"] = self.readVInt()\n fields[\"anotherIDLow\"] = self.readVInt()\n super().decode(fields)\n\n return fields\n\n def execute(message, calling_instance, fields, cryptoInit):\n fields[\"Socket\"] = calling_instance.client\n Messaging.sendMessage(24301, fields, cryptoInit, calling_instance.player)\n\n def getMessageType(self):\n return 14302\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"KeepAliveMessage","path":"Heart/Packets/Client/Socket/KeepAliveMessage.py","snippet":"class KeepAliveMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n pass\n\n def decode(self):\n return {}\n\n def execute(message, calling_instance, fields, cryptoInit):\n fields[\"Socket\"] = calling_instance.client\n Messaging.sendMessage(20108, fields, cryptoInit)\n\n def getMessageType(self):\n return 10108\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"LoginFailedMessage","path":"Heart/Packets/Server/Authentification/LoginFailedMessage.py","snippet":"class LoginFailedMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n self.writeInt(fields['ErrorID'])\n self.writeString(fields['FingerprintData'])\n self.writeString()\n self.writeString(fields['ContentURL'])\n self.writeString()\n self.writeString(fields['Message'])\n self.writeInt(0)\n self.writeBoolean(False)\n self.writeInt(0)\n self.writeInt(0)\n self.writeInt(0)\n self.writeInt(0)\n self.writeString()\n self.writeInt(0)\n self.writeBoolean(True)\n self.writeBoolean(True)\n self.writeString()\n self.writeVInt(0)\n self.writeString()\n self.writeBoolean(False)\n\n def decode(self):\n fields = {}\n fields[\"ErrorCode\"] = self.readInt()\n fields[\"ResourceFingerprintData\"] = self.readString()\n fields[\"RedirectDomain\"] = self.readString()\n fields[\"ContentURL\"] = self.readString()\n fields[\"UpdateURL\"] = self.readString()\n fields[\"Reason\"] = self.readString()\n fields[\"SecondsUntilMaintenanceEnd\"] = self.readInt()\n fields[\"ShowContactSupportForBan\"] = self.readBoolean()\n fields[\"CompressedFingerprintData\"] = self.readBytesWithoutLength()\n fields[\"ContentURLListCount\"] = self.readInt()\n fields[\"ContentURLList\"] = []\n for i in range(fields[\"ContentURLListCount\"]):\n fields[\"ContentURLList\"].append(self.readString())\n fields[\"KunlunAppStore\"] = self.readInt()\n fields[\"MaintenanceType\"] = self.readInt()\n fields[\"HelpshiftFaqId\"] = self.readString()\n fields[\"Tier\"] = self.readInt()\n fields[\"Unk1\"] = self.readBoolean()\n fields[\"Unk2\"] = self.readBoolean()\n fields[\"Unk3\"] = self.readString()\n fields[\"Unk4\"] = self.readVInt()\n fields[\"Unk5\"] = self.readString()\n fields[\"OptionalTargetedAccountIdState\"] = self.readBoolean()\n if fields[\"OptionalTargetedAccountIdState\"] == True:\n fields[\"OptionalTargetedAccountId\"] = self.readLong()\n super().decode(fields)\n return fields\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 20103\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"LoginOkMessage","path":"Heart/Packets/Server/Authentification/LoginOkMessage.py","snippet":"class LoginOkMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 1\n\n def encode(self, fields, player):\n self.writeLong(player.ID[0], player.ID[1])\n self.writeLong(player.ID[0], player.ID[1])\n self.writeString(player.Token)\n self.writeString()\n self.writeString()\n self.writeInt(53)\n self.writeInt(176)\n self.writeInt(1)\n self.writeString(\"dev\")\n self.writeInt(0)\n self.writeInt(0)\n self.writeInt(0)\n self.writeString()\n self.writeString()\n self.writeString()\n self.writeInt(0)\n self.writeString()\n self.writeString(\"RU\")\n self.writeString()\n self.writeInt(0)\n self.writeString()\n self.writeInt(2)\n self.writeString('https://game-assets.brawlstarsgame.com')\n self.writeString('http://a678dbc1c015a893c9fd-4e8cc3b1ad3a3c940c504815caefa967.r87.cf2.rackcdn.com')\n self.writeInt(2)\n self.writeString('https://event-assets.brawlstars.com')\n self.writeString('https://24b999e6da07674e22b0-8209975788a0f2469e68e84405ae4fcf.ssl.cf2.rackcdn.com/event-assets')\n self.writeVInt(0)\n self.writeCompressedString(b'')\n self.writeBoolean(True)\n self.writeBoolean(False)\n self.writeString()\n self.writeString()\n self.writeString()\n self.writeString('https://play.google.com/store/apps/details?id=com.supercell.brawlstars')\n self.writeString()\n self.writeBoolean(False)\n\n self.writeBoolean(False)\n if False:\n self.writeString()\n\n self.writeBoolean(False)\n if False:\n self.writeString()\n\n self.writeBoolean(False)\n if False:\n self.writeString()\n\n self.writeBoolean(False)\n if False:\n self.writeString()\n\n\n def decode(self):\n fields = {}\n fields[\"AccountID\"] = self.readLong()\n fields[\"HomeID\"] = self.readLong()\n fields[\"PassToken\"] = self.readString()\n fields[\"FacebookID\"] = self.readString()\n fields[\"GamecenterID\"] = self.readString()\n fields[\"ServerMajorVersion\"] = self.readInt()\n fields[\"ContentVersion\"] = self.readInt()\n fields[\"ServerBuild\"] = self.readInt()\n fields[\"ServerEnvironment\"] = self.readString()\n fields[\"SessionCount\"] = self.readInt()\n fields[\"PlayTimeSeconds\"] = self.readInt()\n fields[\"DaysSinceStartedPlaying\"] = self.readInt()\n fields[\"FacebookAppID\"] = self.readString()\n fields[\"ServerTime\"] = self.readString()\n fields[\"AccountCreatedDate\"] = self.readString()\n fields[\"StartupCooldownSeconds\"] = self.readInt()\n fields[\"GoogleServiceID\"] = self.readString()\n fields[\"LoginCountry\"] = self.readString()\n fields[\"KunlunID\"] = self.readString()\n fields[\"Tier\"] = self.readInt()\n fields[\"TencentID\"] = self.readString()\n\n ContentUrlCount = self.readInt()\n fields[\"GameAssetsUrls\"] = []\n for i in range(ContentUrlCount):\n fields[\"GameAssetsUrls\"].append(self.readString())\n\n EventUrlCount = self.readInt()\n fields[\"EventAssetsUrls\"] = []\n for i in range(EventUrlCount):\n fields[\"EventAssetsUrls\"].append(self.readString())\n\n fields[\"SecondsUntilAccountDeletion\"] = self.readVInt()\n fields[\"SupercellIDToken\"] = self.readCompressedString()\n fields[\"IsSupercellIDLogoutAllDevicesAllowed\"] = self.readBoolean()\n fields[\"isSupercellIDEligible\"] = self.readBoolean()\n fields[\"LineID\"] = self.readString()\n fields[\"SessionID\"] = self.readString()\n fields[\"KakaoID\"] = self.readString()\n fields[\"UpdateURL\"] = self.readString()\n fields[\"YoozooPayNotifyUrl\"] = self.readString()\n fields[\"UnbotifyEnabled\"] = self.readBoolean()\n\n Unknown1 = self.readBoolean()\n fields[\"Unknown1\"] = Unknown1\n if Unknown1:\n fields[\"Unknown2\"] = self.readString()\n\n Unknown3 = self.readBoolean()\n fields[\"Unknown3\"] = Unknown1\n if Unknown3:\n fields[\"Unknown4\"] = self.readString()\n\n Unknown5 = self.readBoolean()\n fields[\"Unknown5\"] = Unknown1\n if Unknown5:\n fields[\"Unknown6\"] = self.readString()\n\n Unknown7 = self.readBoolean()\n fields[\"Unknown7\"] = Unknown1\n if Unknown7:\n fields[\"Unknown8\"] = self.readString()\n super().decode(fields)\n return fields\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 20104\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"OutOfSyncMessage","path":"Heart/Packets/Server/Authentification/OutOfSyncMessage.py","snippet":"class OutOfSyncMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n self.writeVInt(fields[\"ServerChecksum\"])\n self.writeVInt(fields[\"ClientChecksum\"])\n self.writeVInt(fields[\"Tick\"])\n\n def decode(self):\n fields = {}\n fields[\"ServerChecksum\"] = self.readVInt()\n fields[\"ClientChecksum\"] = self.readVInt()\n fields[\"Tick\"] = self.readVInt()\n super().decode(fields)\n return fields\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 24104\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"ServerHelloMessage","path":"Heart/Packets/Server/Authentification/ServerHelloMessage.py","snippet":"class ServerHelloMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n self.writeBytes(urandom(24), 24)\n\n def decode(self):\n fields = {}\n fields[\"Random\"] = self.readBytesWithoutLength()\n super().decode(fields)\n return fields\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 20100\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"BattleEndMessage","path":"Heart/Packets/Server/Battle/BattleEndMessage.py","snippet":"class BattleEndMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields, player):\n self.writeLong(0, 0) # Battle UUID High\n self.writeLong(0, 0) # Battle UUID Low\n self.writeVInt(2) # Battle End Game Mode (gametype)\n self.writeVInt(fields[\"Rank\"]) # Result (Victory/Defeat/Draw/Rank Score)\n self.writeVInt(0) # Tokens Gained (Gained Keys)\n self.writeVInt(0) # Trophies Result (Metascore change)\n self.writeVInt(0) # Power Play Points Gained (Pro League Points)\n self.writeVInt(0) # Doubled Tokens (Double Keys)\n self.writeVInt(0) # Double Token Event (Double Event Keys)\n self.writeVInt(0) # Token Doubler Remaining (Double Keys Remaining)\n self.writeVInt(0) # game Lenght In Seconds\n self.writeVInt(0) # Epic Win Power Play Points Gained (op Win Points)\n self.writeVInt(0) # Championship Level Reached (CC Wins)\n self.writeBoolean(False)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeBoolean(True)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeVInt(-1)\n self.writeBoolean(False)\n\n self.writeVInt(fields[\"HeroesCount\"])\n for heroEntry in fields[\"Heroes\"]:\n self.writeBoolean(heroEntry[\"IsPlayer\"])\n self.writeBoolean(bool(heroEntry[\"Team\"]))\n self.writeBoolean(bool(heroEntry[\"Team\"]))\n self.writeByte(1)\n for i in range(1):\n self.writeDataReference(heroEntry[\"Brawler\"][\"ID\"][0], heroEntry[\"Brawler\"][\"ID\"][1])\n self.writeByte(1)\n for i in range(1):\n if (heroEntry[\"Brawler\"][\"SkinID\"] is None):\n self.writeVInt(0)\n else:\n self.writeDataReference(heroEntry[\"Brawler\"][\"SkinID\"][0], heroEntry[\"Brawler\"][\"SkinID\"][1])\n self.writeByte(1)\n for i in range(1):\n self.writeVInt(1250)\n self.writeByte(1)\n for i in range(1):\n self.writeVInt(11)\n self.writeByte(1)\n for i in range(1):\n self.writeVInt(0)\n\n self.writeVInt(0)\n self.writeVInt(0)\n\n self.writeBoolean(heroEntry[\"IsPlayer\"])\n if heroEntry[\"IsPlayer\"]:\n self.writeLong(player.ID[0], player.ID[1])\n self.writeString(heroEntry[\"PlayerName\"])\n self.writeVInt(100)\n self.writeVInt(28000000)\n self.writeVInt(43000000)\n self.writeVInt(-2)\n if heroEntry[\"IsPlayer\"]:\n self.writeBoolean(True)\n self.writeVLong(5, 4181497)\n self.writeString('haccer club')\n self.writeDataReference(8, 16)\n else:\n self.writeBoolean(False)\n\n self.writeInt8(1)\n self.writeVInt(5978)\n self.writeInt8(1)\n self.writeVInt(0)\n\n self.writeInt16(5)\n self.writeInt16(3)\n self.writeInt(27328)\n self.writeInt(25659)\n\n self.writeDataReference(0)\n\n self.writeVInt(0)\n self.writeVInt(1)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False) # 0x0\n self.writeBoolean(False) # 0x0\n self.writeBoolean(False) # 0x0\n self.writeBoolean(False) # 0x0\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False) # 0x0\n self.writeVInt(0)\n self.writeBoolean(False) # 0x0\n self.writeVInt(0)\n self.writeBoolean(False) # 0x0\n self.writeBoolean(False) # 0x0\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False) # 0x0\n self.writeBoolean(False) # 0x0\n self.writeBoolean(False) # 0x0\n\n def decode(self):\n fields = {}\n return {}\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 23456\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"AvailableServerCommandMessage","path":"Heart/Packets/Server/Home/AvailableServerCommandMessage.py","snippet":"class AvailableServerCommandMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields, player):\n self.writeVInt(fields[\"Command\"][\"ID\"])\n command = LogicCommandManager.createCommand(fields[\"Command\"][\"ID\"], self.messagePayload)\n self.messagePayload = command.encode(fields)\n\n def decode(self):\n return {}\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 24111\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"LobbyInfoMessage","path":"Heart/Packets/Server/Home/LobbyInfoMessage.py","snippet":"class LobbyInfoMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields, player):\n self.writeVInt(ClientsManager.GetCount())\n self.writeString(f\"\"\"Version: {player.ClientVersion}\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\"\"\")\n self.writeVInt(0) # count event\n self.writeVInt(0) # new timer in v51\n\n def decode(self):\n fields = {}\n fields[\"PlayerCount\"] = self.readVInt()\n fields[\"Text\"] = self.readString()\n fields[\"Unk1\"] = self.readVInt()\n super().decode(fields)\n return {}\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 23457\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"OwnHomeDataMessage","path":"Heart/Packets/Server/Home/OwnHomeDataMessage.py","snippet":"class OwnHomeDataMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields, player):\n self.writeVInt(1688816070)\n self.writeVInt(1191532375)\n self.writeVInt(2023189)\n self.writeVInt(73530)\n\n self.writeVInt(player.Trophies)\n self.writeVInt(player.HighestTrophies)\n self.writeVInt(player.HighestTrophies) \n self.writeVInt(player.TrophyRoadTier)\n self.writeVInt(player.Experience)\n self.writeDataReference(28, player.Thumbnail)\n self.writeDataReference(43, player.Namecolor)\n\n self.writeVInt(26)\n for x in range(26):\n self.writeVInt(x)\n\n self.writeVInt(0)\n\n self.writeVInt(0)\n\n self.writeVInt(0)\n \n self.writeVInt(len(player.OwnedSkins))\n for x in player.OwnedSkins:\n self.writeDataReference(29, x)\n\n self.writeVInt(0)\n\n self.writeVInt(0)\n\n self.writeVInt(0)\n self.writeVInt(player.HighestTrophies)\n self.writeVInt(0)\n self.writeVInt(2)\n self.writeBoolean(True)\n self.writeVInt(0)\n self.writeVInt(115)\n self.writeVInt(335442)\n self.writeVInt(1001442)\n self.writeVInt(5778642) \n\n self.writeVInt(120)\n self.writeVInt(200)\n self.writeVInt(0)\n\n self.writeBoolean(True)\n self.writeVInt(2)\n self.writeVInt(2)\n self.writeVInt(2)\n self.writeVInt(0)\n self.writeVInt(0)\n\n self.writeVInt(1) # Shop Offers\n\n self.writeVInt(1) # RewardCount\n\n self.writeVInt(38) # ItemType\n self.writeVInt(1337) # Amount\n self.writeDataReference(0) # CsvID\n self.writeVInt(0) # SkinID\n\n self.writeVInt(0) # Currency(0-Gems, 1-Gold, 3-StarpoInts)\n self.writeVInt(0) # Cost\n self.writeVInt(0) # Time\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False) # Daily Offer\n self.writeVInt(0) # Old price\n self.writeString('Offer') # Text\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeString(\"offer_bgr_xmas23\") # Background\n self.writeVInt(0)\n self.writeBoolean(False) # This purchase is already being processed\n self.writeVInt(0) # Type Benefit\n self.writeVInt(0) # Benefit\n self.writeString()\n self.writeBoolean(False) # One time offer\n self.writeBoolean(False) # Claimed\n self.writeDataReference(0)\n self.writeDataReference(0)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n \n self.writeVInt(20)\n self.writeVInt(1428)\n\n self.writeVInt(0)\n\n self.writeVInt(1)\n self.writeVInt(30)\n\n self.writeByte(1) # count brawlers selected\n self.writeDataReference(16, player.SelectedBrawlers[0]) # selected brawler\n self.writeString(player.Region) # location\n self.writeString(player.ContentCreator) # supported creator\n\n self.writeVInt(6) \n self.writeVInt(1) \n self.writeVInt(9) \n self.writeVInt(1) \n self.writeVInt(22) \n self.writeVInt(3) \n self.writeVInt(25) \n self.writeVInt(1) \n self.writeVInt(24) \n self.writeVInt(0)\n self.writeVInt(15)\n self.writeVInt(32447)\n self.writeVInt(28)\n\n\n self.writeVInt(0)\n\n self.writeVInt(1)\n for season in range(1):\n self.writeVInt(22-1)\n self.writeVInt(40000)\n self.writeBoolean(True)\n self.writeVInt(0)\n self.writeBoolean(False)\n self.writeBoolean(True)\n self.writeInt(0)\n self.writeInt(0)\n self.writeInt(0)\n self.writeInt(0)\n self.writeBoolean(True)\n self.writeInt(0)\n self.writeInt(0)\n self.writeInt(0)\n self.writeInt(0)\n self.writeBoolean(True)\n self.writeBoolean(True)\n self.writeInt(0)\n self.writeInt(0)\n self.writeInt(0)\n self.writeInt(0)\n\n self.writeVInt(0)\n\n self.writeBoolean(True)\n self.writeVInt(0)\n self.writeVInt(1)\n self.writeVInt(2)\n self.writeVInt(0) \n\n self.writeBoolean(True) # Vanity items\n self.writeVInt(len(player.OwnedThumbnails)+len(player.OwnedPins))\n for x in player.OwnedThumbnails:\n self.writeVInt(28)\n self.writeVInt(x)\n self.writeVInt(0)\n for x in player.OwnedPins:\n self.writeVInt(52)\n self.writeVInt(x)\n self.writeVInt(0)\n\n\n self.writeBoolean(False) # Power league season data\n\n self.writeInt(0)\n self.writeVInt(0)\n self.writeVInt(16)\n self.writeVInt(76)\n self.writeBoolean(False)\n self.writeVInt(0)\n self.writeVInt(0)\n\n self.writeVInt(2023189)\n\n self.writeVInt(35) # event slot id\n self.writeVInt(1)\n self.writeVInt(2)\n self.writeVInt(3)\n self.writeVInt(4)\n self.writeVInt(5)\n self.writeVInt(6)\n self.writeVInt(7)\n self.writeVInt(8)\n self.writeVInt(9)\n self.writeVInt(10)\n self.writeVInt(11)\n self.writeVInt(12)\n self.writeVInt(13) \n self.writeVInt(14)\n self.writeVInt(15)\n self.writeVInt(16)\n self.writeVInt(17)\n self.writeVInt(18) \n self.writeVInt(19)\n self.writeVInt(20)\n self.writeVInt(21) \n self.writeVInt(22)\n self.writeVInt(23)\n self.writeVInt(24)\n self.writeVInt(25)\n self.writeVInt(26)\n self.writeVInt(27)\n self.writeVInt(28)\n self.writeVInt(29)\n self.writeVInt(30)\n self.writeVInt(31)\n self.writeVInt(32)\n self.writeVInt(33)\n self.writeVInt(34)\n self.writeVInt(35)\n\n self.writeVInt(1)\n\n self.writeVInt(4)\n self.writeVInt(7)\n self.writeVInt(1)\n self.writeVInt(0)\n self.writeVInt(72292)\n self.writeVInt(10) \n self.writeDataReference(15, 21) # map id\n self.writeVInt(-1)\n self.writeVInt(2)\n self.writeString(\"\")\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False) # MapMaker map structure array\n self.writeVInt(0)\n self.writeBoolean(False) # Power League array entry\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeVInt(-1)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeVInt(-1)\n self.writeVInt(0) \n self.writeVInt(0) \n self.writeVInt(0) \n self.writeBoolean(False) \n\n self.writeVInt(0)\n \n ByteStreamHelper.encodeIntList(self, [20, 35, 75, 140, 290, 480, 800, 1250, 1875, 2800])\n ByteStreamHelper.encodeIntList(self, [30, 80, 170, 360]) # Shop Coins Price\n ByteStreamHelper.encodeIntList(self, [300, 880, 2040, 4680]) # Shop Coins Amount\n\n self.writeVInt(0) \n\n self.writeVInt(1)\n self.writeVInt(41000086) # theme\n self.writeVInt(1)\n\n self.writeVInt(0) \n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n\n self.writeVInt(2)\n self.writeVInt(1)\n self.writeVInt(2)\n self.writeVInt(2)\n self.writeVInt(1)\n self.writeVInt(-1)\n self.writeVInt(2)\n self.writeVInt(1)\n self.writeVInt(4)\n\n ByteStreamHelper.encodeIntList(self, [0, 29, 79, 169, 349, 699])\n ByteStreamHelper.encodeIntList(self, [0, 160, 450, 500, 1250, 2500])\n\n self.writeLong(0, 1) # Player ID\n\n self.writeVInt(0) # Notification factory\n \n self.writeVInt(1)\n self.writeBoolean(False)\n self.writeVInt(0)\n self.writeVInt(0) \n self.writeVInt(0)\n self.writeBoolean(False) # Login Calendar\n self.writeVInt(0)\n self.writeBoolean(True) # Starr Road\n for i in range(7):\n self.writeVInt(0)\n\n self.writeVInt(0) # Mastery\n\n #BattleCard\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeBoolean(False)\n self.writeBoolean(False)\n\n self.writeVInt(0) #Brawler's BattleCards\n\n self.writeVInt(5)\n for i in range(5):\n self.writeDataReference(80, i)\n self.writeVInt(-1)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeInt(0)\n self.writeVInt(0) \n self.writeVInt(0)\n self.writeVInt(86400*24)\n self.writeVInt(0)\n self.writeVInt(0)\n\n self.writeBoolean(False)\n\n # end LogicClientHome\n\n self.writeVLong(player.ID[0], player.ID[1])\n self.writeVLong(player.ID[0], player.ID[1])\n self.writeVLong(player.ID[0], player.ID[1])\n self.writeStringReference(player.Name)\n self.writeBoolean(player.Registered)\n self.writeInt(-1)\n\n self.writeVInt(17)\n unlocked_brawler = [i['CardID'] for x,i in player.OwnedBrawlers.items()]\n self.writeVInt(len(unlocked_brawler) + 2)\n for x in unlocked_brawler:\n self.writeDataReference(23, x)\n self.writeVInt(-1)\n self.writeVInt(1)\n\n self.writeDataReference(5, 8)\n self.writeVInt(-1)\n self.writeVInt(player.Coins)\n\n self.writeDataReference(5, 23)\n self.writeVInt(-1)\n self.writeVInt(player.Blings)\n\n self.writeVInt(len(player.OwnedBrawlers)) # HeroScore\n for x,i in player.OwnedBrawlers.items():\n self.writeDataReference(16, x)\n self.writeVInt(-1)\n self.writeVInt(i[\"Trophies\"])\n\n self.writeVInt(len(player.OwnedBrawlers)) # HeroHighScore\n for x,i in player.OwnedBrawlers.items():\n self.writeDataReference(16, x)\n self.writeVInt(-1)\n self.writeVInt(i[\"HighestTrophies\"])\n\n self.writeVInt(0) # Array\n\n self.writeVInt(0) # HeroPower\n \n self.writeVInt(len(player.OwnedBrawlers)) # HeroLevel\n for x,i in player.OwnedBrawlers.items():\n self.writeDataReference(16, x)\n self.writeVInt(-1)\n self.writeVInt(i[\"PowerLevel\"]-1)\n\n self.writeVInt(0) # hero star power gadget and hypercharge\n\n self.writeVInt(len(player.OwnedBrawlers)) # HeroSeenState\n for x,i in player.OwnedBrawlers.items():\n self.writeDataReference(16, x)\n self.writeVInt(-1)\n self.writeVInt(2)\n\n self.writeVInt(0) # Array\n self.writeVInt(0) # Array\n self.writeVInt(0) # Array\n self.writeVInt(0) # Array\n self.writeVInt(0) # Array\n self.writeVInt(0) # Array\n self.writeVInt(0) # Array\n self.writeVInt(0) # Array\n self.writeVInt(0) # Array\n\n self.writeVInt(player.Gems) # Diamonds\n self.writeVInt(player.Gems) # Free Diamonds\n self.writeVInt(10) # Player Level\n self.writeVInt(100)\n self.writeVInt(0) # CumulativePurchasedDiamonds or Avatar User Level Tier | 10000 < Level Tier = 3 | 1000 < Level Tier = 2 | 0 < Level Tier = 1\n self.writeVInt(100) # Battle Count\n self.writeVInt(10) # WinCount\n self.writeVInt(80) # LoseCount\n self.writeVInt(50) # WinLooseStreak\n self.writeVInt(20) # NpcWinCount\n self.writeVInt(0) # NpcLoseCount\n self.writeVInt(2) # TutorialState | shouldGoToFirstTutorialBattle = State == 0\n self.writeVInt(12)\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeString()\n self.writeVInt(0)\n self.writeVInt(0)\n self.writeVInt(1)\n\n def decode(self):\n fields = {}\n return fields\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 24101\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"KeepAliveServerMessage","path":"Heart/Packets/Server/Socket/KeepAliveServerMessage.py","snippet":"class KeepAliveServerMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields):\n pass\n\n def decode(self):\n return {}\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 20108\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"PlayerProfileMessage","path":"Heart/Packets/Server/Home/PlayerProfileMessage.py","snippet":"class PlayerProfileMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields, player):\n self.writeVLong(fields[\"PlayerHighID\"], fields[\"PlayerLowID\"])\n self.writeDataReference(16,11) # \n self.writeVInt(70)\n for i in range(70):\n self.writeDataReference(16, i)\n self.writeDataReference(0)\n self.writeVInt(500) # trophies\n self.writeVInt(1250) # highestTrophies\n self.writeVInt(11) #power level\n \n self.writeVInt(18)\n\n self.writeVInt(1) \n self.writeVInt(1) # 3v3 victories\n\n self.writeVInt(2)\n self.writeVInt(528859) # total exp\n\n self.writeVInt(3)\n self.writeVInt(3) # current trophies\n\n self.writeVInt(4)\n self.writeVInt(4) # highest trophies\n\n self.writeVInt(5) \n self.writeVInt(5) # unlocked brawler?\n\n self.writeVInt(8)\n self.writeVInt(6) # solo victories\n\n self.writeVInt(11) \n self.writeVInt(7) # duo victories\n\n self.writeVInt(9) \n self.writeVInt(8) # highest level robo rumble\n\n self.writeVInt(12) \n self.writeVInt(9) # highest level boss fight\n\n self.writeVInt(13)\n self.writeVInt(10) # highest power league points\n\n self.writeVInt(14)\n self.writeVInt(11) # some power league stuff\n\n self.writeVInt(15)\n self.writeVInt(12) # most challenge win\n\n self.writeVInt(16) #highest level city rampage\n self.writeVInt(13)\n\n self.writeVInt(18) #highest solo power league rank\n self.writeVInt(14)\n\n self.writeVInt(17) #highest team power league rank\n self.writeVInt(15)\n\n self.writeVInt(19) # highest Club league rank\n self.writeVInt(16)\n\n self.writeVInt(20) # number fame\n self.writeVInt(1000)\n\n self.writeVInt(21)\n self.writeVInt(502052) #v50\n\n self.writeString(player.Name) #PlayerInfo\n self.writeVInt(100)\n self.writeVInt(28000000 + player.Thumbnail)\n self.writeVInt(43000000 + player.Namecolor)\n self.writeVInt(14)\n\n self.writeBoolean(True)\n self.writeVInt(300)\n\n self.writeString(\"hello world\")\n self.writeVInt(100)\n self.writeVInt(200)\n self.writeDataReference(29, 558)\n self.writeDataReference(0)\n self.writeDataReference(0)\n self.writeDataReference(0)\n self.writeDataReference(0)\n\n self.writeBoolean(True) #alliance\n self.writeLong(0,1) #alliance ID\n self.writeString(\"haccers\") #alliance name\n self.writeDataReference(8,1) # alliance icon\n self.writeVInt(1) # type\n self.writeVInt(1) # member count\n self.writeVInt(10000) # total trophies\n self.writeVInt(1) # minimum trophies to enter\n self.writeDataReference(0)\n self.writeString(\"RU\") #location\n self.writeVInt(4) # unknown\n self.writeBoolean(True) #is Family friendly\n self.writeVInt(0)\n \n\n self.writeDataReference(25, 1) #alliance role\n self.writeVInt(16)\n\n def decode(self):\n pass\n # fields = {}\n # fields[\"PlayerCount\"] = self.readVInt()\n # fields[\"Text\"] = self.readString()\n # fields[\"Unk1\"] = self.readVInt()\n # super().decode(fields)\n return {}\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 24113\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"MyAllianceMessage","path":"Heart/Packets/Server/Home/MyAllianceMessage.py","snippet":"class MyAllianceMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields, player):\n self.writeVInt(1) # Online people in alliance\n self.writeBoolean(True) # isInAlliance\n self.writeDataReference(25, 4)\n self.writeLong(0, 1) # alliance ID\n self.writeString(player.ContentCreator) # alliance name\n self.writeDataReference(8, 37) # alliance icon\n self.writeVInt(3) # type\n self.writeVInt(1) # member count\n self.writeVInt(9500) # total trophies\n self.writeVInt(1) # minimum trophies to enter\n self.writeVInt(0) # 0\n self.writeString('RU') # location\n self.writeVInt(3) # unknown\n self.writeBoolean(True) # isFamilyFriendly\n self.writeVInt(0)\n\n def decode(self):\n fields = {}\n super().decode(fields)\n return {}\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 24399\n\n def getMessageVersion(self):\n return self.messageVersion"},{"identifier":"AllianceDataMessage","path":"Heart/Packets/Server/Home/AllianceDataMessage.py","snippet":"class AllianceDataMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields, player):\n self.writeBoolean(True)\n\n self.writeLong(0, 1) # alliance ID\n self.writeString(player.ContentCreator) # alliance name\n self.writeDataReference(8, 37) # alliance icon\n self.writeVInt(1) # type\n self.writeVInt(1) # member count\n self.writeVInt(player.Trophies) # total trophies\n self.writeVInt(0) # minimum trophies to enter\n self.writeVInt(0) # 0\n self.writeString('RU') # location\n self.writeVInt(1) # people online\n self.writeBoolean(True) # isFamilyFriendly\n self.writeVInt(0)\n\n self.writeString(\"this is the hacciest club in the world\")\n\n self.writeVInt(1) # member count\n self.writeLong(player.ID[0], player.ID[1]) # player ID\n self.writeVInt(2) # role\n self.writeVInt(player.Trophies) # trophies\n self.writeVInt(0) # status: 0=offline 2=online\n self.writeVInt(1) # last connected time seconds ?\n highestPowerLeagueRank = 2\n self.writeVInt(highestPowerLeagueRank)\n if highestPowerLeagueRank != 0:\n self.writeVInt(2) #solo\n self.writeVInt(1) #duo\n self.writeBoolean(False) # boolean always false?\n\n self.writeString(player.Name) # player name\n self.writeVInt(100) # VInt always 100\n self.writeVInt(28000000 + player.Thumbnail) # thumbnail\n self.writeVInt(43000000 + player.Namecolor) # name color\n self.writeVInt(46000000 + player.Namecolor)\n\n self.writeVInt(-1) # most people have it -1 but some with something\n self.writeBoolean(False) # whats this ? only 2/30 people have it true in my club\n week = 58 # week 58 of club league as of 2023/07/05, this number is 0 if you just arrived in the club\n self.writeVInt(week)\n if week != 0: # club league week number?\n self.writeVInt(3) # day\n self.writeVInt(18) # total club trophies earned\n self.writeVInt(0) # event day club trophies earned\n self.writeVInt(8) # total tickets used\n self.writeVInt(0) # event day tickets used\n self.writeVInt(6) # event day max tickets\n self.writeVInt(6) # event day tickets left\n self.writeVInt(0) # event day player ranking\n self.writeBoolean(True) # everyone have it to true\n self.writeVInt(200) # player experience lvl but why tf it doesn't show for some people\n\n def decode(self):\n fields = {}\n super().decode(fields)\n return {}\n\n def execute(message, calling_instance, fields):\n pass\n\n def getMessageType(self):\n return 24301\n\n def getMessageVersion(self):\n return self.messageVersion"}],"string":"[\n {\n \"identifier\": \"ClientHelloMessage\",\n \"path\": \"Heart/Packets/Client/Authentification/ClientHelloMessage.py\",\n \"snippet\": \"class ClientHelloMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"Protocol\\\"] = self.readInt()\\n fields[\\\"KeyVersion\\\"] = self.readInt()\\n fields[\\\"MajorVersion\\\"] = self.readInt()\\n fields[\\\"MinorVersion\\\"] = self.readInt()\\n fields[\\\"Build\\\"] = self.readInt()\\n fields[\\\"ContentHash\\\"] = self.readString()\\n fields[\\\"DeviceType\\\"] = self.readInt()\\n fields[\\\"AppStore\\\"] = self.readInt()\\n super().decode(fields)\\n return fields\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n fields[\\\"Socket\\\"] = calling_instance.client\\n Messaging.sendMessage(20100, fields, cryptoInit)\\n\\n def getMessageType(self):\\n return 10100\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"LoginMessage\",\n \"path\": \"Heart/Packets/Client/Authentification/LoginMessage.py\",\n \"snippet\": \"class LoginMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"AccountID\\\"] = self.readLong()\\n fields[\\\"PassToken\\\"] = self.readString()\\n fields[\\\"ClientMajor\\\"] = self.readInt()\\n fields[\\\"ClientMinor\\\"] = self.readInt()\\n fields[\\\"ClientBuild\\\"] = self.readInt()\\n fields[\\\"ResourceSha\\\"] = self.readString()\\n fields[\\\"Device\\\"] = self.readString()\\n fields[\\\"PreferredLanguage\\\"] = self.readDataReference()\\n fields[\\\"PreferredDeviceLanguage\\\"] = self.readString()\\n fields[\\\"OSVersion\\\"] = self.readString()\\n fields[\\\"isAndroid\\\"] = self.readBoolean()\\n fields[\\\"IMEI\\\"] = self.readString()\\n fields[\\\"AndroidID\\\"] = self.readString()\\n fields[\\\"isAdvertisingEnabled\\\"] = self.readBoolean()\\n fields[\\\"AppleIFV\\\"] = self.readString()\\n fields[\\\"RndKey\\\"] = self.readInt()\\n fields[\\\"AppStore\\\"] = self.readVInt()\\n fields[\\\"ClientVersion\\\"] = self.readString()\\n fields[\\\"TencentOpenId\\\"] = self.readString()\\n fields[\\\"TencentToken\\\"] = self.readString()\\n fields[\\\"TencentPlatform\\\"] = self.readVInt()\\n fields[\\\"DeviceVerifierResponse\\\"] = self.readString()\\n fields[\\\"AppLicensingSignature\\\"] = self.readString()\\n fields[\\\"DeviceVerifierResponse\\\"] = self.readString()\\n super().decode(fields)\\n return fields\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n if fields[\\\"ClientMajor\\\"]==53:\\n calling_instance.player.ClientVersion = f'{str(fields[\\\"ClientMajor\\\"])}.{str(fields[\\\"ClientBuild\\\"])}.{str(fields[\\\"ClientMinor\\\"])}'\\n fields[\\\"Socket\\\"] = calling_instance.client\\n db_instance = DatabaseHandler()\\n if db_instance.playerExist(fields[\\\"PassToken\\\"], fields[\\\"AccountID\\\"]):\\n player_data = json.loads(db_instance.getPlayerEntry(fields[\\\"AccountID\\\"])[2])\\n db_instance.loadAccount(calling_instance.player, fields[\\\"AccountID\\\"])\\n else:\\n db_instance.createAccount(calling_instance.player.getDataTemplate(fields[\\\"AccountID\\\"][0], fields[\\\"AccountID\\\"][1], fields[\\\"PassToken\\\"]))\\n ClientsManager.AddPlayer(calling_instance.player.ID, calling_instance.client)\\n Messaging.sendMessage(20104, fields, cryptoInit, calling_instance.player)\\n Messaging.sendMessage(24101, fields, cryptoInit, calling_instance.player)\\n Messaging.sendMessage(24399, fields, cryptoInit, calling_instance.player)\\n\\n def getMessageType(self):\\n return 10101\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"AskForBattleEndMessage\",\n \"path\": \"Heart/Packets/Client/Battle/AskForBattleEndMessage.py\",\n \"snippet\": \"class AskForBattleEndMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"Unk1\\\"] = self.readVInt()\\n fields[\\\"Result\\\"] = self.readVInt()\\n fields[\\\"Rank\\\"] = self.readVInt()\\n fields[\\\"MapID\\\"] = self.readDataReference()\\n fields[\\\"HeroesCount\\\"] = self.readVInt()\\n fields[\\\"Heroes\\\"] = []\\n for i in range(fields[\\\"HeroesCount\\\"]): fields[\\\"Heroes\\\"].append({\\\"Brawler\\\": {\\\"ID\\\": self.readDataReference(), \\\"SkinID\\\": self.readDataReference()}, \\\"Team\\\": self.readVInt(), \\\"IsPlayer\\\": self.readBoolean(), \\\"PlayerName\\\": self.readString()})\\n super().decode(fields)\\n return fields\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n fields[\\\"Socket\\\"] = calling_instance.client\\n Messaging.sendMessage(23456, fields, cryptoInit, calling_instance.player)\\n\\n def getMessageType(self):\\n return 14110\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"ChangeAvatarNameMessage\",\n \"path\": \"Heart/Packets/Client/Home/ChangeAvatarNameMessage.py\",\n \"snippet\": \"class ChangeAvatarNameMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n self.writeString(fields[\\\"Name\\\"])\\n self.writeBoolean(fields[\\\"NameSetByUser\\\"])\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"Name\\\"] = self.readString()\\n fields[\\\"NameSetByUser\\\"] = self.readBoolean()\\n super().decode(fields)\\n return fields\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n db_instance = DatabaseHandler()\\n playerData = db_instance.getPlayer(calling_instance.player.ID)\\n playerData[\\\"Name\\\"] = fields[\\\"Name\\\"]\\n playerData[\\\"Registered\\\"] = True\\n db_instance.updatePlayerData(playerData, calling_instance)\\n fields[\\\"Socket\\\"] = calling_instance.client\\n fields[\\\"Command\\\"] = {\\\"ID\\\": 201}\\n Messaging.sendMessage(24111, fields, cryptoInit, calling_instance.player)\\n\\n def getMessageType(self):\\n return 10212\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"EndClientTurnMessage\",\n \"path\": \"Heart/Packets/Client/Home/EndClientTurnMessage.py\",\n \"snippet\": \"class EndClientTurnMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n fields = {}\\n self.readBoolean()\\n fields[\\\"Tick\\\"] = self.readVInt()\\n fields[\\\"Checksum\\\"] = self.readVInt()\\n fields[\\\"CommandsCount\\\"] = self.readVInt()\\n super().decode(fields)\\n fields[\\\"Commands\\\"] = []\\n for i in range(fields[\\\"CommandsCount\\\"]):\\n fields[\\\"Commands\\\"].append({\\\"ID\\\": self.readVInt()})\\n if LogicCommandManager.commandExist(fields[\\\"Commands\\\"][i][\\\"ID\\\"]):\\n command = LogicCommandManager.createCommand(fields[\\\"Commands\\\"][i][\\\"ID\\\"])\\n print(\\\"Command\\\", LogicCommandManager.getCommandsName(fields[\\\"Commands\\\"][i][\\\"ID\\\"]))\\n if command is not None:\\n fields[\\\"Commands\\\"][i][\\\"Fields\\\"] = command.decode(self)\\n fields[\\\"Commands\\\"][i][\\\"Instance\\\"] = command\\n return fields\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n fields[\\\"Socket\\\"] = calling_instance.client\\n for command in fields[\\\"Commands\\\"]:\\n if \\\"Instance\\\" not in command.keys():\\n return\\n\\n if hasattr(command[\\\"Instance\\\"], 'execute'):\\n command[\\\"Instance\\\"].execute(calling_instance, command[\\\"Fields\\\"], cryptoInit)\\n if command[\\\"ID\\\"] == 519:\\n Messaging.sendMessage(24104, {\\\"Socket\\\": calling_instance.client, \\\"ServerChecksum\\\": 0, \\\"ClientChecksum\\\": 0, \\\"Tick\\\": 0}, cryptoInit)\\n\\n def getMessageType(self):\\n return 14102\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"GoHomeFromOfflinePractiseMessage\",\n \"path\": \"Heart/Packets/Client/Home/GoHomeFromOfflinePractiseMessage.py\",\n \"snippet\": \"class GoHomeFromOfflinePractiseMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n fields = {}\\n self.readBoolean()\\n return fields\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n fields[\\\"Socket\\\"] = calling_instance.client\\n Messaging.sendMessage(24101, fields, cryptoInit, calling_instance.player)\\n\\n def getMessageType(self):\\n return 14109\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"GoHomeMessage\",\n \"path\": \"Heart/Packets/Client/Home/GoHomeMessage.py\",\n \"snippet\": \"class GoHomeMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n fields = {}\\n self.readBoolean()\\n return fields\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n fields[\\\"Socket\\\"] = calling_instance.client\\n Messaging.sendMessage(24101, fields, cryptoInit, calling_instance.player)\\n\\n def getMessageType(self):\\n return 17750\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"GetPlayerProfileMessage\",\n \"path\": \"Heart/Packets/Client/Home/GetPlayerProfileMessage.py\",\n \"snippet\": \"class GetPlayerProfileMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"BattleInfoBoolean\\\"] = self.readBoolean()\\n if fields[\\\"BattleInfoBoolean\\\"]:\\n fields[\\\"unk1\\\"] = self.readVInt()\\n fields[\\\"AnotherID\\\"] = self.readLong()\\n fields[\\\"unk2\\\"] = self.readVInt()\\n for i in self.readVInt():\\n fields[\\\"CsvID\\\"] = self.readDataReference()\\n fields[\\\"unk3\\\"] = self.readVInt()\\n fields[\\\"unk4\\\"] = self.readVInt()\\n fields[\\\"unk5\\\"] = self.readVInt()\\n fields[\\\"unk6\\\"] = self.readVInt()\\n fields[\\\"PlayerName\\\"] = self.readString()\\n fields[\\\"unk7\\\"] = self.readVInt()\\n fields[\\\"Thumbnail\\\"] = self.readVInt()\\n fields[\\\"NameColor\\\"] = self.readVInt()\\n fields[\\\"unk10\\\"] = self.readVInt()\\n fields[\\\"unk11\\\"] = self.readVInt()\\n fields[\\\"PlayerHighID\\\"] = self.readInt()\\n fields[\\\"PlayerLowID\\\"] = self.readInt()\\n super().decode(fields)\\n\\n\\n return fields\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n fields[\\\"Socket\\\"] = calling_instance.client\\n Messaging.sendMessage(24113, fields, cryptoInit, calling_instance.player)\\n\\n def getMessageType(self):\\n return 15081\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"AskForAllianceDataMessage\",\n \"path\": \"Heart/Packets/Client/Home/AskForAllianceDataMessage.py\",\n \"snippet\": \"class AskForAllianceDataMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"id\\\"] = self.readVLong()\\n fields[\\\"isInAlliance\\\"] = self.readBoolean()\\n if fields[\\\"isInAlliance\\\"] == True:\\n fields[\\\"anotherIDHigh\\\"] = self.readVInt()\\n fields[\\\"anotherIDLow\\\"] = self.readVInt()\\n super().decode(fields)\\n\\n return fields\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n fields[\\\"Socket\\\"] = calling_instance.client\\n Messaging.sendMessage(24301, fields, cryptoInit, calling_instance.player)\\n\\n def getMessageType(self):\\n return 14302\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"KeepAliveMessage\",\n \"path\": \"Heart/Packets/Client/Socket/KeepAliveMessage.py\",\n \"snippet\": \"class KeepAliveMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n return {}\\n\\n def execute(message, calling_instance, fields, cryptoInit):\\n fields[\\\"Socket\\\"] = calling_instance.client\\n Messaging.sendMessage(20108, fields, cryptoInit)\\n\\n def getMessageType(self):\\n return 10108\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"LoginFailedMessage\",\n \"path\": \"Heart/Packets/Server/Authentification/LoginFailedMessage.py\",\n \"snippet\": \"class LoginFailedMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n self.writeInt(fields['ErrorID'])\\n self.writeString(fields['FingerprintData'])\\n self.writeString()\\n self.writeString(fields['ContentURL'])\\n self.writeString()\\n self.writeString(fields['Message'])\\n self.writeInt(0)\\n self.writeBoolean(False)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeString()\\n self.writeInt(0)\\n self.writeBoolean(True)\\n self.writeBoolean(True)\\n self.writeString()\\n self.writeVInt(0)\\n self.writeString()\\n self.writeBoolean(False)\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"ErrorCode\\\"] = self.readInt()\\n fields[\\\"ResourceFingerprintData\\\"] = self.readString()\\n fields[\\\"RedirectDomain\\\"] = self.readString()\\n fields[\\\"ContentURL\\\"] = self.readString()\\n fields[\\\"UpdateURL\\\"] = self.readString()\\n fields[\\\"Reason\\\"] = self.readString()\\n fields[\\\"SecondsUntilMaintenanceEnd\\\"] = self.readInt()\\n fields[\\\"ShowContactSupportForBan\\\"] = self.readBoolean()\\n fields[\\\"CompressedFingerprintData\\\"] = self.readBytesWithoutLength()\\n fields[\\\"ContentURLListCount\\\"] = self.readInt()\\n fields[\\\"ContentURLList\\\"] = []\\n for i in range(fields[\\\"ContentURLListCount\\\"]):\\n fields[\\\"ContentURLList\\\"].append(self.readString())\\n fields[\\\"KunlunAppStore\\\"] = self.readInt()\\n fields[\\\"MaintenanceType\\\"] = self.readInt()\\n fields[\\\"HelpshiftFaqId\\\"] = self.readString()\\n fields[\\\"Tier\\\"] = self.readInt()\\n fields[\\\"Unk1\\\"] = self.readBoolean()\\n fields[\\\"Unk2\\\"] = self.readBoolean()\\n fields[\\\"Unk3\\\"] = self.readString()\\n fields[\\\"Unk4\\\"] = self.readVInt()\\n fields[\\\"Unk5\\\"] = self.readString()\\n fields[\\\"OptionalTargetedAccountIdState\\\"] = self.readBoolean()\\n if fields[\\\"OptionalTargetedAccountIdState\\\"] == True:\\n fields[\\\"OptionalTargetedAccountId\\\"] = self.readLong()\\n super().decode(fields)\\n return fields\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 20103\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"LoginOkMessage\",\n \"path\": \"Heart/Packets/Server/Authentification/LoginOkMessage.py\",\n \"snippet\": \"class LoginOkMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 1\\n\\n def encode(self, fields, player):\\n self.writeLong(player.ID[0], player.ID[1])\\n self.writeLong(player.ID[0], player.ID[1])\\n self.writeString(player.Token)\\n self.writeString()\\n self.writeString()\\n self.writeInt(53)\\n self.writeInt(176)\\n self.writeInt(1)\\n self.writeString(\\\"dev\\\")\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeString()\\n self.writeString()\\n self.writeString()\\n self.writeInt(0)\\n self.writeString()\\n self.writeString(\\\"RU\\\")\\n self.writeString()\\n self.writeInt(0)\\n self.writeString()\\n self.writeInt(2)\\n self.writeString('https://game-assets.brawlstarsgame.com')\\n self.writeString('http://a678dbc1c015a893c9fd-4e8cc3b1ad3a3c940c504815caefa967.r87.cf2.rackcdn.com')\\n self.writeInt(2)\\n self.writeString('https://event-assets.brawlstars.com')\\n self.writeString('https://24b999e6da07674e22b0-8209975788a0f2469e68e84405ae4fcf.ssl.cf2.rackcdn.com/event-assets')\\n self.writeVInt(0)\\n self.writeCompressedString(b'')\\n self.writeBoolean(True)\\n self.writeBoolean(False)\\n self.writeString()\\n self.writeString()\\n self.writeString()\\n self.writeString('https://play.google.com/store/apps/details?id=com.supercell.brawlstars')\\n self.writeString()\\n self.writeBoolean(False)\\n\\n self.writeBoolean(False)\\n if False:\\n self.writeString()\\n\\n self.writeBoolean(False)\\n if False:\\n self.writeString()\\n\\n self.writeBoolean(False)\\n if False:\\n self.writeString()\\n\\n self.writeBoolean(False)\\n if False:\\n self.writeString()\\n\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"AccountID\\\"] = self.readLong()\\n fields[\\\"HomeID\\\"] = self.readLong()\\n fields[\\\"PassToken\\\"] = self.readString()\\n fields[\\\"FacebookID\\\"] = self.readString()\\n fields[\\\"GamecenterID\\\"] = self.readString()\\n fields[\\\"ServerMajorVersion\\\"] = self.readInt()\\n fields[\\\"ContentVersion\\\"] = self.readInt()\\n fields[\\\"ServerBuild\\\"] = self.readInt()\\n fields[\\\"ServerEnvironment\\\"] = self.readString()\\n fields[\\\"SessionCount\\\"] = self.readInt()\\n fields[\\\"PlayTimeSeconds\\\"] = self.readInt()\\n fields[\\\"DaysSinceStartedPlaying\\\"] = self.readInt()\\n fields[\\\"FacebookAppID\\\"] = self.readString()\\n fields[\\\"ServerTime\\\"] = self.readString()\\n fields[\\\"AccountCreatedDate\\\"] = self.readString()\\n fields[\\\"StartupCooldownSeconds\\\"] = self.readInt()\\n fields[\\\"GoogleServiceID\\\"] = self.readString()\\n fields[\\\"LoginCountry\\\"] = self.readString()\\n fields[\\\"KunlunID\\\"] = self.readString()\\n fields[\\\"Tier\\\"] = self.readInt()\\n fields[\\\"TencentID\\\"] = self.readString()\\n\\n ContentUrlCount = self.readInt()\\n fields[\\\"GameAssetsUrls\\\"] = []\\n for i in range(ContentUrlCount):\\n fields[\\\"GameAssetsUrls\\\"].append(self.readString())\\n\\n EventUrlCount = self.readInt()\\n fields[\\\"EventAssetsUrls\\\"] = []\\n for i in range(EventUrlCount):\\n fields[\\\"EventAssetsUrls\\\"].append(self.readString())\\n\\n fields[\\\"SecondsUntilAccountDeletion\\\"] = self.readVInt()\\n fields[\\\"SupercellIDToken\\\"] = self.readCompressedString()\\n fields[\\\"IsSupercellIDLogoutAllDevicesAllowed\\\"] = self.readBoolean()\\n fields[\\\"isSupercellIDEligible\\\"] = self.readBoolean()\\n fields[\\\"LineID\\\"] = self.readString()\\n fields[\\\"SessionID\\\"] = self.readString()\\n fields[\\\"KakaoID\\\"] = self.readString()\\n fields[\\\"UpdateURL\\\"] = self.readString()\\n fields[\\\"YoozooPayNotifyUrl\\\"] = self.readString()\\n fields[\\\"UnbotifyEnabled\\\"] = self.readBoolean()\\n\\n Unknown1 = self.readBoolean()\\n fields[\\\"Unknown1\\\"] = Unknown1\\n if Unknown1:\\n fields[\\\"Unknown2\\\"] = self.readString()\\n\\n Unknown3 = self.readBoolean()\\n fields[\\\"Unknown3\\\"] = Unknown1\\n if Unknown3:\\n fields[\\\"Unknown4\\\"] = self.readString()\\n\\n Unknown5 = self.readBoolean()\\n fields[\\\"Unknown5\\\"] = Unknown1\\n if Unknown5:\\n fields[\\\"Unknown6\\\"] = self.readString()\\n\\n Unknown7 = self.readBoolean()\\n fields[\\\"Unknown7\\\"] = Unknown1\\n if Unknown7:\\n fields[\\\"Unknown8\\\"] = self.readString()\\n super().decode(fields)\\n return fields\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 20104\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"OutOfSyncMessage\",\n \"path\": \"Heart/Packets/Server/Authentification/OutOfSyncMessage.py\",\n \"snippet\": \"class OutOfSyncMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n self.writeVInt(fields[\\\"ServerChecksum\\\"])\\n self.writeVInt(fields[\\\"ClientChecksum\\\"])\\n self.writeVInt(fields[\\\"Tick\\\"])\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"ServerChecksum\\\"] = self.readVInt()\\n fields[\\\"ClientChecksum\\\"] = self.readVInt()\\n fields[\\\"Tick\\\"] = self.readVInt()\\n super().decode(fields)\\n return fields\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 24104\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"ServerHelloMessage\",\n \"path\": \"Heart/Packets/Server/Authentification/ServerHelloMessage.py\",\n \"snippet\": \"class ServerHelloMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n self.writeBytes(urandom(24), 24)\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"Random\\\"] = self.readBytesWithoutLength()\\n super().decode(fields)\\n return fields\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 20100\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"BattleEndMessage\",\n \"path\": \"Heart/Packets/Server/Battle/BattleEndMessage.py\",\n \"snippet\": \"class BattleEndMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields, player):\\n self.writeLong(0, 0) # Battle UUID High\\n self.writeLong(0, 0) # Battle UUID Low\\n self.writeVInt(2) # Battle End Game Mode (gametype)\\n self.writeVInt(fields[\\\"Rank\\\"]) # Result (Victory/Defeat/Draw/Rank Score)\\n self.writeVInt(0) # Tokens Gained (Gained Keys)\\n self.writeVInt(0) # Trophies Result (Metascore change)\\n self.writeVInt(0) # Power Play Points Gained (Pro League Points)\\n self.writeVInt(0) # Doubled Tokens (Double Keys)\\n self.writeVInt(0) # Double Token Event (Double Event Keys)\\n self.writeVInt(0) # Token Doubler Remaining (Double Keys Remaining)\\n self.writeVInt(0) # game Lenght In Seconds\\n self.writeVInt(0) # Epic Win Power Play Points Gained (op Win Points)\\n self.writeVInt(0) # Championship Level Reached (CC Wins)\\n self.writeBoolean(False)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeBoolean(True)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeVInt(-1)\\n self.writeBoolean(False)\\n\\n self.writeVInt(fields[\\\"HeroesCount\\\"])\\n for heroEntry in fields[\\\"Heroes\\\"]:\\n self.writeBoolean(heroEntry[\\\"IsPlayer\\\"])\\n self.writeBoolean(bool(heroEntry[\\\"Team\\\"]))\\n self.writeBoolean(bool(heroEntry[\\\"Team\\\"]))\\n self.writeByte(1)\\n for i in range(1):\\n self.writeDataReference(heroEntry[\\\"Brawler\\\"][\\\"ID\\\"][0], heroEntry[\\\"Brawler\\\"][\\\"ID\\\"][1])\\n self.writeByte(1)\\n for i in range(1):\\n if (heroEntry[\\\"Brawler\\\"][\\\"SkinID\\\"] is None):\\n self.writeVInt(0)\\n else:\\n self.writeDataReference(heroEntry[\\\"Brawler\\\"][\\\"SkinID\\\"][0], heroEntry[\\\"Brawler\\\"][\\\"SkinID\\\"][1])\\n self.writeByte(1)\\n for i in range(1):\\n self.writeVInt(1250)\\n self.writeByte(1)\\n for i in range(1):\\n self.writeVInt(11)\\n self.writeByte(1)\\n for i in range(1):\\n self.writeVInt(0)\\n\\n self.writeVInt(0)\\n self.writeVInt(0)\\n\\n self.writeBoolean(heroEntry[\\\"IsPlayer\\\"])\\n if heroEntry[\\\"IsPlayer\\\"]:\\n self.writeLong(player.ID[0], player.ID[1])\\n self.writeString(heroEntry[\\\"PlayerName\\\"])\\n self.writeVInt(100)\\n self.writeVInt(28000000)\\n self.writeVInt(43000000)\\n self.writeVInt(-2)\\n if heroEntry[\\\"IsPlayer\\\"]:\\n self.writeBoolean(True)\\n self.writeVLong(5, 4181497)\\n self.writeString('haccer club')\\n self.writeDataReference(8, 16)\\n else:\\n self.writeBoolean(False)\\n\\n self.writeInt8(1)\\n self.writeVInt(5978)\\n self.writeInt8(1)\\n self.writeVInt(0)\\n\\n self.writeInt16(5)\\n self.writeInt16(3)\\n self.writeInt(27328)\\n self.writeInt(25659)\\n\\n self.writeDataReference(0)\\n\\n self.writeVInt(0)\\n self.writeVInt(1)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False) # 0x0\\n self.writeBoolean(False) # 0x0\\n self.writeBoolean(False) # 0x0\\n self.writeBoolean(False) # 0x0\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False) # 0x0\\n self.writeVInt(0)\\n self.writeBoolean(False) # 0x0\\n self.writeVInt(0)\\n self.writeBoolean(False) # 0x0\\n self.writeBoolean(False) # 0x0\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False) # 0x0\\n self.writeBoolean(False) # 0x0\\n self.writeBoolean(False) # 0x0\\n\\n def decode(self):\\n fields = {}\\n return {}\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 23456\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"AvailableServerCommandMessage\",\n \"path\": \"Heart/Packets/Server/Home/AvailableServerCommandMessage.py\",\n \"snippet\": \"class AvailableServerCommandMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields, player):\\n self.writeVInt(fields[\\\"Command\\\"][\\\"ID\\\"])\\n command = LogicCommandManager.createCommand(fields[\\\"Command\\\"][\\\"ID\\\"], self.messagePayload)\\n self.messagePayload = command.encode(fields)\\n\\n def decode(self):\\n return {}\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 24111\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"LobbyInfoMessage\",\n \"path\": \"Heart/Packets/Server/Home/LobbyInfoMessage.py\",\n \"snippet\": \"class LobbyInfoMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields, player):\\n self.writeVInt(ClientsManager.GetCount())\\n self.writeString(f\\\"\\\"\\\"Version: {player.ClientVersion}\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\"\\\"\\\")\\n self.writeVInt(0) # count event\\n self.writeVInt(0) # new timer in v51\\n\\n def decode(self):\\n fields = {}\\n fields[\\\"PlayerCount\\\"] = self.readVInt()\\n fields[\\\"Text\\\"] = self.readString()\\n fields[\\\"Unk1\\\"] = self.readVInt()\\n super().decode(fields)\\n return {}\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 23457\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"OwnHomeDataMessage\",\n \"path\": \"Heart/Packets/Server/Home/OwnHomeDataMessage.py\",\n \"snippet\": \"class OwnHomeDataMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields, player):\\n self.writeVInt(1688816070)\\n self.writeVInt(1191532375)\\n self.writeVInt(2023189)\\n self.writeVInt(73530)\\n\\n self.writeVInt(player.Trophies)\\n self.writeVInt(player.HighestTrophies)\\n self.writeVInt(player.HighestTrophies) \\n self.writeVInt(player.TrophyRoadTier)\\n self.writeVInt(player.Experience)\\n self.writeDataReference(28, player.Thumbnail)\\n self.writeDataReference(43, player.Namecolor)\\n\\n self.writeVInt(26)\\n for x in range(26):\\n self.writeVInt(x)\\n\\n self.writeVInt(0)\\n\\n self.writeVInt(0)\\n\\n self.writeVInt(0)\\n \\n self.writeVInt(len(player.OwnedSkins))\\n for x in player.OwnedSkins:\\n self.writeDataReference(29, x)\\n\\n self.writeVInt(0)\\n\\n self.writeVInt(0)\\n\\n self.writeVInt(0)\\n self.writeVInt(player.HighestTrophies)\\n self.writeVInt(0)\\n self.writeVInt(2)\\n self.writeBoolean(True)\\n self.writeVInt(0)\\n self.writeVInt(115)\\n self.writeVInt(335442)\\n self.writeVInt(1001442)\\n self.writeVInt(5778642) \\n\\n self.writeVInt(120)\\n self.writeVInt(200)\\n self.writeVInt(0)\\n\\n self.writeBoolean(True)\\n self.writeVInt(2)\\n self.writeVInt(2)\\n self.writeVInt(2)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n\\n self.writeVInt(1) # Shop Offers\\n\\n self.writeVInt(1) # RewardCount\\n\\n self.writeVInt(38) # ItemType\\n self.writeVInt(1337) # Amount\\n self.writeDataReference(0) # CsvID\\n self.writeVInt(0) # SkinID\\n\\n self.writeVInt(0) # Currency(0-Gems, 1-Gold, 3-StarpoInts)\\n self.writeVInt(0) # Cost\\n self.writeVInt(0) # Time\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False) # Daily Offer\\n self.writeVInt(0) # Old price\\n self.writeString('Offer') # Text\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeString(\\\"offer_bgr_xmas23\\\") # Background\\n self.writeVInt(0)\\n self.writeBoolean(False) # This purchase is already being processed\\n self.writeVInt(0) # Type Benefit\\n self.writeVInt(0) # Benefit\\n self.writeString()\\n self.writeBoolean(False) # One time offer\\n self.writeBoolean(False) # Claimed\\n self.writeDataReference(0)\\n self.writeDataReference(0)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n \\n self.writeVInt(20)\\n self.writeVInt(1428)\\n\\n self.writeVInt(0)\\n\\n self.writeVInt(1)\\n self.writeVInt(30)\\n\\n self.writeByte(1) # count brawlers selected\\n self.writeDataReference(16, player.SelectedBrawlers[0]) # selected brawler\\n self.writeString(player.Region) # location\\n self.writeString(player.ContentCreator) # supported creator\\n\\n self.writeVInt(6) \\n self.writeVInt(1) \\n self.writeVInt(9) \\n self.writeVInt(1) \\n self.writeVInt(22) \\n self.writeVInt(3) \\n self.writeVInt(25) \\n self.writeVInt(1) \\n self.writeVInt(24) \\n self.writeVInt(0)\\n self.writeVInt(15)\\n self.writeVInt(32447)\\n self.writeVInt(28)\\n\\n\\n self.writeVInt(0)\\n\\n self.writeVInt(1)\\n for season in range(1):\\n self.writeVInt(22-1)\\n self.writeVInt(40000)\\n self.writeBoolean(True)\\n self.writeVInt(0)\\n self.writeBoolean(False)\\n self.writeBoolean(True)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeBoolean(True)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeBoolean(True)\\n self.writeBoolean(True)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeInt(0)\\n self.writeInt(0)\\n\\n self.writeVInt(0)\\n\\n self.writeBoolean(True)\\n self.writeVInt(0)\\n self.writeVInt(1)\\n self.writeVInt(2)\\n self.writeVInt(0) \\n\\n self.writeBoolean(True) # Vanity items\\n self.writeVInt(len(player.OwnedThumbnails)+len(player.OwnedPins))\\n for x in player.OwnedThumbnails:\\n self.writeVInt(28)\\n self.writeVInt(x)\\n self.writeVInt(0)\\n for x in player.OwnedPins:\\n self.writeVInt(52)\\n self.writeVInt(x)\\n self.writeVInt(0)\\n\\n\\n self.writeBoolean(False) # Power league season data\\n\\n self.writeInt(0)\\n self.writeVInt(0)\\n self.writeVInt(16)\\n self.writeVInt(76)\\n self.writeBoolean(False)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n\\n self.writeVInt(2023189)\\n\\n self.writeVInt(35) # event slot id\\n self.writeVInt(1)\\n self.writeVInt(2)\\n self.writeVInt(3)\\n self.writeVInt(4)\\n self.writeVInt(5)\\n self.writeVInt(6)\\n self.writeVInt(7)\\n self.writeVInt(8)\\n self.writeVInt(9)\\n self.writeVInt(10)\\n self.writeVInt(11)\\n self.writeVInt(12)\\n self.writeVInt(13) \\n self.writeVInt(14)\\n self.writeVInt(15)\\n self.writeVInt(16)\\n self.writeVInt(17)\\n self.writeVInt(18) \\n self.writeVInt(19)\\n self.writeVInt(20)\\n self.writeVInt(21) \\n self.writeVInt(22)\\n self.writeVInt(23)\\n self.writeVInt(24)\\n self.writeVInt(25)\\n self.writeVInt(26)\\n self.writeVInt(27)\\n self.writeVInt(28)\\n self.writeVInt(29)\\n self.writeVInt(30)\\n self.writeVInt(31)\\n self.writeVInt(32)\\n self.writeVInt(33)\\n self.writeVInt(34)\\n self.writeVInt(35)\\n\\n self.writeVInt(1)\\n\\n self.writeVInt(4)\\n self.writeVInt(7)\\n self.writeVInt(1)\\n self.writeVInt(0)\\n self.writeVInt(72292)\\n self.writeVInt(10) \\n self.writeDataReference(15, 21) # map id\\n self.writeVInt(-1)\\n self.writeVInt(2)\\n self.writeString(\\\"\\\")\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False) # MapMaker map structure array\\n self.writeVInt(0)\\n self.writeBoolean(False) # Power League array entry\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeVInt(-1)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeVInt(-1)\\n self.writeVInt(0) \\n self.writeVInt(0) \\n self.writeVInt(0) \\n self.writeBoolean(False) \\n\\n self.writeVInt(0)\\n \\n ByteStreamHelper.encodeIntList(self, [20, 35, 75, 140, 290, 480, 800, 1250, 1875, 2800])\\n ByteStreamHelper.encodeIntList(self, [30, 80, 170, 360]) # Shop Coins Price\\n ByteStreamHelper.encodeIntList(self, [300, 880, 2040, 4680]) # Shop Coins Amount\\n\\n self.writeVInt(0) \\n\\n self.writeVInt(1)\\n self.writeVInt(41000086) # theme\\n self.writeVInt(1)\\n\\n self.writeVInt(0) \\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n\\n self.writeVInt(2)\\n self.writeVInt(1)\\n self.writeVInt(2)\\n self.writeVInt(2)\\n self.writeVInt(1)\\n self.writeVInt(-1)\\n self.writeVInt(2)\\n self.writeVInt(1)\\n self.writeVInt(4)\\n\\n ByteStreamHelper.encodeIntList(self, [0, 29, 79, 169, 349, 699])\\n ByteStreamHelper.encodeIntList(self, [0, 160, 450, 500, 1250, 2500])\\n\\n self.writeLong(0, 1) # Player ID\\n\\n self.writeVInt(0) # Notification factory\\n \\n self.writeVInt(1)\\n self.writeBoolean(False)\\n self.writeVInt(0)\\n self.writeVInt(0) \\n self.writeVInt(0)\\n self.writeBoolean(False) # Login Calendar\\n self.writeVInt(0)\\n self.writeBoolean(True) # Starr Road\\n for i in range(7):\\n self.writeVInt(0)\\n\\n self.writeVInt(0) # Mastery\\n\\n #BattleCard\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n self.writeBoolean(False)\\n\\n self.writeVInt(0) #Brawler's BattleCards\\n\\n self.writeVInt(5)\\n for i in range(5):\\n self.writeDataReference(80, i)\\n self.writeVInt(-1)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeInt(0)\\n self.writeVInt(0) \\n self.writeVInt(0)\\n self.writeVInt(86400*24)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n\\n self.writeBoolean(False)\\n\\n # end LogicClientHome\\n\\n self.writeVLong(player.ID[0], player.ID[1])\\n self.writeVLong(player.ID[0], player.ID[1])\\n self.writeVLong(player.ID[0], player.ID[1])\\n self.writeStringReference(player.Name)\\n self.writeBoolean(player.Registered)\\n self.writeInt(-1)\\n\\n self.writeVInt(17)\\n unlocked_brawler = [i['CardID'] for x,i in player.OwnedBrawlers.items()]\\n self.writeVInt(len(unlocked_brawler) + 2)\\n for x in unlocked_brawler:\\n self.writeDataReference(23, x)\\n self.writeVInt(-1)\\n self.writeVInt(1)\\n\\n self.writeDataReference(5, 8)\\n self.writeVInt(-1)\\n self.writeVInt(player.Coins)\\n\\n self.writeDataReference(5, 23)\\n self.writeVInt(-1)\\n self.writeVInt(player.Blings)\\n\\n self.writeVInt(len(player.OwnedBrawlers)) # HeroScore\\n for x,i in player.OwnedBrawlers.items():\\n self.writeDataReference(16, x)\\n self.writeVInt(-1)\\n self.writeVInt(i[\\\"Trophies\\\"])\\n\\n self.writeVInt(len(player.OwnedBrawlers)) # HeroHighScore\\n for x,i in player.OwnedBrawlers.items():\\n self.writeDataReference(16, x)\\n self.writeVInt(-1)\\n self.writeVInt(i[\\\"HighestTrophies\\\"])\\n\\n self.writeVInt(0) # Array\\n\\n self.writeVInt(0) # HeroPower\\n \\n self.writeVInt(len(player.OwnedBrawlers)) # HeroLevel\\n for x,i in player.OwnedBrawlers.items():\\n self.writeDataReference(16, x)\\n self.writeVInt(-1)\\n self.writeVInt(i[\\\"PowerLevel\\\"]-1)\\n\\n self.writeVInt(0) # hero star power gadget and hypercharge\\n\\n self.writeVInt(len(player.OwnedBrawlers)) # HeroSeenState\\n for x,i in player.OwnedBrawlers.items():\\n self.writeDataReference(16, x)\\n self.writeVInt(-1)\\n self.writeVInt(2)\\n\\n self.writeVInt(0) # Array\\n self.writeVInt(0) # Array\\n self.writeVInt(0) # Array\\n self.writeVInt(0) # Array\\n self.writeVInt(0) # Array\\n self.writeVInt(0) # Array\\n self.writeVInt(0) # Array\\n self.writeVInt(0) # Array\\n self.writeVInt(0) # Array\\n\\n self.writeVInt(player.Gems) # Diamonds\\n self.writeVInt(player.Gems) # Free Diamonds\\n self.writeVInt(10) # Player Level\\n self.writeVInt(100)\\n self.writeVInt(0) # CumulativePurchasedDiamonds or Avatar User Level Tier | 10000 < Level Tier = 3 | 1000 < Level Tier = 2 | 0 < Level Tier = 1\\n self.writeVInt(100) # Battle Count\\n self.writeVInt(10) # WinCount\\n self.writeVInt(80) # LoseCount\\n self.writeVInt(50) # WinLooseStreak\\n self.writeVInt(20) # NpcWinCount\\n self.writeVInt(0) # NpcLoseCount\\n self.writeVInt(2) # TutorialState | shouldGoToFirstTutorialBattle = State == 0\\n self.writeVInt(12)\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeString()\\n self.writeVInt(0)\\n self.writeVInt(0)\\n self.writeVInt(1)\\n\\n def decode(self):\\n fields = {}\\n return fields\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 24101\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"KeepAliveServerMessage\",\n \"path\": \"Heart/Packets/Server/Socket/KeepAliveServerMessage.py\",\n \"snippet\": \"class KeepAliveServerMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields):\\n pass\\n\\n def decode(self):\\n return {}\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 20108\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"PlayerProfileMessage\",\n \"path\": \"Heart/Packets/Server/Home/PlayerProfileMessage.py\",\n \"snippet\": \"class PlayerProfileMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields, player):\\n self.writeVLong(fields[\\\"PlayerHighID\\\"], fields[\\\"PlayerLowID\\\"])\\n self.writeDataReference(16,11) # \\n self.writeVInt(70)\\n for i in range(70):\\n self.writeDataReference(16, i)\\n self.writeDataReference(0)\\n self.writeVInt(500) # trophies\\n self.writeVInt(1250) # highestTrophies\\n self.writeVInt(11) #power level\\n \\n self.writeVInt(18)\\n\\n self.writeVInt(1) \\n self.writeVInt(1) # 3v3 victories\\n\\n self.writeVInt(2)\\n self.writeVInt(528859) # total exp\\n\\n self.writeVInt(3)\\n self.writeVInt(3) # current trophies\\n\\n self.writeVInt(4)\\n self.writeVInt(4) # highest trophies\\n\\n self.writeVInt(5) \\n self.writeVInt(5) # unlocked brawler?\\n\\n self.writeVInt(8)\\n self.writeVInt(6) # solo victories\\n\\n self.writeVInt(11) \\n self.writeVInt(7) # duo victories\\n\\n self.writeVInt(9) \\n self.writeVInt(8) # highest level robo rumble\\n\\n self.writeVInt(12) \\n self.writeVInt(9) # highest level boss fight\\n\\n self.writeVInt(13)\\n self.writeVInt(10) # highest power league points\\n\\n self.writeVInt(14)\\n self.writeVInt(11) # some power league stuff\\n\\n self.writeVInt(15)\\n self.writeVInt(12) # most challenge win\\n\\n self.writeVInt(16) #highest level city rampage\\n self.writeVInt(13)\\n\\n self.writeVInt(18) #highest solo power league rank\\n self.writeVInt(14)\\n\\n self.writeVInt(17) #highest team power league rank\\n self.writeVInt(15)\\n\\n self.writeVInt(19) # highest Club league rank\\n self.writeVInt(16)\\n\\n self.writeVInt(20) # number fame\\n self.writeVInt(1000)\\n\\n self.writeVInt(21)\\n self.writeVInt(502052) #v50\\n\\n self.writeString(player.Name) #PlayerInfo\\n self.writeVInt(100)\\n self.writeVInt(28000000 + player.Thumbnail)\\n self.writeVInt(43000000 + player.Namecolor)\\n self.writeVInt(14)\\n\\n self.writeBoolean(True)\\n self.writeVInt(300)\\n\\n self.writeString(\\\"hello world\\\")\\n self.writeVInt(100)\\n self.writeVInt(200)\\n self.writeDataReference(29, 558)\\n self.writeDataReference(0)\\n self.writeDataReference(0)\\n self.writeDataReference(0)\\n self.writeDataReference(0)\\n\\n self.writeBoolean(True) #alliance\\n self.writeLong(0,1) #alliance ID\\n self.writeString(\\\"haccers\\\") #alliance name\\n self.writeDataReference(8,1) # alliance icon\\n self.writeVInt(1) # type\\n self.writeVInt(1) # member count\\n self.writeVInt(10000) # total trophies\\n self.writeVInt(1) # minimum trophies to enter\\n self.writeDataReference(0)\\n self.writeString(\\\"RU\\\") #location\\n self.writeVInt(4) # unknown\\n self.writeBoolean(True) #is Family friendly\\n self.writeVInt(0)\\n \\n\\n self.writeDataReference(25, 1) #alliance role\\n self.writeVInt(16)\\n\\n def decode(self):\\n pass\\n # fields = {}\\n # fields[\\\"PlayerCount\\\"] = self.readVInt()\\n # fields[\\\"Text\\\"] = self.readString()\\n # fields[\\\"Unk1\\\"] = self.readVInt()\\n # super().decode(fields)\\n return {}\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 24113\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"MyAllianceMessage\",\n \"path\": \"Heart/Packets/Server/Home/MyAllianceMessage.py\",\n \"snippet\": \"class MyAllianceMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields, player):\\n self.writeVInt(1) # Online people in alliance\\n self.writeBoolean(True) # isInAlliance\\n self.writeDataReference(25, 4)\\n self.writeLong(0, 1) # alliance ID\\n self.writeString(player.ContentCreator) # alliance name\\n self.writeDataReference(8, 37) # alliance icon\\n self.writeVInt(3) # type\\n self.writeVInt(1) # member count\\n self.writeVInt(9500) # total trophies\\n self.writeVInt(1) # minimum trophies to enter\\n self.writeVInt(0) # 0\\n self.writeString('RU') # location\\n self.writeVInt(3) # unknown\\n self.writeBoolean(True) # isFamilyFriendly\\n self.writeVInt(0)\\n\\n def decode(self):\\n fields = {}\\n super().decode(fields)\\n return {}\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 24399\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n },\n {\n \"identifier\": \"AllianceDataMessage\",\n \"path\": \"Heart/Packets/Server/Home/AllianceDataMessage.py\",\n \"snippet\": \"class AllianceDataMessage(PiranhaMessage):\\n def __init__(self, messageData):\\n super().__init__(messageData)\\n self.messageVersion = 0\\n\\n def encode(self, fields, player):\\n self.writeBoolean(True)\\n\\n self.writeLong(0, 1) # alliance ID\\n self.writeString(player.ContentCreator) # alliance name\\n self.writeDataReference(8, 37) # alliance icon\\n self.writeVInt(1) # type\\n self.writeVInt(1) # member count\\n self.writeVInt(player.Trophies) # total trophies\\n self.writeVInt(0) # minimum trophies to enter\\n self.writeVInt(0) # 0\\n self.writeString('RU') # location\\n self.writeVInt(1) # people online\\n self.writeBoolean(True) # isFamilyFriendly\\n self.writeVInt(0)\\n\\n self.writeString(\\\"this is the hacciest club in the world\\\")\\n\\n self.writeVInt(1) # member count\\n self.writeLong(player.ID[0], player.ID[1]) # player ID\\n self.writeVInt(2) # role\\n self.writeVInt(player.Trophies) # trophies\\n self.writeVInt(0) # status: 0=offline 2=online\\n self.writeVInt(1) # last connected time seconds ?\\n highestPowerLeagueRank = 2\\n self.writeVInt(highestPowerLeagueRank)\\n if highestPowerLeagueRank != 0:\\n self.writeVInt(2) #solo\\n self.writeVInt(1) #duo\\n self.writeBoolean(False) # boolean always false?\\n\\n self.writeString(player.Name) # player name\\n self.writeVInt(100) # VInt always 100\\n self.writeVInt(28000000 + player.Thumbnail) # thumbnail\\n self.writeVInt(43000000 + player.Namecolor) # name color\\n self.writeVInt(46000000 + player.Namecolor)\\n\\n self.writeVInt(-1) # most people have it -1 but some with something\\n self.writeBoolean(False) # whats this ? only 2/30 people have it true in my club\\n week = 58 # week 58 of club league as of 2023/07/05, this number is 0 if you just arrived in the club\\n self.writeVInt(week)\\n if week != 0: # club league week number?\\n self.writeVInt(3) # day\\n self.writeVInt(18) # total club trophies earned\\n self.writeVInt(0) # event day club trophies earned\\n self.writeVInt(8) # total tickets used\\n self.writeVInt(0) # event day tickets used\\n self.writeVInt(6) # event day max tickets\\n self.writeVInt(6) # event day tickets left\\n self.writeVInt(0) # event day player ranking\\n self.writeBoolean(True) # everyone have it to true\\n self.writeVInt(200) # player experience lvl but why tf it doesn't show for some people\\n\\n def decode(self):\\n fields = {}\\n super().decode(fields)\\n return {}\\n\\n def execute(message, calling_instance, fields):\\n pass\\n\\n def getMessageType(self):\\n return 24301\\n\\n def getMessageVersion(self):\\n return self.messageVersion\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from Heart.Packets.Client.Authentification.ClientHelloMessage import ClientHelloMessage\nfrom Heart.Packets.Client.Authentification.LoginMessage import LoginMessage\nfrom Heart.Packets.Client.Battle.AskForBattleEndMessage import AskForBattleEndMessage\nfrom Heart.Packets.Client.Home.ChangeAvatarNameMessage import ChangeAvatarNameMessage\nfrom Heart.Packets.Client.Home.EndClientTurnMessage import EndClientTurnMessage\nfrom Heart.Packets.Client.Home.GoHomeFromOfflinePractiseMessage import GoHomeFromOfflinePractiseMessage\nfrom Heart.Packets.Client.Home.GoHomeMessage import GoHomeMessage\nfrom Heart.Packets.Client.Home.GetPlayerProfileMessage import GetPlayerProfileMessage\nfrom Heart.Packets.Client.Home.AskForAllianceDataMessage import AskForAllianceDataMessage\nfrom Heart.Packets.Client.Socket.KeepAliveMessage import KeepAliveMessage\nfrom Heart.Packets.Server.Authentification.LoginFailedMessage import LoginFailedMessage\nfrom Heart.Packets.Server.Authentification.LoginOkMessage import LoginOkMessage\nfrom Heart.Packets.Server.Authentification.OutOfSyncMessage import OutOfSyncMessage\nfrom Heart.Packets.Server.Authentification.ServerHelloMessage import ServerHelloMessage\nfrom Heart.Packets.Server.Battle.BattleEndMessage import BattleEndMessage\nfrom Heart.Packets.Server.Home.AvailableServerCommandMessage import AvailableServerCommandMessage\nfrom Heart.Packets.Server.Home.LobbyInfoMessage import LobbyInfoMessage\nfrom Heart.Packets.Server.Home.OwnHomeDataMessage import OwnHomeDataMessage\nfrom Heart.Packets.Server.Socket.KeepAliveServerMessage import KeepAliveServerMessage\nfrom Heart.Packets.Server.Home.PlayerProfileMessage import PlayerProfileMessage\nfrom Heart.Packets.Server.Home.MyAllianceMessage import MyAllianceMessage\nfrom Heart.Packets.Server.Home.AllianceDataMessage import AllianceDataMessage"},"token_num":{"kind":"number","value":17267,"string":"17,267"},"cropped_code":{"kind":"string","value":" 16939: 'AskApiTokenMessage',\n 17000: 'LogicAccountTransferCodeRequestMessage',\n 17190: 'JoinAllianceUsingTokenMessage',\n 17337: 'UnbotifyReportMessage',\n 17338: 'AdjustPackageMessage',\n 17750: GoHomeFromOfflinePractiseMessage, #v50\n 18686: 'SetSupportedCreatorMessage',\n 19001: 'LatencyTestResultMessage',\n 19002: 'UdpLatencyTestRequestMessage',\n 19003: 'TriggerStartLatencyTestMessage',\n 19004: 'RequestLatencyTestStatusMessage',\n 20000: 'SetEncryptionMessage',\n 20100: ServerHelloMessage,\n 20101: 'CreateAccountOkMessage',\n 20103: LoginFailedMessage,\n 20104: LoginOkMessage,\n 20105: 'FriendListMessage',\n 20106: 'FriendListUpdateMessage',\n 20107: 'AddableFriendsMessage',\n 20108: KeepAliveServerMessage,\n 20109: 'FriendOnlineStatusMessage',\n 20110: 'FriendLoggedInMessage',\n 20111: 'FriendLoggedOutMessage',\n 20112: 'AddFriendFailedMessage',\n 20117: 'ReportUserStatusMessage',\n 20118: 'ChatAccountBanStatusMessage',\n 20121: 'BillingRequestFailedMessage',\n 20132: 'UnlockAccountOkMessage',\n 20133: 'UnlockAccountFailedMessage',\n 20151: 'AppleBillingProcessedByServerMessage',\n 20152: 'GoogleBillingProcessedByServerMessage',\n 20153: 'TencentBillingProcessedByServerMessage',\n 20154: 'CafeBazaarBillingProcessedByServerMessage',\n 20156: 'KunlunBillingProcessedByServerMessage',\n 20161: 'ShutdownStartedMessage',\n 20171: 'PersonalBreakStartedMessage',\n 20173: 'YoozooBillingProcessedByServerMessage',\n 20199: 'FriendSuggestionsMessage',\n 20205: 'AvatarNameChangeFailedMessage',\n 20206: 'AvatarOnlineStatusUpdated',\n 20207: 'AllianceOnlineStatusUpdatedMessage',\n 20300: 'AvatarNameCheckResponseMessage',\n 20402: 'CreateGameFailedMessage',\n 20405: 'MatchMakingStatusMessage',\n 20406: 'MatchMakingCancelledMessage',\n 20501: 'AcceptFriendFailedMessage',\n 20523: 'YoozooOrderAvailableMessage',\n 20545: 'YoozooOrderDeliveryFailedMessage',\n 20559: 'StartLoadingMessage',\n 20801: 'NotificationMessage',\n 20802: 'OpponentRejoinsMatchNotificationMessage',\n 20931: 'AntiAddictionDataUpdatedMessage',\n 22089: 'GetTokenFriendResultMessage',\n 22100: 'CreatePlayerMapResponseMessage',\n 22101: 'DeletePlayerMapResponseMessage',\n 22102: 'PlayerMapsMessage',\n 22103: 'UpdatePlayerMapResponseMessage',\n 22104: 'SubmitPlayerMapResponseMessage',\n 22105: 'PublishPlayerMapResponseMessage',\n 22106: 'ChangePlayerMapNameMResponseMessage',\n 22107: 'PlayerMapInfoUpdatedMessage',\n 22109: 'DebugPlayerMapReviewResultOverrideSetMessage',\n 22111: 'PlayerMapGreenlightedMessage',\n 22125: 'ReportPlayerMapResponseMessage',\n 22150: 'RankedMatchStartMessage',\n 22151: 'RankedMatchBanStartedMessage',\n 22152: 'RankedMatchBanHeroResponseMessage',\n 22153: 'RankedMatchBanEndedMessage',\n 22154: 'RankedMatchPickStartedMessage',\n 22155: 'RankedMatchPickHeroFailedMessage',\n 22156: 'RankedMatchHeroPickedMessage',\n 22157: 'RankedMatchHeroDataUpdatedMessage',\n 22158: 'RankedMatchFinalPreparationStartedMessage',\n 22159: 'RankedMatchTerminatedMessage',\n 22202: 'MapPreviewMessage',\n 22377: 'GoogleServiceAccountBoundMessage',\n 22687: 'GamecenterAccountAlreadyBoundMessage',\n 22957: 'PvpMatchmakeNotificationMessage',\n 23067: 'SCIDLogoutAllDevicesResultMessage',\n 23302: 'GetAllianceInviteTokenResultMessage',\n 23456: BattleEndMessage,\n 23457: LobbyInfoMessage,\n 23458: 'BattleLogMessage',\n 23459: 'BattleLogReplayAvailableMessage',\n 23494: 'GoogleServiceAccountAlreadyBoundMessage',\n 23774: 'PlayerJWTokenMessage',\n 24101: OwnHomeDataMessage,\n 24104: OutOfSyncMessage,\n 24105: 'SpectacleFailedMessage',\n 24106: 'StopHomeLogicMessage',\n 24108: 'MatchmakeFailedMessage',\n 24109: 'VisionUpdateMessage',\n 24111: AvailableServerCommandMessage,\n 24112: 'UdpConnectionInfoMessage',\n 24113: PlayerProfileMessage,\n 24114: 'HomeBattleReplayDataMessage',\n 24115: 'ServerErrorMessage',\n 24116: 'HomeBattleReplayFailedMessage',\n 24117: 'HomeBattleReplayViewedMessage',\n 24123: 'SeasonRewardsMessage',\n 24124: 'TeamMessage',\n 24125: 'TeamLeftMessage',\n 24129: 'TeamErrorMessage',\n 24130: 'TeamGameStartingMessage',\n 24131: 'TeamStreamMessage',\n 24177: 'SetRegionResponseMessage',\n 24178: 'SetCountryResponseMessage',\n 24199: 'LookForGameRoomRequestMessage',\n 24201: 'FacebookAccountBoundMessage',\n 24202: 'FacebookAccountAlreadyBoundMessage',\n 24203: 'KakaoAccountBoundMessage',\n 24204: 'KakaoAccountAlreadyBoundMessage',\n 24205: 'LineAccountAlreadyBoundMessage',\n 24206: 'LineAccountBoundMessage',\n 24214: 'FacebookAccountUnboundMessage',\n 24215: 'KakaoAccountUnboundMessage',\n 24216: 'LineAccountUnboundMessage',\n 24220: 'TencentAccountBoundMessage',\n 24221: 'TencentAccountAlreadyBoundMessage',\n 24223: 'tencentCheckCanPayResponseMessage',\n"},"all_code":{"kind":"string","value":"\n\nclass LogicLaserMessageFactory:\n messagesList = {\n 10055: 'AskPlayerJWTokenMessage',\n 10099: 'ClientCryptoErrorMessage',\n 10100: ClientHelloMessage,\n 10101: LoginMessage,\n 10102: 'LoginUsingSessionMessage',\n 10103: 'CreateAccountMessage',\n 10107: 'ClientCapabilitiesMessage',\n 10108: KeepAliveMessage,\n 10109: 'UdpCheckConnectionMessage',\n 10110: 'AnalyticEventMessage',\n 10111: 'AccountIdentifiersMessage',\n 10112: 'AuthenticationCheckMessage',\n 10113: 'SetDeviceTokenMessage',\n 10116: 'ResetAccountMessage',\n 10117: 'ReportUserMessage',\n 10118: 'AccountSwitchedMessage',\n 10119: 'ReportAllianceStreamMessage',\n 10121: 'UnlockAccountMessage',\n 10150: 'AppleBillingRequestMessage',\n 10151: 'GoogleBillingRequestMessage',\n 10152: 'TencentBillingRequestMessage',\n 10153: 'CafeBazaarBillingRequestMessage',\n 10159: 'KunlunBillingRequestMessage',\n 10160: 'BillingCancelledByClientMessage',\n 10177: 'ClientInfoMessage',\n 10212: ChangeAvatarNameMessage,\n 10309: 'GetAllianceInviteTokenMessage',\n 10321: 'AttributionEventMessage',\n 10401: 'CreateGameMessage',\n 10501: 'AcceptFriendMessage',\n 10502: 'AddFriendMessage',\n 10503: 'AskForAddableFriendsMessage',\n 10504: 'AskForFriendListMessage',\n 10506: 'RemoveFriendMessage',\n 10507: 'AddFriendByEmailMessage',\n 10509: 'AddFriendByAvatarNameAndCodeMessage',\n 10512: 'AskForPlayingGamecenterFriendsMessage',\n 10513: 'AskForPlayingFacebookFriendsMessage',\n 10514: 'AskForPlayingKakaoFriendsMessage',\n 10515: 'AskForPlayingTencentFriendsMessage',\n 10516: 'AskForPlayingLineFriendsMessage',\n 10517: 'AskForPlayingSupercellFriendsMessage',\n 10523: 'YoozooBillingRequestMessage',\n 10555: 'ClientInputMessage',\n 10576: 'SetBlockFriendRequestsMessage',\n 10599: 'AskForFriendSuggestionsMessage',\n 10636: 'SCIDBindAccountMessage',\n 11736: 'SCIDLogoutAllDevicesMessage',\n 12100: 'CreatePlayerMapMessage',\n 12101: 'DeletePlayerMapMessage',\n 12102: 'GetPlayerMapsMessage',\n 12103: 'UpdatePlayerMapMessage',\n 12104: 'SubmitPlayerMapMessage',\n 12105: 'PublishPlayerMapMessage',\n 12106: 'ChangePlayerMapNameMessage',\n 12107: 'EnterMapEditorMessage',\n 12108: 'GoHomeFromMapEditorMessage',\n 12110: 'TeamSetPlayerMapMessage',\n 12111: 'SignoffPlayerMapMessage',\n 12125: 'ReportPlayerMapMessage',\n 12152: 'RankedMatchBanHeroMessage',\n 12155: 'RankedMatchPickHeroMessage',\n 12157: 'RankedMatchUpdateHeroDataMessage',\n 12905: 'GetCurrentBattleReplayDataMessage',\n 12998: 'SetCountryMessage',\n 13922: 'AcceptTokenFriendMessage',\n 14101: GoHomeMessage,\n 14102: EndClientTurnMessage,\n 14103: 'StartGameMessage',\n 14104: 'StartSpectateMessage',\n 14105: 'HomeLogicStoppedMessage',\n 14106: 'CancelMatchmakingMessage',\n 14107: 'StopSpectateMessage',\n 14108: 'GoHomeFromSpectateMessage',\n #14109: GoHomeFromOfflinePractiseMessage, //before v50\n 14110: AskForBattleEndMessage,\n #14113: GetPlayerProfileMessage, //before v50\n 14114: 'GetBattleLogMessage',\n 14115: 'BattleLogViewReplayMessage',\n 14116: 'ViewReplayByStringMessage',\n 14117: 'RequestMatchCancelMessage',\n 14118: 'SinglePlayerMatchRequestMessage',\n 14166: 'ChronosEventSeenMessage',\n 14167: 'ChronosEventSeenMessage',\n 14177: 'PlayAgainMessage',\n 14178: 'DebugCommandMessage',\n 14199: 'LookForGameRoomRequestMessage',\n 14211: 'UnbindFacebookAccountMessage',\n 14201: 'BindFacebookAccountMessage',\n 14202: 'BindKakaoAccountMessage',\n 14203: 'BingLineAccountMessage',\n 14212: 'BindGamecenterAccountMessage',\n 14213: 'UnbindKakaoAccountMessage',\n 14214: 'UnbindLineAccountMessage',\n 14262: 'BindGoogleServiceAccountMessage',\n 14266: 'BindTencentAccountMessage',\n 14268: 'TencentCheckCanPayMessage',\n 14276: 'TencentAntiAddictionInstructionExecutedMessage',\n 14277: 'GetSeasonRewardsMessage',\n 14299: 'SetAllianceCountryMessage',\n 14301: 'CreateAllianceMessage',\n 14302: AskForAllianceDataMessage,\n 14303: 'AskForJoinableAlliancesListMessage',\n 14304: 'AskForAllianceStreamMessage',\n 14305: 'JoinAllianceMessage',\n 14306: 'ChangeAllianceMemberRoleMessage',\n 14307: 'KickAllianceMemberMessage',\n 14308: 'LeaveAllianceMessage',\n 14315: 'ChatToAllianceStreamMessage',\n 14316: 'ChangeAllianceSettingsMessage',\n 14317: 'RequestJoinAllianceMessage',\n 14321: 'RespondToAllianceJoinRequestMessage',\n 14322: 'SendAllianceInvitationMessage',\n 14323: 'JoinAllianceUsingInvitationMessage',\n 14324: 'SearchAlliancesMessage',\n 14326: 'SendAllianceInvitationToFriendMessage',\n 14330: 'SendAllianceMailMessage',\n 14350: 'TeamCreateMessage',\n 14351: 'TeamJoinMessage',\n 14352: 'TeamKickMessage',\n 14353: 'TeamLeaveMessage',\n 14354: 'TeamChangeMemberSettingsMessage',\n 14355: 'TeamSetMemberReadyMessage',\n 14356: 'TeamTogglePractiseMessage',\n 14357: 'TeamToggleMemberSideMessage',\n 14358: 'TeamSpectateMessage',\n 14359: 'TeamChatMessage',\n 14360: 'TeamPostAdMessage',\n 14361: 'TeamMemberStatusMessage',\n 14362: 'TeamSetEventMessage',\n 14363: 'TeamSetLocationMessage',\n 14364: 'TeamReportChatMessage',\n 14365: 'TeamInviteMessage',\n 14366: 'PlayerStatusMessage',\n 14367: 'TeamClearInviteMessage',\n 14368: 'TeamInviteResponseMessage',\n 14369: 'TeamPremadeChatMessage',\n 14370: 'TeamAllianceMemberInviteMessage',\n 14371: 'TeamJoinOrCreateGameRoomMessage',\n 14372: 'TeamToggleSettingsMessage',\n 14373: 'TeamBotSlotDisableMessage',\n 14403: 'GetLeaderboardMessage',\n 14405: 'AskForAvatarStreamMessage',\n 14406: 'AskForBattleReplayStreamMessage',\n 14418: 'RemoveAvatarStreamEntryMessage',\n 14469: 'AlliancePremadeChatMessage',\n 14479: 'TeamInvitationResponseMessage',\n 14600: 'AvatarNameCheckRequestMessage',\n 14700: 'ListBrawlTvChannelsMessage',\n 14701: 'TuneBrawlTvChannelMessage',\n 14715: 'SendGlobalChatLineMessage',\n 14777: 'SetInvitesBlockedMessage',\n 14778: 'SetTeamChatMutedMessage',\n 14867: 'SetRegionMessage',\n 14880: 'TeamRequestJoinCancelMessage',\n 14881: 'TeamRequestJoinMessage',\n 14882: 'TeamRequestJoinApproveMessage',\n 15081: GetPlayerProfileMessage, #v50\n 15793: 'GetTokenFriendMessage',\n 16000: 'LogicDeviceLinkCodeRequestMessage',\n 16001: 'LogicDeviceLinkMenuClosedMessage',\n 16002: 'LogicDeviceLinkEnterCodeMessage',\n 16003: 'LogicDeviceLinkConfirmYesMessage',\n 16939: 'AskApiTokenMessage',\n 17000: 'LogicAccountTransferCodeRequestMessage',\n 17190: 'JoinAllianceUsingTokenMessage',\n 17337: 'UnbotifyReportMessage',\n 17338: 'AdjustPackageMessage',\n 17750: GoHomeFromOfflinePractiseMessage, #v50\n 18686: 'SetSupportedCreatorMessage',\n 19001: 'LatencyTestResultMessage',\n 19002: 'UdpLatencyTestRequestMessage',\n 19003: 'TriggerStartLatencyTestMessage',\n 19004: 'RequestLatencyTestStatusMessage',\n 20000: 'SetEncryptionMessage',\n 20100: ServerHelloMessage,\n 20101: 'CreateAccountOkMessage',\n 20103: LoginFailedMessage,\n 20104: LoginOkMessage,\n 20105: 'FriendListMessage',\n 20106: 'FriendListUpdateMessage',\n 20107: 'AddableFriendsMessage',\n 20108: KeepAliveServerMessage,\n 20109: 'FriendOnlineStatusMessage',\n 20110: 'FriendLoggedInMessage',\n 20111: 'FriendLoggedOutMessage',\n 20112: 'AddFriendFailedMessage',\n 20117: 'ReportUserStatusMessage',\n 20118: 'ChatAccountBanStatusMessage',\n 20121: 'BillingRequestFailedMessage',\n 20132: 'UnlockAccountOkMessage',\n 20133: 'UnlockAccountFailedMessage',\n 20151: 'AppleBillingProcessedByServerMessage',\n 20152: 'GoogleBillingProcessedByServerMessage',\n 20153: 'TencentBillingProcessedByServerMessage',\n 20154: 'CafeBazaarBillingProcessedByServerMessage',\n 20156: 'KunlunBillingProcessedByServerMessage',\n 20161: 'ShutdownStartedMessage',\n 20171: 'PersonalBreakStartedMessage',\n 20173: 'YoozooBillingProcessedByServerMessage',\n 20199: 'FriendSuggestionsMessage',\n 20205: 'AvatarNameChangeFailedMessage',\n 20206: 'AvatarOnlineStatusUpdated',\n 20207: 'AllianceOnlineStatusUpdatedMessage',\n 20300: 'AvatarNameCheckResponseMessage',\n 20402: 'CreateGameFailedMessage',\n 20405: 'MatchMakingStatusMessage',\n 20406: 'MatchMakingCancelledMessage',\n 20501: 'AcceptFriendFailedMessage',\n 20523: 'YoozooOrderAvailableMessage',\n 20545: 'YoozooOrderDeliveryFailedMessage',\n 20559: 'StartLoadingMessage',\n 20801: 'NotificationMessage',\n 20802: 'OpponentRejoinsMatchNotificationMessage',\n 20931: 'AntiAddictionDataUpdatedMessage',\n 22089: 'GetTokenFriendResultMessage',\n 22100: 'CreatePlayerMapResponseMessage',\n 22101: 'DeletePlayerMapResponseMessage',\n 22102: 'PlayerMapsMessage',\n 22103: 'UpdatePlayerMapResponseMessage',\n 22104: 'SubmitPlayerMapResponseMessage',\n 22105: 'PublishPlayerMapResponseMessage',\n 22106: 'ChangePlayerMapNameMResponseMessage',\n 22107: 'PlayerMapInfoUpdatedMessage',\n 22109: 'DebugPlayerMapReviewResultOverrideSetMessage',\n 22111: 'PlayerMapGreenlightedMessage',\n 22125: 'ReportPlayerMapResponseMessage',\n 22150: 'RankedMatchStartMessage',\n 22151: 'RankedMatchBanStartedMessage',\n 22152: 'RankedMatchBanHeroResponseMessage',\n 22153: 'RankedMatchBanEndedMessage',\n 22154: 'RankedMatchPickStartedMessage',\n 22155: 'RankedMatchPickHeroFailedMessage',\n 22156: 'RankedMatchHeroPickedMessage',\n 22157: 'RankedMatchHeroDataUpdatedMessage',\n 22158: 'RankedMatchFinalPreparationStartedMessage',\n 22159: 'RankedMatchTerminatedMessage',\n 22202: 'MapPreviewMessage',\n 22377: 'GoogleServiceAccountBoundMessage',\n 22687: 'GamecenterAccountAlreadyBoundMessage',\n 22957: 'PvpMatchmakeNotificationMessage',\n 23067: 'SCIDLogoutAllDevicesResultMessage',\n 23302: 'GetAllianceInviteTokenResultMessage',\n 23456: BattleEndMessage,\n 23457: LobbyInfoMessage,\n 23458: 'BattleLogMessage',\n 23459: 'BattleLogReplayAvailableMessage',\n 23494: 'GoogleServiceAccountAlreadyBoundMessage',\n 23774: 'PlayerJWTokenMessage',\n 24101: OwnHomeDataMessage,\n 24104: OutOfSyncMessage,\n 24105: 'SpectacleFailedMessage',\n 24106: 'StopHomeLogicMessage',\n 24108: 'MatchmakeFailedMessage',\n 24109: 'VisionUpdateMessage',\n 24111: AvailableServerCommandMessage,\n 24112: 'UdpConnectionInfoMessage',\n 24113: PlayerProfileMessage,\n 24114: 'HomeBattleReplayDataMessage',\n 24115: 'ServerErrorMessage',\n 24116: 'HomeBattleReplayFailedMessage',\n 24117: 'HomeBattleReplayViewedMessage',\n 24123: 'SeasonRewardsMessage',\n 24124: 'TeamMessage',\n 24125: 'TeamLeftMessage',\n 24129: 'TeamErrorMessage',\n 24130: 'TeamGameStartingMessage',\n 24131: 'TeamStreamMessage',\n 24177: 'SetRegionResponseMessage',\n 24178: 'SetCountryResponseMessage',\n 24199: 'LookForGameRoomRequestMessage',\n 24201: 'FacebookAccountBoundMessage',\n 24202: 'FacebookAccountAlreadyBoundMessage',\n 24203: 'KakaoAccountBoundMessage',\n 24204: 'KakaoAccountAlreadyBoundMessage',\n 24205: 'LineAccountAlreadyBoundMessage',\n 24206: 'LineAccountBoundMessage',\n 24214: 'FacebookAccountUnboundMessage',\n 24215: 'KakaoAccountUnboundMessage',\n 24216: 'LineAccountUnboundMessage',\n 24220: 'TencentAccountBoundMessage',\n 24221: 'TencentAccountAlreadyBoundMessage',\n 24223: 'tencentCheckCanPayResponseMessage',"},"next_line":{"kind":"string","value":" 24301: AllianceDataMessage,"},"gold_snippet_index":{"kind":"number","value":21,"string":"21"},"created_at":{"kind":"string","value":"2023-12-14 18:57:56+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5979,"cells":{"repo_name":{"kind":"string","value":"GXNU-ZhongLab/ODTrack"},"file_path":{"kind":"string","value":"lib/train/base_functions.py"},"context":{"kind":"list like","value":[{"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, Hexin Bai, Yong Xu, Chunyuan Liao and Haibin Ling\n CVPR, 2019\n https://arxiv.org/pdf/1809.07845.pdf\n\n Download the dataset from https://cis.temple.edu/lasot/download.html\n \"\"\"\n\n def __init__(self, root=None, image_loader=jpeg4py_loader, vid_ids=None, split=None, data_fraction=None):\n \"\"\"\n args:\n root - path to the lasot dataset.\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\n is used by default.\n vid_ids - List containing the ids of the videos (1 - 20) used for training. If vid_ids = [1, 3, 5], then the\n videos with subscripts -1, -3, and -5 from each class will be used for training.\n split - If split='train', the official train split (protocol-II) is used for training. Note: Only one of\n vid_ids or split option can be used at a time.\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\n \"\"\"\n root = env_settings().lasot_dir if root is None else root\n super().__init__('LaSOT', root, image_loader)\n\n # Keep a list of all classes\n self.class_list = [f for f in os.listdir(self.root)]\n self.class_to_id = {cls_name: cls_id for cls_id, cls_name in enumerate(self.class_list)}\n\n self.sequence_list = self._build_sequence_list(vid_ids, split)\n\n if data_fraction is not None:\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\n\n self.seq_per_class = self._build_class_list()\n\n def _build_sequence_list(self, vid_ids=None, split=None):\n if split is not None:\n if vid_ids is not None:\n raise ValueError('Cannot set both split_name and vid_ids.')\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\n if split == 'train':\n file_path = os.path.join(ltr_path, 'data_specs', 'lasot_train_split.txt')\n else:\n raise ValueError('Unknown split name.')\n # sequence_list = pandas.read_csv(file_path, header=None, squeeze=True).values.tolist()\n sequence_list = pandas.read_csv(file_path, header=None).squeeze(\"columns\").values.tolist()\n elif vid_ids is not None:\n sequence_list = [c+'-'+str(v) for c in self.class_list for v in vid_ids]\n else:\n raise ValueError('Set either split_name or vid_ids.')\n\n return sequence_list\n\n def _build_class_list(self):\n seq_per_class = {}\n for seq_id, seq_name in enumerate(self.sequence_list):\n class_name = seq_name.split('-')[0]\n if class_name in seq_per_class:\n seq_per_class[class_name].append(seq_id)\n else:\n seq_per_class[class_name] = [seq_id]\n\n return seq_per_class\n\n def get_name(self):\n return 'lasot'\n\n def has_class_info(self):\n return True\n\n def has_occlusion_info(self):\n return True\n\n def get_num_sequences(self):\n return len(self.sequence_list)\n\n def get_num_classes(self):\n return len(self.class_list)\n\n def get_sequences_in_class(self, class_name):\n return self.seq_per_class[class_name]\n\n def _read_bb_anno(self, seq_path):\n bb_anno_file = os.path.join(seq_path, \"groundtruth.txt\")\n gt = pandas.read_csv(bb_anno_file, delimiter=',', header=None, dtype=np.float32, na_filter=False, low_memory=False).values\n return torch.tensor(gt)\n\n def _read_target_visible(self, seq_path):\n # Read full occlusion and out_of_view\n occlusion_file = os.path.join(seq_path, \"full_occlusion.txt\")\n out_of_view_file = os.path.join(seq_path, \"out_of_view.txt\")\n\n with open(occlusion_file, 'r', newline='') as f:\n occlusion = torch.ByteTensor([int(v) for v in list(csv.reader(f))[0]])\n with open(out_of_view_file, 'r') as f:\n out_of_view = torch.ByteTensor([int(v) for v in list(csv.reader(f))[0]])\n\n target_visible = ~occlusion & ~out_of_view\n\n return target_visible\n\n def _get_sequence_path(self, seq_id):\n seq_name = self.sequence_list[seq_id]\n class_name = seq_name.split('-')[0]\n vid_id = seq_name.split('-')[1]\n\n return os.path.join(self.root, class_name, class_name + '-' + vid_id)\n\n def get_sequence_info(self, seq_id):\n seq_path = self._get_sequence_path(seq_id)\n bbox = self._read_bb_anno(seq_path)\n\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\n visible = self._read_target_visible(seq_path) & valid.byte()\n\n return {'bbox': bbox, 'valid': valid, 'visible': visible}\n\n def _get_frame_path(self, seq_path, frame_id):\n return os.path.join(seq_path, 'img', '{:08}.jpg'.format(frame_id+1)) # frames start from 1\n\n def _get_frame(self, seq_path, frame_id):\n return self.image_loader(self._get_frame_path(seq_path, frame_id))\n\n def _get_class(self, seq_path):\n raw_class = seq_path.split('/')[-2]\n return raw_class\n\n def get_class_name(self, seq_id):\n seq_path = self._get_sequence_path(seq_id)\n obj_class = self._get_class(seq_path)\n\n return obj_class\n\n def get_frames(self, seq_id, frame_ids, anno=None):\n seq_path = self._get_sequence_path(seq_id)\n\n obj_class = self._get_class(seq_path)\n frame_list = [self._get_frame(seq_path, f_id) for f_id in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\n\n object_meta = OrderedDict({'object_class_name': obj_class,\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n\n return frame_list, anno_frames, object_meta"},{"identifier":"Got10k","path":"lib/train/dataset/got10k.py","snippet":"class Got10k(BaseVideoDataset):\n \"\"\" GOT-10k dataset.\n\n Publication:\n GOT-10k: A Large High-Diversity Benchmark for Generic Object Tracking in the Wild\n Lianghua Huang, Xin Zhao, and Kaiqi Huang\n arXiv:1810.11981, 2018\n https://arxiv.org/pdf/1810.11981.pdf\n\n Download dataset from http://got-10k.aitestunion.com/downloads\n \"\"\"\n\n def __init__(self, root=None, image_loader=jpeg4py_loader, split=None, seq_ids=None, data_fraction=None):\n \"\"\"\n args:\n root - path to the got-10k training data. Note: This should point to the 'train' folder inside GOT-10k\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\n is used by default.\n split - 'train' or 'val'. Note: The validation split here is a subset of the official got-10k train split,\n not NOT the official got-10k validation split. To use the official validation split, provide that as\n the root folder instead.\n seq_ids - List containing the ids of the videos to be used for training. Note: Only one of 'split' or 'seq_ids'\n options can be used at the same time.\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\n \"\"\"\n root = env_settings().got10k_dir if root is None else root\n super().__init__('GOT10k', root, image_loader)\n\n # all folders inside the root\n self.sequence_list = self._get_sequence_list()\n\n # seq_id is the index of the folder inside the got10k root path\n if split is not None:\n if seq_ids is not None:\n raise ValueError('Cannot set both split_name and seq_ids.')\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\n if split == 'train':\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_train_split.txt')\n elif split == 'val':\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_val_split.txt')\n elif split == 'train_full':\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_train_full_split.txt')\n elif split == 'vottrain':\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_vot_train_split.txt')\n elif split == 'votval':\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_vot_val_split.txt')\n else:\n raise ValueError('Unknown split name.')\n # seq_ids = pandas.read_csv(file_path, header=None, squeeze=True, dtype=np.int64).values.tolist()\n seq_ids = pandas.read_csv(file_path, header=None, dtype=np.int64).squeeze(\"columns\").values.tolist()\n elif seq_ids is None:\n seq_ids = list(range(0, len(self.sequence_list)))\n\n self.sequence_list = [self.sequence_list[i] for i in seq_ids]\n\n if data_fraction is not None:\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\n\n self.sequence_meta_info = self._load_meta_info()\n self.seq_per_class = self._build_seq_per_class()\n\n self.class_list = list(self.seq_per_class.keys())\n self.class_list.sort()\n\n def get_name(self):\n return 'got10k'\n\n def has_class_info(self):\n return True\n\n def has_occlusion_info(self):\n return True\n\n def _load_meta_info(self):\n sequence_meta_info = {s: self._read_meta(os.path.join(self.root, s)) for s in self.sequence_list}\n return sequence_meta_info\n\n def _read_meta(self, seq_path):\n try:\n with open(os.path.join(seq_path, 'meta_info.ini')) as f:\n meta_info = f.readlines()\n object_meta = OrderedDict({'object_class_name': meta_info[5].split(': ')[-1][:-1],\n 'motion_class': meta_info[6].split(': ')[-1][:-1],\n 'major_class': meta_info[7].split(': ')[-1][:-1],\n 'root_class': meta_info[8].split(': ')[-1][:-1],\n 'motion_adverb': meta_info[9].split(': ')[-1][:-1]})\n except:\n object_meta = OrderedDict({'object_class_name': None,\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n return object_meta\n\n def _build_seq_per_class(self):\n seq_per_class = {}\n\n for i, s in enumerate(self.sequence_list):\n object_class = self.sequence_meta_info[s]['object_class_name']\n if object_class in seq_per_class:\n seq_per_class[object_class].append(i)\n else:\n seq_per_class[object_class] = [i]\n\n return seq_per_class\n\n def get_sequences_in_class(self, class_name):\n return self.seq_per_class[class_name]\n\n def _get_sequence_list(self):\n with open(os.path.join(self.root, 'list.txt')) as f:\n dir_list = list(csv.reader(f))\n dir_list = [dir_name[0] for dir_name in dir_list]\n return dir_list\n\n def _read_bb_anno(self, seq_path):\n bb_anno_file = os.path.join(seq_path, \"groundtruth.txt\")\n gt = pandas.read_csv(bb_anno_file, delimiter=',', header=None, dtype=np.float32, na_filter=False, low_memory=False).values\n return torch.tensor(gt)\n\n def _read_target_visible(self, seq_path):\n # Read full occlusion and out_of_view\n occlusion_file = os.path.join(seq_path, \"absence.label\")\n cover_file = os.path.join(seq_path, \"cover.label\")\n\n with open(occlusion_file, 'r', newline='') as f:\n occlusion = torch.ByteTensor([int(v[0]) for v in csv.reader(f)])\n with open(cover_file, 'r', newline='') as f:\n cover = torch.ByteTensor([int(v[0]) for v in csv.reader(f)])\n\n target_visible = ~occlusion & (cover>0).byte()\n\n visible_ratio = cover.float() / 8\n return target_visible, visible_ratio\n\n def _get_sequence_path(self, seq_id):\n return os.path.join(self.root, self.sequence_list[seq_id])\n\n def get_sequence_info(self, seq_id):\n seq_path = self._get_sequence_path(seq_id)\n bbox = self._read_bb_anno(seq_path)\n\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\n visible, visible_ratio = self._read_target_visible(seq_path)\n visible = visible & valid.byte()\n\n return {'bbox': bbox, 'valid': valid, 'visible': visible, 'visible_ratio': visible_ratio}\n\n def _get_frame_path(self, seq_path, frame_id):\n return os.path.join(seq_path, '{:08}.jpg'.format(frame_id+1)) # frames start from 1\n\n def _get_frame(self, seq_path, frame_id):\n return self.image_loader(self._get_frame_path(seq_path, frame_id))\n\n def get_class_name(self, seq_id):\n obj_meta = self.sequence_meta_info[self.sequence_list[seq_id]]\n\n return obj_meta['object_class_name']\n\n def get_frames(self, seq_id, frame_ids, anno=None):\n seq_path = self._get_sequence_path(seq_id)\n obj_meta = self.sequence_meta_info[self.sequence_list[seq_id]]\n\n frame_list = [self._get_frame(seq_path, f_id) for f_id in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\n\n return frame_list, anno_frames, obj_meta"},{"identifier":"TrackingNet","path":"lib/train/dataset/tracking_net.py","snippet":"class TrackingNet(BaseVideoDataset):\n \"\"\" TrackingNet dataset.\n\n Publication:\n TrackingNet: A Large-Scale Dataset and Benchmark for Object Tracking in the Wild.\n Matthias Mueller,Adel Bibi, Silvio Giancola, Salman Al-Subaihi and Bernard Ghanem\n ECCV, 2018\n https://ivul.kaust.edu.sa/Documents/Publications/2018/TrackingNet%20A%20Large%20Scale%20Dataset%20and%20Benchmark%20for%20Object%20Tracking%20in%20the%20Wild.pdf\n\n Download the dataset using the toolkit https://github.com/SilvioGiancola/TrackingNet-devkit.\n \"\"\"\n def __init__(self, root=None, image_loader=jpeg4py_loader, set_ids=None, data_fraction=None):\n \"\"\"\n args:\n root - The path to the TrackingNet folder, containing the training sets.\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\n is used by default.\n set_ids (None) - List containing the ids of the TrackingNet sets to be used for training. If None, all the\n sets (0 - 11) will be used.\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\n \"\"\"\n root = env_settings().trackingnet_dir if root is None else root\n super().__init__('TrackingNet', root, image_loader)\n\n if set_ids is None:\n set_ids = [i for i in range(12)]\n\n self.set_ids = set_ids\n\n # Keep a list of all videos. Sequence list is a list of tuples (set_id, video_name) containing the set_id and\n # video_name for each sequence\n self.sequence_list = list_sequences(self.root, self.set_ids)\n\n if data_fraction is not None:\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list) * data_fraction))\n\n self.seq_to_class_map, self.seq_per_class = self._load_class_info()\n\n # we do not have the class_lists for the tracking net\n self.class_list = list(self.seq_per_class.keys())\n self.class_list.sort()\n\n def _load_class_info(self):\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\n class_map_path = os.path.join(ltr_path, 'data_specs', 'trackingnet_classmap.txt')\n\n with open(class_map_path, 'r') as f:\n seq_to_class_map = {seq_class.split('\\t')[0]: seq_class.rstrip().split('\\t')[1] for seq_class in f}\n\n seq_per_class = {}\n for i, seq in enumerate(self.sequence_list):\n class_name = seq_to_class_map.get(seq[1], 'Unknown')\n if class_name not in seq_per_class:\n seq_per_class[class_name] = [i]\n else:\n seq_per_class[class_name].append(i)\n\n return seq_to_class_map, seq_per_class\n\n def get_name(self):\n return 'trackingnet'\n\n def has_class_info(self):\n return True\n\n def get_sequences_in_class(self, class_name):\n return self.seq_per_class[class_name]\n\n def _read_bb_anno(self, seq_id):\n set_id = self.sequence_list[seq_id][0]\n vid_name = self.sequence_list[seq_id][1]\n bb_anno_file = os.path.join(self.root, \"TRAIN_\" + str(set_id), \"anno\", vid_name + \".txt\")\n gt = pandas.read_csv(bb_anno_file, delimiter=',', header=None, dtype=np.float32, na_filter=False,\n low_memory=False).values\n return torch.tensor(gt)\n\n def get_sequence_info(self, seq_id):\n bbox = self._read_bb_anno(seq_id)\n\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\n visible = valid.clone().byte()\n return {'bbox': bbox, 'valid': valid, 'visible': visible}\n\n def _get_frame(self, seq_id, frame_id):\n set_id = self.sequence_list[seq_id][0]\n vid_name = self.sequence_list[seq_id][1]\n frame_path = os.path.join(self.root, \"TRAIN_\" + str(set_id), \"frames\", vid_name, str(frame_id) + \".jpg\")\n return self.image_loader(frame_path)\n\n def _get_class(self, seq_id):\n seq_name = self.sequence_list[seq_id][1]\n return self.seq_to_class_map[seq_name]\n\n def get_class_name(self, seq_id):\n obj_class = self._get_class(seq_id)\n\n return obj_class\n\n def get_frames(self, seq_id, frame_ids, anno=None):\n frame_list = [self._get_frame(seq_id, f) for f in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\n\n obj_class = self._get_class(seq_id)\n\n object_meta = OrderedDict({'object_class_name': obj_class,\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n\n return frame_list, anno_frames, object_meta"},{"identifier":"ImagenetVID","path":"lib/train/dataset/imagenetvid.py","snippet":"class ImagenetVID(BaseVideoDataset):\n \"\"\" Imagenet VID dataset.\n\n Publication:\n ImageNet Large Scale Visual Recognition Challenge\n Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy,\n Aditya Khosla, Michael Bernstein, Alexander C. Berg and Li Fei-Fei\n IJCV, 2015\n https://arxiv.org/pdf/1409.0575.pdf\n\n Download the dataset from http://image-net.org/\n \"\"\"\n def __init__(self, root=None, image_loader=jpeg4py_loader, min_length=0, max_target_area=1):\n \"\"\"\n args:\n root - path to the imagenet vid dataset.\n image_loader (default_image_loader) - The function to read the images. If installed,\n jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,\n opencv's imread is used.\n min_length - Minimum allowed sequence length.\n max_target_area - max allowed ratio between target area and image area. Can be used to filter out targets\n which cover complete image.\n \"\"\"\n root = env_settings().imagenet_dir if root is None else root\n super().__init__(\"imagenetvid\", root, image_loader)\n\n cache_file = os.path.join(root, 'cache.json')\n if os.path.isfile(cache_file):\n # If available, load the pre-processed cache file containing meta-info for each sequence\n with open(cache_file, 'r') as f:\n sequence_list_dict = json.load(f)\n\n self.sequence_list = sequence_list_dict\n else:\n # Else process the imagenet annotations and generate the cache file\n self.sequence_list = self._process_anno(root)\n\n with open(cache_file, 'w') as f:\n json.dump(self.sequence_list, f)\n\n # Filter the sequences based on min_length and max_target_area in the first frame\n self.sequence_list = [x for x in self.sequence_list if len(x['anno']) >= min_length and\n get_target_to_image_ratio(x) < max_target_area]\n\n def get_name(self):\n return 'imagenetvid'\n\n def get_num_sequences(self):\n return len(self.sequence_list)\n\n def get_sequence_info(self, seq_id):\n bb_anno = torch.Tensor(self.sequence_list[seq_id]['anno'])\n valid = (bb_anno[:, 2] > 0) & (bb_anno[:, 3] > 0)\n visible = torch.ByteTensor(self.sequence_list[seq_id]['target_visible']) & valid.byte()\n return {'bbox': bb_anno, 'valid': valid, 'visible': visible}\n\n def _get_frame(self, sequence, frame_id):\n set_name = 'ILSVRC2015_VID_train_{:04d}'.format(sequence['set_id'])\n vid_name = 'ILSVRC2015_train_{:08d}'.format(sequence['vid_id'])\n frame_number = frame_id + sequence['start_frame']\n frame_path = os.path.join(self.root, 'Data', 'VID', 'train', set_name, vid_name,\n '{:06d}.JPEG'.format(frame_number))\n return self.image_loader(frame_path)\n\n def get_frames(self, seq_id, frame_ids, anno=None):\n sequence = self.sequence_list[seq_id]\n\n frame_list = [self._get_frame(sequence, f) for f in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n # Create anno dict\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\n\n # added the class info to the meta info\n object_meta = OrderedDict({'object_class': sequence['class_name'],\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n\n return frame_list, anno_frames, object_meta\n\n def _process_anno(self, root):\n # Builds individual tracklets\n base_vid_anno_path = os.path.join(root, 'Annotations', 'VID', 'train')\n\n all_sequences = []\n for set in sorted(os.listdir(base_vid_anno_path)):\n set_id = int(set.split('_')[-1])\n for vid in sorted(os.listdir(os.path.join(base_vid_anno_path, set))):\n\n vid_id = int(vid.split('_')[-1])\n anno_files = sorted(os.listdir(os.path.join(base_vid_anno_path, set, vid)))\n\n frame1_anno = ET.parse(os.path.join(base_vid_anno_path, set, vid, anno_files[0]))\n image_size = [int(frame1_anno.find('size/width').text), int(frame1_anno.find('size/height').text)]\n\n objects = [ET.ElementTree(file=os.path.join(base_vid_anno_path, set, vid, f)).findall('object')\n for f in anno_files]\n\n tracklets = {}\n\n # Find all tracklets along with start frame\n for f_id, all_targets in enumerate(objects):\n for target in all_targets:\n tracklet_id = target.find('trackid').text\n if tracklet_id not in tracklets:\n tracklets[tracklet_id] = f_id\n\n for tracklet_id, tracklet_start in tracklets.items():\n tracklet_anno = []\n target_visible = []\n class_name_id = None\n\n for f_id in range(tracklet_start, len(objects)):\n found = False\n for target in objects[f_id]:\n if target.find('trackid').text == tracklet_id:\n if not class_name_id:\n class_name_id = target.find('name').text\n x1 = int(target.find('bndbox/xmin').text)\n y1 = int(target.find('bndbox/ymin').text)\n x2 = int(target.find('bndbox/xmax').text)\n y2 = int(target.find('bndbox/ymax').text)\n\n tracklet_anno.append([x1, y1, x2 - x1, y2 - y1])\n target_visible.append(target.find('occluded').text == '0')\n\n found = True\n break\n if not found:\n break\n\n new_sequence = {'set_id': set_id, 'vid_id': vid_id, 'class_name': class_name_id,\n 'start_frame': tracklet_start, 'anno': tracklet_anno,\n 'target_visible': target_visible, 'image_size': image_size}\n all_sequences.append(new_sequence)\n\n return all_sequences"},{"identifier":"MSCOCOSeq","path":"lib/train/dataset/coco_seq.py","snippet":"class MSCOCOSeq(BaseVideoDataset):\n \"\"\" The COCO dataset. COCO is an image dataset. Thus, we treat each image as a sequence of length 1.\n\n Publication:\n Microsoft COCO: Common Objects in Context.\n Tsung-Yi Lin, Michael Maire, Serge J. Belongie, Lubomir D. Bourdev, Ross B. Girshick, James Hays, Pietro Perona,\n Deva Ramanan, Piotr Dollar and C. Lawrence Zitnick\n ECCV, 2014\n https://arxiv.org/pdf/1405.0312.pdf\n\n Download the images along with annotations from http://cocodataset.org/#download. The root folder should be\n organized as follows.\n - coco_root\n - annotations\n - instances_train2014.json\n - instances_train2017.json\n - images\n - train2014\n - train2017\n\n Note: You also have to install the coco pythonAPI from https://github.com/cocodataset/cocoapi.\n \"\"\"\n\n def __init__(self, root=None, image_loader=jpeg4py_loader, data_fraction=None, split=\"train\", version=\"2014\"):\n \"\"\"\n args:\n root - path to the coco dataset.\n image_loader (default_image_loader) - The function to read the images. If installed,\n jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,\n opencv's imread is used.\n data_fraction (None) - Fraction of images to be used. The images are selected randomly. If None, all the\n images will be used\n split - 'train' or 'val'.\n version - version of coco dataset (2014 or 2017)\n \"\"\"\n root = env_settings().coco_dir if root is None else root\n super().__init__('COCO', root, image_loader)\n\n self.img_pth = os.path.join(root, 'images/{}{}/'.format(split, version))\n self.anno_path = os.path.join(root, 'annotations/instances_{}{}.json'.format(split, version))\n\n # Load the COCO set.\n self.coco_set = COCO(self.anno_path)\n\n self.cats = self.coco_set.cats\n\n self.class_list = self.get_class_list()\n\n self.sequence_list = self._get_sequence_list()\n\n if data_fraction is not None:\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\n self.seq_per_class = self._build_seq_per_class()\n\n def _get_sequence_list(self):\n ann_list = list(self.coco_set.anns.keys())\n seq_list = [a for a in ann_list if self.coco_set.anns[a]['iscrowd'] == 0]\n\n return seq_list\n\n def is_video_sequence(self):\n return False\n\n def get_num_classes(self):\n return len(self.class_list)\n\n def get_name(self):\n return 'coco'\n\n def has_class_info(self):\n return True\n\n def get_class_list(self):\n class_list = []\n for cat_id in self.cats.keys():\n class_list.append(self.cats[cat_id]['name'])\n return class_list\n\n def has_segmentation_info(self):\n return True\n\n def get_num_sequences(self):\n return len(self.sequence_list)\n\n def _build_seq_per_class(self):\n seq_per_class = {}\n for i, seq in enumerate(self.sequence_list):\n class_name = self.cats[self.coco_set.anns[seq]['category_id']]['name']\n if class_name not in seq_per_class:\n seq_per_class[class_name] = [i]\n else:\n seq_per_class[class_name].append(i)\n\n return seq_per_class\n\n def get_sequences_in_class(self, class_name):\n return self.seq_per_class[class_name]\n\n def get_sequence_info(self, seq_id):\n anno = self._get_anno(seq_id)\n\n bbox = torch.Tensor(anno['bbox']).view(1, 4)\n\n mask = torch.Tensor(self.coco_set.annToMask(anno)).unsqueeze(dim=0)\n\n '''2021.1.3 To avoid too small bounding boxes. Here we change the threshold to 50 pixels'''\n valid = (bbox[:, 2] > 50) & (bbox[:, 3] > 50)\n\n visible = valid.clone().byte()\n\n return {'bbox': bbox, 'mask': mask, 'valid': valid, 'visible': visible}\n\n def _get_anno(self, seq_id):\n anno = self.coco_set.anns[self.sequence_list[seq_id]]\n\n return anno\n\n def _get_frames(self, seq_id):\n path = self.coco_set.loadImgs([self.coco_set.anns[self.sequence_list[seq_id]]['image_id']])[0]['file_name']\n img = self.image_loader(os.path.join(self.img_pth, path))\n return img\n\n def get_meta_info(self, seq_id):\n try:\n cat_dict_current = self.cats[self.coco_set.anns[self.sequence_list[seq_id]]['category_id']]\n object_meta = OrderedDict({'object_class_name': cat_dict_current['name'],\n 'motion_class': None,\n 'major_class': cat_dict_current['supercategory'],\n 'root_class': None,\n 'motion_adverb': None})\n except:\n object_meta = OrderedDict({'object_class_name': None,\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n return object_meta\n\n\n def get_class_name(self, seq_id):\n cat_dict_current = self.cats[self.coco_set.anns[self.sequence_list[seq_id]]['category_id']]\n return cat_dict_current['name']\n\n def get_frames(self, seq_id=None, frame_ids=None, anno=None):\n # COCO is an image dataset. Thus we replicate the image denoted by seq_id len(frame_ids) times, and return a\n # list containing these replicated images.\n frame = self._get_frames(seq_id)\n\n frame_list = [frame.copy() for _ in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[0, ...] for _ in frame_ids]\n\n object_meta = self.get_meta_info(seq_id)\n\n return frame_list, anno_frames, object_meta"},{"identifier":"Got10k_lmdb","path":"lib/train/dataset/got10k_lmdb.py","snippet":"class Got10k_lmdb(BaseVideoDataset):\n\n def __init__(self, root=None, image_loader=jpeg4py_loader, split=None, seq_ids=None, data_fraction=None):\n \"\"\"\n args:\n root - path to the got-10k training data. Note: This should point to the 'train' folder inside GOT-10k\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\n is used by default.\n split - 'train' or 'val'. Note: The validation split here is a subset of the official got-10k train split,\n not NOT the official got-10k validation split. To use the official validation split, provide that as\n the root folder instead.\n seq_ids - List containing the ids of the videos to be used for training. Note: Only one of 'split' or 'seq_ids'\n options can be used at the same time.\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\n use_lmdb - whether the dataset is stored in lmdb format\n \"\"\"\n root = env_settings().got10k_lmdb_dir if root is None else root\n super().__init__('GOT10k_lmdb', root, image_loader)\n\n # all folders inside the root\n self.sequence_list = self._get_sequence_list()\n\n # seq_id is the index of the folder inside the got10k root path\n if split is not None:\n if seq_ids is not None:\n raise ValueError('Cannot set both split_name and seq_ids.')\n train_lib_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\n if split == 'train':\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_train_split.txt')\n elif split == 'val':\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_val_split.txt')\n elif split == 'train_full':\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_train_full_split.txt')\n elif split == 'vottrain':\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_vot_train_split.txt')\n elif split == 'votval':\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_vot_val_split.txt')\n else:\n raise ValueError('Unknown split name.')\n seq_ids = pandas.read_csv(file_path, header=None, squeeze=True, dtype=np.int64).values.tolist()\n elif seq_ids is None:\n seq_ids = list(range(0, len(self.sequence_list)))\n\n self.sequence_list = [self.sequence_list[i] for i in seq_ids]\n\n if data_fraction is not None:\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\n\n self.sequence_meta_info = self._load_meta_info()\n self.seq_per_class = self._build_seq_per_class()\n\n self.class_list = list(self.seq_per_class.keys())\n self.class_list.sort()\n\n def get_name(self):\n return 'got10k_lmdb'\n\n def has_class_info(self):\n return True\n\n def has_occlusion_info(self):\n return True\n\n def _load_meta_info(self):\n def _read_meta(meta_info):\n\n object_meta = OrderedDict({'object_class_name': meta_info[5].split(': ')[-1],\n 'motion_class': meta_info[6].split(': ')[-1],\n 'major_class': meta_info[7].split(': ')[-1],\n 'root_class': meta_info[8].split(': ')[-1],\n 'motion_adverb': meta_info[9].split(': ')[-1]})\n\n return object_meta\n sequence_meta_info = {}\n for s in self.sequence_list:\n try:\n meta_str = decode_str(self.root, \"train/%s/meta_info.ini\" %s)\n sequence_meta_info[s] = _read_meta(meta_str.split('\\n'))\n except:\n sequence_meta_info[s] = OrderedDict({'object_class_name': None,\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n return sequence_meta_info\n\n def _build_seq_per_class(self):\n seq_per_class = {}\n\n for i, s in enumerate(self.sequence_list):\n object_class = self.sequence_meta_info[s]['object_class_name']\n if object_class in seq_per_class:\n seq_per_class[object_class].append(i)\n else:\n seq_per_class[object_class] = [i]\n\n return seq_per_class\n\n def get_sequences_in_class(self, class_name):\n return self.seq_per_class[class_name]\n\n def _get_sequence_list(self):\n dir_str = decode_str(self.root, 'train/list.txt')\n dir_list = dir_str.split('\\n')\n return dir_list\n\n def _read_bb_anno(self, seq_path):\n bb_anno_file = os.path.join(seq_path, \"groundtruth.txt\")\n gt_str_list = decode_str(self.root, bb_anno_file).split('\\n')[:-1] # the last line in got10k is empty\n gt_list = [list(map(float, line.split(','))) for line in gt_str_list]\n gt_arr = np.array(gt_list).astype(np.float32)\n\n return torch.tensor(gt_arr)\n\n def _read_target_visible(self, seq_path):\n # full occlusion and out_of_view files\n occlusion_file = os.path.join(seq_path, \"absence.label\")\n cover_file = os.path.join(seq_path, \"cover.label\")\n # Read these files\n occ_list = list(map(int, decode_str(self.root, occlusion_file).split('\\n')[:-1])) # the last line in got10k is empty\n occlusion = torch.ByteTensor(occ_list)\n cover_list = list(map(int, decode_str(self.root, cover_file).split('\\n')[:-1])) # the last line in got10k is empty\n cover = torch.ByteTensor(cover_list)\n\n target_visible = ~occlusion & (cover>0).byte()\n\n visible_ratio = cover.float() / 8\n return target_visible, visible_ratio\n\n def _get_sequence_path(self, seq_id):\n return os.path.join(\"train\", self.sequence_list[seq_id])\n\n def get_sequence_info(self, seq_id):\n seq_path = self._get_sequence_path(seq_id)\n bbox = self._read_bb_anno(seq_path)\n\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\n visible, visible_ratio = self._read_target_visible(seq_path)\n visible = visible & valid.byte()\n\n return {'bbox': bbox, 'valid': valid, 'visible': visible, 'visible_ratio': visible_ratio}\n\n def _get_frame_path(self, seq_path, frame_id):\n return os.path.join(seq_path, '{:08}.jpg'.format(frame_id+1)) # frames start from 1\n\n def _get_frame(self, seq_path, frame_id):\n return decode_img(self.root, self._get_frame_path(seq_path, frame_id))\n\n def get_class_name(self, seq_id):\n obj_meta = self.sequence_meta_info[self.sequence_list[seq_id]]\n\n return obj_meta['object_class_name']\n\n def get_frames(self, seq_id, frame_ids, anno=None):\n seq_path = self._get_sequence_path(seq_id)\n obj_meta = self.sequence_meta_info[self.sequence_list[seq_id]]\n\n frame_list = [self._get_frame(seq_path, f_id) for f_id in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\n\n return frame_list, anno_frames, obj_meta"},{"identifier":"Lasot_lmdb","path":"lib/train/dataset/lasot_lmdb.py","snippet":"class Lasot_lmdb(BaseVideoDataset):\n\n def __init__(self, root=None, image_loader=jpeg4py_loader, vid_ids=None, split=None, data_fraction=None):\n \"\"\"\n args:\n root - path to the lasot dataset.\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\n is used by default.\n vid_ids - List containing the ids of the videos (1 - 20) used for training. If vid_ids = [1, 3, 5], then the\n videos with subscripts -1, -3, and -5 from each class will be used for training.\n split - If split='train', the official train split (protocol-II) is used for training. Note: Only one of\n vid_ids or split option can be used at a time.\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\n \"\"\"\n root = env_settings().lasot_lmdb_dir if root is None else root\n super().__init__('LaSOT_lmdb', root, image_loader)\n\n self.sequence_list = self._build_sequence_list(vid_ids, split)\n class_list = [seq_name.split('-')[0] for seq_name in self.sequence_list]\n self.class_list = []\n for ele in class_list:\n if ele not in self.class_list:\n self.class_list.append(ele)\n # Keep a list of all classes\n self.class_to_id = {cls_name: cls_id for cls_id, cls_name in enumerate(self.class_list)}\n\n if data_fraction is not None:\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\n\n self.seq_per_class = self._build_class_list()\n\n def _build_sequence_list(self, vid_ids=None, split=None):\n if split is not None:\n if vid_ids is not None:\n raise ValueError('Cannot set both split_name and vid_ids.')\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\n if split == 'train':\n file_path = os.path.join(ltr_path, 'data_specs', 'lasot_train_split.txt')\n else:\n raise ValueError('Unknown split name.')\n sequence_list = pandas.read_csv(file_path, header=None, squeeze=True).values.tolist()\n elif vid_ids is not None:\n sequence_list = [c+'-'+str(v) for c in self.class_list for v in vid_ids]\n else:\n raise ValueError('Set either split_name or vid_ids.')\n\n return sequence_list\n\n def _build_class_list(self):\n seq_per_class = {}\n for seq_id, seq_name in enumerate(self.sequence_list):\n class_name = seq_name.split('-')[0]\n if class_name in seq_per_class:\n seq_per_class[class_name].append(seq_id)\n else:\n seq_per_class[class_name] = [seq_id]\n\n return seq_per_class\n\n def get_name(self):\n return 'lasot_lmdb'\n\n def has_class_info(self):\n return True\n\n def has_occlusion_info(self):\n return True\n\n def get_num_sequences(self):\n return len(self.sequence_list)\n\n def get_num_classes(self):\n return len(self.class_list)\n\n def get_sequences_in_class(self, class_name):\n return self.seq_per_class[class_name]\n\n def _read_bb_anno(self, seq_path):\n bb_anno_file = os.path.join(seq_path, \"groundtruth.txt\")\n gt_str_list = decode_str(self.root, bb_anno_file).split('\\n')[:-1] # the last line is empty\n gt_list = [list(map(float, line.split(','))) for line in gt_str_list]\n gt_arr = np.array(gt_list).astype(np.float32)\n return torch.tensor(gt_arr)\n\n def _read_target_visible(self, seq_path):\n # Read full occlusion and out_of_view\n occlusion_file = os.path.join(seq_path, \"full_occlusion.txt\")\n out_of_view_file = os.path.join(seq_path, \"out_of_view.txt\")\n\n occ_list = list(map(int, decode_str(self.root, occlusion_file).split(',')))\n occlusion = torch.ByteTensor(occ_list)\n out_view_list = list(map(int, decode_str(self.root, out_of_view_file).split(',')))\n out_of_view = torch.ByteTensor(out_view_list)\n\n target_visible = ~occlusion & ~out_of_view\n\n return target_visible\n\n def _get_sequence_path(self, seq_id):\n seq_name = self.sequence_list[seq_id]\n class_name = seq_name.split('-')[0]\n vid_id = seq_name.split('-')[1]\n\n return os.path.join(class_name, class_name + '-' + vid_id)\n\n def get_sequence_info(self, seq_id):\n seq_path = self._get_sequence_path(seq_id)\n bbox = self._read_bb_anno(seq_path)\n\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\n visible = self._read_target_visible(seq_path) & valid.byte()\n\n return {'bbox': bbox, 'valid': valid, 'visible': visible}\n\n def _get_frame_path(self, seq_path, frame_id):\n return os.path.join(seq_path, 'img', '{:08}.jpg'.format(frame_id+1)) # frames start from 1\n\n def _get_frame(self, seq_path, frame_id):\n return decode_img(self.root, self._get_frame_path(seq_path, frame_id))\n\n def _get_class(self, seq_path):\n raw_class = seq_path.split('/')[-2]\n return raw_class\n\n def get_class_name(self, seq_id):\n seq_path = self._get_sequence_path(seq_id)\n obj_class = self._get_class(seq_path)\n\n return obj_class\n\n def get_frames(self, seq_id, frame_ids, anno=None):\n seq_path = self._get_sequence_path(seq_id)\n\n obj_class = self._get_class(seq_path)\n frame_list = [self._get_frame(seq_path, f_id) for f_id in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\n\n object_meta = OrderedDict({'object_class_name': obj_class,\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n\n return frame_list, anno_frames, object_meta"},{"identifier":"ImagenetVID_lmdb","path":"lib/train/dataset/imagenetvid_lmdb.py","snippet":"class ImagenetVID_lmdb(BaseVideoDataset):\n \"\"\" Imagenet VID dataset.\n\n Publication:\n ImageNet Large Scale Visual Recognition Challenge\n Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy,\n Aditya Khosla, Michael Bernstein, Alexander C. Berg and Li Fei-Fei\n IJCV, 2015\n https://arxiv.org/pdf/1409.0575.pdf\n\n Download the dataset from http://image-net.org/\n \"\"\"\n def __init__(self, root=None, image_loader=jpeg4py_loader, min_length=0, max_target_area=1):\n \"\"\"\n args:\n root - path to the imagenet vid dataset.\n image_loader (default_image_loader) - The function to read the images. If installed,\n jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,\n opencv's imread is used.\n min_length - Minimum allowed sequence length.\n max_target_area - max allowed ratio between target area and image area. Can be used to filter out targets\n which cover complete image.\n \"\"\"\n root = env_settings().imagenet_dir if root is None else root\n super().__init__(\"imagenetvid_lmdb\", root, image_loader)\n\n sequence_list_dict = decode_json(root, \"cache.json\")\n self.sequence_list = sequence_list_dict\n\n # Filter the sequences based on min_length and max_target_area in the first frame\n self.sequence_list = [x for x in self.sequence_list if len(x['anno']) >= min_length and\n get_target_to_image_ratio(x) < max_target_area]\n\n def get_name(self):\n return 'imagenetvid_lmdb'\n\n def get_num_sequences(self):\n return len(self.sequence_list)\n\n def get_sequence_info(self, seq_id):\n bb_anno = torch.Tensor(self.sequence_list[seq_id]['anno'])\n valid = (bb_anno[:, 2] > 0) & (bb_anno[:, 3] > 0)\n visible = torch.ByteTensor(self.sequence_list[seq_id]['target_visible']) & valid.byte()\n return {'bbox': bb_anno, 'valid': valid, 'visible': visible}\n\n def _get_frame(self, sequence, frame_id):\n set_name = 'ILSVRC2015_VID_train_{:04d}'.format(sequence['set_id'])\n vid_name = 'ILSVRC2015_train_{:08d}'.format(sequence['vid_id'])\n frame_number = frame_id + sequence['start_frame']\n frame_path = os.path.join('Data', 'VID', 'train', set_name, vid_name,\n '{:06d}.JPEG'.format(frame_number))\n return decode_img(self.root, frame_path)\n\n def get_frames(self, seq_id, frame_ids, anno=None):\n sequence = self.sequence_list[seq_id]\n\n frame_list = [self._get_frame(sequence, f) for f in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n # Create anno dict\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\n\n # added the class info to the meta info\n object_meta = OrderedDict({'object_class': sequence['class_name'],\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n\n return frame_list, anno_frames, object_meta"},{"identifier":"MSCOCOSeq_lmdb","path":"lib/train/dataset/coco_seq_lmdb.py","snippet":"class MSCOCOSeq_lmdb(BaseVideoDataset):\n \"\"\" The COCO dataset. COCO is an image dataset. Thus, we treat each image as a sequence of length 1.\n\n Publication:\n Microsoft COCO: Common Objects in Context.\n Tsung-Yi Lin, Michael Maire, Serge J. Belongie, Lubomir D. Bourdev, Ross B. Girshick, James Hays, Pietro Perona,\n Deva Ramanan, Piotr Dollar and C. Lawrence Zitnick\n ECCV, 2014\n https://arxiv.org/pdf/1405.0312.pdf\n\n Download the images along with annotations from http://cocodataset.org/#download. The root folder should be\n organized as follows.\n - coco_root\n - annotations\n - instances_train2014.json\n - instances_train2017.json\n - images\n - train2014\n - train2017\n\n Note: You also have to install the coco pythonAPI from https://github.com/cocodataset/cocoapi.\n \"\"\"\n\n def __init__(self, root=None, image_loader=jpeg4py_loader, data_fraction=None, split=\"train\", version=\"2014\"):\n \"\"\"\n args:\n root - path to the coco dataset.\n image_loader (default_image_loader) - The function to read the images. If installed,\n jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,\n opencv's imread is used.\n data_fraction (None) - Fraction of images to be used. The images are selected randomly. If None, all the\n images will be used\n split - 'train' or 'val'.\n version - version of coco dataset (2014 or 2017)\n \"\"\"\n root = env_settings().coco_dir if root is None else root\n super().__init__('COCO_lmdb', root, image_loader)\n self.root = root\n self.img_pth = 'images/{}{}/'.format(split, version)\n self.anno_path = 'annotations/instances_{}{}.json'.format(split, version)\n\n # Load the COCO set.\n print('loading annotations into memory...')\n tic = time.time()\n coco_json = decode_json(root, self.anno_path)\n print('Done (t={:0.2f}s)'.format(time.time() - tic))\n\n self.coco_set = COCO(coco_json)\n\n self.cats = self.coco_set.cats\n\n self.class_list = self.get_class_list()\n\n self.sequence_list = self._get_sequence_list()\n\n if data_fraction is not None:\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\n self.seq_per_class = self._build_seq_per_class()\n\n def _get_sequence_list(self):\n ann_list = list(self.coco_set.anns.keys())\n seq_list = [a for a in ann_list if self.coco_set.anns[a]['iscrowd'] == 0]\n\n return seq_list\n\n def is_video_sequence(self):\n return False\n\n def get_num_classes(self):\n return len(self.class_list)\n\n def get_name(self):\n return 'coco_lmdb'\n\n def has_class_info(self):\n return True\n\n def get_class_list(self):\n class_list = []\n for cat_id in self.cats.keys():\n class_list.append(self.cats[cat_id]['name'])\n return class_list\n\n def has_segmentation_info(self):\n return True\n\n def get_num_sequences(self):\n return len(self.sequence_list)\n\n def _build_seq_per_class(self):\n seq_per_class = {}\n for i, seq in enumerate(self.sequence_list):\n class_name = self.cats[self.coco_set.anns[seq]['category_id']]['name']\n if class_name not in seq_per_class:\n seq_per_class[class_name] = [i]\n else:\n seq_per_class[class_name].append(i)\n\n return seq_per_class\n\n def get_sequences_in_class(self, class_name):\n return self.seq_per_class[class_name]\n\n def get_sequence_info(self, seq_id):\n anno = self._get_anno(seq_id)\n\n bbox = torch.Tensor(anno['bbox']).view(1, 4)\n\n mask = torch.Tensor(self.coco_set.annToMask(anno)).unsqueeze(dim=0)\n\n '''2021.1.3 To avoid too small bounding boxes. Here we change the threshold to 50 pixels'''\n valid = (bbox[:, 2] > 50) & (bbox[:, 3] > 50)\n\n visible = valid.clone().byte()\n\n return {'bbox': bbox, 'mask': mask, 'valid': valid, 'visible': visible}\n\n def _get_anno(self, seq_id):\n anno = self.coco_set.anns[self.sequence_list[seq_id]]\n\n return anno\n\n def _get_frames(self, seq_id):\n path = self.coco_set.loadImgs([self.coco_set.anns[self.sequence_list[seq_id]]['image_id']])[0]['file_name']\n # img = self.image_loader(os.path.join(self.img_pth, path))\n img = decode_img(self.root, os.path.join(self.img_pth, path))\n return img\n\n def get_meta_info(self, seq_id):\n try:\n cat_dict_current = self.cats[self.coco_set.anns[self.sequence_list[seq_id]]['category_id']]\n object_meta = OrderedDict({'object_class_name': cat_dict_current['name'],\n 'motion_class': None,\n 'major_class': cat_dict_current['supercategory'],\n 'root_class': None,\n 'motion_adverb': None})\n except:\n object_meta = OrderedDict({'object_class_name': None,\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n return object_meta\n\n\n def get_class_name(self, seq_id):\n cat_dict_current = self.cats[self.coco_set.anns[self.sequence_list[seq_id]]['category_id']]\n return cat_dict_current['name']\n\n def get_frames(self, seq_id=None, frame_ids=None, anno=None):\n # COCO is an image dataset. Thus we replicate the image denoted by seq_id len(frame_ids) times, and return a\n # list containing these replicated images.\n frame = self._get_frames(seq_id)\n\n frame_list = [frame.copy() for _ in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[0, ...] for _ in frame_ids]\n\n object_meta = self.get_meta_info(seq_id)\n\n return frame_list, anno_frames, object_meta"},{"identifier":"TrackingNet_lmdb","path":"lib/train/dataset/tracking_net_lmdb.py","snippet":"class TrackingNet_lmdb(BaseVideoDataset):\n \"\"\" TrackingNet dataset.\n\n Publication:\n TrackingNet: A Large-Scale Dataset and Benchmark for Object Tracking in the Wild.\n Matthias Mueller,Adel Bibi, Silvio Giancola, Salman Al-Subaihi and Bernard Ghanem\n ECCV, 2018\n https://ivul.kaust.edu.sa/Documents/Publications/2018/TrackingNet%20A%20Large%20Scale%20Dataset%20and%20Benchmark%20for%20Object%20Tracking%20in%20the%20Wild.pdf\n\n Download the dataset using the toolkit https://github.com/SilvioGiancola/TrackingNet-devkit.\n \"\"\"\n def __init__(self, root=None, image_loader=jpeg4py_loader, set_ids=None, data_fraction=None):\n \"\"\"\n args:\n root - The path to the TrackingNet folder, containing the training sets.\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\n is used by default.\n set_ids (None) - List containing the ids of the TrackingNet sets to be used for training. If None, all the\n sets (0 - 11) will be used.\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\n \"\"\"\n root = env_settings().trackingnet_lmdb_dir if root is None else root\n super().__init__('TrackingNet_lmdb', root, image_loader)\n\n if set_ids is None:\n set_ids = [i for i in range(12)]\n\n self.set_ids = set_ids\n\n # Keep a list of all videos. Sequence list is a list of tuples (set_id, video_name) containing the set_id and\n # video_name for each sequence\n self.sequence_list = list_sequences(self.root)\n\n if data_fraction is not None:\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list) * data_fraction))\n\n self.seq_to_class_map, self.seq_per_class = self._load_class_info()\n\n # we do not have the class_lists for the tracking net\n self.class_list = list(self.seq_per_class.keys())\n self.class_list.sort()\n\n def _load_class_info(self):\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\n class_map_path = os.path.join(ltr_path, 'data_specs', 'trackingnet_classmap.txt')\n\n with open(class_map_path, 'r') as f:\n seq_to_class_map = {seq_class.split('\\t')[0]: seq_class.rstrip().split('\\t')[1] for seq_class in f}\n\n seq_per_class = {}\n for i, seq in enumerate(self.sequence_list):\n class_name = seq_to_class_map.get(seq[1], 'Unknown')\n if class_name not in seq_per_class:\n seq_per_class[class_name] = [i]\n else:\n seq_per_class[class_name].append(i)\n\n return seq_to_class_map, seq_per_class\n\n def get_name(self):\n return 'trackingnet_lmdb'\n\n def has_class_info(self):\n return True\n\n def get_sequences_in_class(self, class_name):\n return self.seq_per_class[class_name]\n\n def _read_bb_anno(self, seq_id):\n set_id = self.sequence_list[seq_id][0]\n vid_name = self.sequence_list[seq_id][1]\n gt_str_list = decode_str(os.path.join(self.root, \"TRAIN_%d_lmdb\" % set_id),\n os.path.join(\"anno\", vid_name + \".txt\")).split('\\n')[:-1]\n gt_list = [list(map(float, line.split(','))) for line in gt_str_list]\n gt_arr = np.array(gt_list).astype(np.float32)\n return torch.tensor(gt_arr)\n\n def get_sequence_info(self, seq_id):\n bbox = self._read_bb_anno(seq_id)\n\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\n visible = valid.clone().byte()\n return {'bbox': bbox, 'valid': valid, 'visible': visible}\n\n def _get_frame(self, seq_id, frame_id):\n set_id = self.sequence_list[seq_id][0]\n vid_name = self.sequence_list[seq_id][1]\n return decode_img(os.path.join(self.root, \"TRAIN_%d_lmdb\" % set_id),\n os.path.join(\"frames\", vid_name, str(frame_id) + \".jpg\"))\n\n def _get_class(self, seq_id):\n seq_name = self.sequence_list[seq_id][1]\n return self.seq_to_class_map[seq_name]\n\n def get_class_name(self, seq_id):\n obj_class = self._get_class(seq_id)\n\n return obj_class\n\n def get_frames(self, seq_id, frame_ids, anno=None):\n frame_list = [self._get_frame(seq_id, f) for f in frame_ids]\n\n if anno is None:\n anno = self.get_sequence_info(seq_id)\n\n anno_frames = {}\n for key, value in anno.items():\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\n\n obj_class = self._get_class(seq_id)\n\n object_meta = OrderedDict({'object_class_name': obj_class,\n 'motion_class': None,\n 'major_class': None,\n 'root_class': None,\n 'motion_adverb': None})\n\n return frame_list, anno_frames, object_meta"},{"identifier":"sampler","path":"lib/train/data/sampler.py","snippet":"def no_processing(data):\n def __init__(self, datasets, p_datasets, samples_per_epoch, max_gap,\n num_search_frames, num_template_frames=1, processing=no_processing, frame_sample_mode='causal',\n train_cls=False, pos_prob=0.5):\n def __len__(self):\n def _sample_visible_ids(self, visible, num_ids=1, min_id=None, max_id=None,\n allow_invisible=False, force_invisible=False):\n def __getitem__(self, index):\n def getitem(self):\n def getitem_cls(self):\n def get_center_box(self, H, W, ratio=1/8):\n def sample_seq_from_dataset(self, dataset, is_video_dataset):\n def get_one_search(self):\n def get_frame_ids_trident(self, visible):\n def get_frame_ids_stark(self, visible, valid):\nclass TrackingSampler(torch.utils.data.Dataset):\n H, W, _ = template_frames[0].shape\n H, W, _ = template_frames[0].shape\n H, W, _ = search_frames[0].shape"},{"identifier":"processing","path":"lib/train/data/processing.py","snippet":"def stack_tensors(x):\n def __init__(self, transform=transforms.ToTensor(), template_transform=None, search_transform=None, joint_transform=None):\n def __call__(self, data: TensorDict):\n def __init__(self, search_area_factor, output_sz, center_jitter_factor, scale_jitter_factor,\n mode='pair', settings=None, *args, **kwargs):\n def _get_jittered_box(self, box, mode):\n def __call__(self, data: TensorDict):\nclass BaseProcessing:\nclass STARKProcessing(BaseProcessing):"},{"identifier":"LTRLoader","path":"lib/train/data/loader.py","snippet":"class LTRLoader(torch.utils.data.dataloader.DataLoader):\n \"\"\"\n Data loader. Combines a dataset and a sampler, and provides\n single- or multi-process iterators over the dataset.\n\n Note: The only difference with default pytorch DataLoader is that an additional option stack_dim is available to\n select along which dimension the data should be stacked to form a batch.\n\n Arguments:\n dataset (Dataset): dataset from which to load the data.\n batch_size (int, optional): how many samples per batch to load\n (default: 1).\n shuffle (bool, optional): set to ``True`` to have the data reshuffled\n at every epoch (default: False).\n sampler (Sampler, optional): defines the strategy to draw samples from\n the dataset. If specified, ``shuffle`` must be False.\n batch_sampler (Sampler, optional): like sampler, but returns a batch of\n indices at a time. Mutually exclusive with batch_size, shuffle,\n sampler, and drop_last.\n num_workers (int, optional): how many subprocesses to use for data\n loading. 0 means that the data will be loaded in the main process.\n (default: 0)\n collate_fn (callable, optional): merges a list of samples to form a mini-batch.\n stack_dim (int): Dimension along which to stack to form the batch. (default: 0)\n pin_memory (bool, optional): If ``True``, the data loader will copy tensors\n into CUDA pinned memory before returning them.\n drop_last (bool, optional): set to ``True`` to drop the last incomplete batch,\n if the dataset size is not divisible by the batch size. If ``False`` and\n the size of dataset is not divisible by the batch size, then the last batch\n will be smaller. (default: False)\n timeout (numeric, optional): if positive, the timeout value for collecting a batch\n from workers. Should always be non-negative. (default: 0)\n worker_init_fn (callable, optional): If not None, this will be called on each\n worker subprocess with the worker id (an int in ``[0, num_workers - 1]``) as\n input, after seeding and before data loading. (default: None)\n\n .. note:: By default, each worker will have its PyTorch seed set to\n ``base_seed + worker_id``, where ``base_seed`` is a long generated\n by main process using its RNG. However, seeds for other libraries\n may be duplicated upon initializing workers (w.g., NumPy), causing\n each worker to return identical random numbers. (See\n :ref:`dataloader-workers-random-seed` section in FAQ.) You may\n use ``torch.initial_seed()`` to access the PyTorch seed for each\n worker in :attr:`worker_init_fn`, and use it to set other seeds\n before data loading.\n\n .. warning:: If ``spawn`` start method is used, :attr:`worker_init_fn` cannot be an\n unpicklable object, e.g., a lambda function.\n \"\"\"\n\n __initialized = False\n\n def __init__(self, name, dataset, training=True, batch_size=1, shuffle=False, sampler=None, batch_sampler=None,\n num_workers=0, epoch_interval=1, collate_fn=None, stack_dim=0, pin_memory=False, drop_last=False,\n timeout=0, worker_init_fn=None):\n if collate_fn is None:\n if stack_dim == 0:\n collate_fn = ltr_collate\n elif stack_dim == 1:\n collate_fn = ltr_collate_stack1\n else:\n raise ValueError('Stack dim no supported. Must be 0 or 1.')\n\n super(LTRLoader, self).__init__(dataset, batch_size, shuffle, sampler, batch_sampler,\n num_workers, collate_fn, pin_memory, drop_last,\n timeout, worker_init_fn)\n\n self.name = name\n self.training = training\n self.epoch_interval = epoch_interval\n self.stack_dim = stack_dim"},{"identifier":"opencv_loader","path":"lib/train/data/image_loader.py","snippet":"def opencv_loader(path):\n \"\"\" Read image using opencv's imread function and returns it in rgb format\"\"\"\n try:\n im = cv.imread(path, cv.IMREAD_COLOR)\n\n # convert to rgb and return\n return cv.cvtColor(im, cv.COLOR_BGR2RGB)\n except Exception as e:\n print('ERROR: Could not read image \"{}\"'.format(path))\n print(e)\n return None"},{"identifier":"is_main_process","path":"lib/utils/misc.py","snippet":"def is_main_process():\n return get_rank() == 0"}],"string":"[\n {\n \"identifier\": \"Lasot\",\n \"path\": \"lib/train/dataset/lasot.py\",\n \"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, Hexin Bai, Yong Xu, Chunyuan Liao and Haibin Ling\\n CVPR, 2019\\n https://arxiv.org/pdf/1809.07845.pdf\\n\\n Download the dataset from https://cis.temple.edu/lasot/download.html\\n \\\"\\\"\\\"\\n\\n def __init__(self, root=None, image_loader=jpeg4py_loader, vid_ids=None, split=None, data_fraction=None):\\n \\\"\\\"\\\"\\n args:\\n root - path to the lasot dataset.\\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\\n is used by default.\\n vid_ids - List containing the ids of the videos (1 - 20) used for training. If vid_ids = [1, 3, 5], then the\\n videos with subscripts -1, -3, and -5 from each class will be used for training.\\n split - If split='train', the official train split (protocol-II) is used for training. Note: Only one of\\n vid_ids or split option can be used at a time.\\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\\n \\\"\\\"\\\"\\n root = env_settings().lasot_dir if root is None else root\\n super().__init__('LaSOT', root, image_loader)\\n\\n # Keep a list of all classes\\n self.class_list = [f for f in os.listdir(self.root)]\\n self.class_to_id = {cls_name: cls_id for cls_id, cls_name in enumerate(self.class_list)}\\n\\n self.sequence_list = self._build_sequence_list(vid_ids, split)\\n\\n if data_fraction is not None:\\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\\n\\n self.seq_per_class = self._build_class_list()\\n\\n def _build_sequence_list(self, vid_ids=None, split=None):\\n if split is not None:\\n if vid_ids is not None:\\n raise ValueError('Cannot set both split_name and vid_ids.')\\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\\n if split == 'train':\\n file_path = os.path.join(ltr_path, 'data_specs', 'lasot_train_split.txt')\\n else:\\n raise ValueError('Unknown split name.')\\n # sequence_list = pandas.read_csv(file_path, header=None, squeeze=True).values.tolist()\\n sequence_list = pandas.read_csv(file_path, header=None).squeeze(\\\"columns\\\").values.tolist()\\n elif vid_ids is not None:\\n sequence_list = [c+'-'+str(v) for c in self.class_list for v in vid_ids]\\n else:\\n raise ValueError('Set either split_name or vid_ids.')\\n\\n return sequence_list\\n\\n def _build_class_list(self):\\n seq_per_class = {}\\n for seq_id, seq_name in enumerate(self.sequence_list):\\n class_name = seq_name.split('-')[0]\\n if class_name in seq_per_class:\\n seq_per_class[class_name].append(seq_id)\\n else:\\n seq_per_class[class_name] = [seq_id]\\n\\n return seq_per_class\\n\\n def get_name(self):\\n return 'lasot'\\n\\n def has_class_info(self):\\n return True\\n\\n def has_occlusion_info(self):\\n return True\\n\\n def get_num_sequences(self):\\n return len(self.sequence_list)\\n\\n def get_num_classes(self):\\n return len(self.class_list)\\n\\n def get_sequences_in_class(self, class_name):\\n return self.seq_per_class[class_name]\\n\\n def _read_bb_anno(self, seq_path):\\n bb_anno_file = os.path.join(seq_path, \\\"groundtruth.txt\\\")\\n gt = pandas.read_csv(bb_anno_file, delimiter=',', header=None, dtype=np.float32, na_filter=False, low_memory=False).values\\n return torch.tensor(gt)\\n\\n def _read_target_visible(self, seq_path):\\n # Read full occlusion and out_of_view\\n occlusion_file = os.path.join(seq_path, \\\"full_occlusion.txt\\\")\\n out_of_view_file = os.path.join(seq_path, \\\"out_of_view.txt\\\")\\n\\n with open(occlusion_file, 'r', newline='') as f:\\n occlusion = torch.ByteTensor([int(v) for v in list(csv.reader(f))[0]])\\n with open(out_of_view_file, 'r') as f:\\n out_of_view = torch.ByteTensor([int(v) for v in list(csv.reader(f))[0]])\\n\\n target_visible = ~occlusion & ~out_of_view\\n\\n return target_visible\\n\\n def _get_sequence_path(self, seq_id):\\n seq_name = self.sequence_list[seq_id]\\n class_name = seq_name.split('-')[0]\\n vid_id = seq_name.split('-')[1]\\n\\n return os.path.join(self.root, class_name, class_name + '-' + vid_id)\\n\\n def get_sequence_info(self, seq_id):\\n seq_path = self._get_sequence_path(seq_id)\\n bbox = self._read_bb_anno(seq_path)\\n\\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\\n visible = self._read_target_visible(seq_path) & valid.byte()\\n\\n return {'bbox': bbox, 'valid': valid, 'visible': visible}\\n\\n def _get_frame_path(self, seq_path, frame_id):\\n return os.path.join(seq_path, 'img', '{:08}.jpg'.format(frame_id+1)) # frames start from 1\\n\\n def _get_frame(self, seq_path, frame_id):\\n return self.image_loader(self._get_frame_path(seq_path, frame_id))\\n\\n def _get_class(self, seq_path):\\n raw_class = seq_path.split('/')[-2]\\n return raw_class\\n\\n def get_class_name(self, seq_id):\\n seq_path = self._get_sequence_path(seq_id)\\n obj_class = self._get_class(seq_path)\\n\\n return obj_class\\n\\n def get_frames(self, seq_id, frame_ids, anno=None):\\n seq_path = self._get_sequence_path(seq_id)\\n\\n obj_class = self._get_class(seq_path)\\n frame_list = [self._get_frame(seq_path, f_id) for f_id in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\\n\\n object_meta = OrderedDict({'object_class_name': obj_class,\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n\\n return frame_list, anno_frames, object_meta\"\n },\n {\n \"identifier\": \"Got10k\",\n \"path\": \"lib/train/dataset/got10k.py\",\n \"snippet\": \"class Got10k(BaseVideoDataset):\\n \\\"\\\"\\\" GOT-10k dataset.\\n\\n Publication:\\n GOT-10k: A Large High-Diversity Benchmark for Generic Object Tracking in the Wild\\n Lianghua Huang, Xin Zhao, and Kaiqi Huang\\n arXiv:1810.11981, 2018\\n https://arxiv.org/pdf/1810.11981.pdf\\n\\n Download dataset from http://got-10k.aitestunion.com/downloads\\n \\\"\\\"\\\"\\n\\n def __init__(self, root=None, image_loader=jpeg4py_loader, split=None, seq_ids=None, data_fraction=None):\\n \\\"\\\"\\\"\\n args:\\n root - path to the got-10k training data. Note: This should point to the 'train' folder inside GOT-10k\\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\\n is used by default.\\n split - 'train' or 'val'. Note: The validation split here is a subset of the official got-10k train split,\\n not NOT the official got-10k validation split. To use the official validation split, provide that as\\n the root folder instead.\\n seq_ids - List containing the ids of the videos to be used for training. Note: Only one of 'split' or 'seq_ids'\\n options can be used at the same time.\\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\\n \\\"\\\"\\\"\\n root = env_settings().got10k_dir if root is None else root\\n super().__init__('GOT10k', root, image_loader)\\n\\n # all folders inside the root\\n self.sequence_list = self._get_sequence_list()\\n\\n # seq_id is the index of the folder inside the got10k root path\\n if split is not None:\\n if seq_ids is not None:\\n raise ValueError('Cannot set both split_name and seq_ids.')\\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\\n if split == 'train':\\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_train_split.txt')\\n elif split == 'val':\\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_val_split.txt')\\n elif split == 'train_full':\\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_train_full_split.txt')\\n elif split == 'vottrain':\\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_vot_train_split.txt')\\n elif split == 'votval':\\n file_path = os.path.join(ltr_path, 'data_specs', 'got10k_vot_val_split.txt')\\n else:\\n raise ValueError('Unknown split name.')\\n # seq_ids = pandas.read_csv(file_path, header=None, squeeze=True, dtype=np.int64).values.tolist()\\n seq_ids = pandas.read_csv(file_path, header=None, dtype=np.int64).squeeze(\\\"columns\\\").values.tolist()\\n elif seq_ids is None:\\n seq_ids = list(range(0, len(self.sequence_list)))\\n\\n self.sequence_list = [self.sequence_list[i] for i in seq_ids]\\n\\n if data_fraction is not None:\\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\\n\\n self.sequence_meta_info = self._load_meta_info()\\n self.seq_per_class = self._build_seq_per_class()\\n\\n self.class_list = list(self.seq_per_class.keys())\\n self.class_list.sort()\\n\\n def get_name(self):\\n return 'got10k'\\n\\n def has_class_info(self):\\n return True\\n\\n def has_occlusion_info(self):\\n return True\\n\\n def _load_meta_info(self):\\n sequence_meta_info = {s: self._read_meta(os.path.join(self.root, s)) for s in self.sequence_list}\\n return sequence_meta_info\\n\\n def _read_meta(self, seq_path):\\n try:\\n with open(os.path.join(seq_path, 'meta_info.ini')) as f:\\n meta_info = f.readlines()\\n object_meta = OrderedDict({'object_class_name': meta_info[5].split(': ')[-1][:-1],\\n 'motion_class': meta_info[6].split(': ')[-1][:-1],\\n 'major_class': meta_info[7].split(': ')[-1][:-1],\\n 'root_class': meta_info[8].split(': ')[-1][:-1],\\n 'motion_adverb': meta_info[9].split(': ')[-1][:-1]})\\n except:\\n object_meta = OrderedDict({'object_class_name': None,\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n return object_meta\\n\\n def _build_seq_per_class(self):\\n seq_per_class = {}\\n\\n for i, s in enumerate(self.sequence_list):\\n object_class = self.sequence_meta_info[s]['object_class_name']\\n if object_class in seq_per_class:\\n seq_per_class[object_class].append(i)\\n else:\\n seq_per_class[object_class] = [i]\\n\\n return seq_per_class\\n\\n def get_sequences_in_class(self, class_name):\\n return self.seq_per_class[class_name]\\n\\n def _get_sequence_list(self):\\n with open(os.path.join(self.root, 'list.txt')) as f:\\n dir_list = list(csv.reader(f))\\n dir_list = [dir_name[0] for dir_name in dir_list]\\n return dir_list\\n\\n def _read_bb_anno(self, seq_path):\\n bb_anno_file = os.path.join(seq_path, \\\"groundtruth.txt\\\")\\n gt = pandas.read_csv(bb_anno_file, delimiter=',', header=None, dtype=np.float32, na_filter=False, low_memory=False).values\\n return torch.tensor(gt)\\n\\n def _read_target_visible(self, seq_path):\\n # Read full occlusion and out_of_view\\n occlusion_file = os.path.join(seq_path, \\\"absence.label\\\")\\n cover_file = os.path.join(seq_path, \\\"cover.label\\\")\\n\\n with open(occlusion_file, 'r', newline='') as f:\\n occlusion = torch.ByteTensor([int(v[0]) for v in csv.reader(f)])\\n with open(cover_file, 'r', newline='') as f:\\n cover = torch.ByteTensor([int(v[0]) for v in csv.reader(f)])\\n\\n target_visible = ~occlusion & (cover>0).byte()\\n\\n visible_ratio = cover.float() / 8\\n return target_visible, visible_ratio\\n\\n def _get_sequence_path(self, seq_id):\\n return os.path.join(self.root, self.sequence_list[seq_id])\\n\\n def get_sequence_info(self, seq_id):\\n seq_path = self._get_sequence_path(seq_id)\\n bbox = self._read_bb_anno(seq_path)\\n\\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\\n visible, visible_ratio = self._read_target_visible(seq_path)\\n visible = visible & valid.byte()\\n\\n return {'bbox': bbox, 'valid': valid, 'visible': visible, 'visible_ratio': visible_ratio}\\n\\n def _get_frame_path(self, seq_path, frame_id):\\n return os.path.join(seq_path, '{:08}.jpg'.format(frame_id+1)) # frames start from 1\\n\\n def _get_frame(self, seq_path, frame_id):\\n return self.image_loader(self._get_frame_path(seq_path, frame_id))\\n\\n def get_class_name(self, seq_id):\\n obj_meta = self.sequence_meta_info[self.sequence_list[seq_id]]\\n\\n return obj_meta['object_class_name']\\n\\n def get_frames(self, seq_id, frame_ids, anno=None):\\n seq_path = self._get_sequence_path(seq_id)\\n obj_meta = self.sequence_meta_info[self.sequence_list[seq_id]]\\n\\n frame_list = [self._get_frame(seq_path, f_id) for f_id in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\\n\\n return frame_list, anno_frames, obj_meta\"\n },\n {\n \"identifier\": \"TrackingNet\",\n \"path\": \"lib/train/dataset/tracking_net.py\",\n \"snippet\": \"class TrackingNet(BaseVideoDataset):\\n \\\"\\\"\\\" TrackingNet dataset.\\n\\n Publication:\\n TrackingNet: A Large-Scale Dataset and Benchmark for Object Tracking in the Wild.\\n Matthias Mueller,Adel Bibi, Silvio Giancola, Salman Al-Subaihi and Bernard Ghanem\\n ECCV, 2018\\n https://ivul.kaust.edu.sa/Documents/Publications/2018/TrackingNet%20A%20Large%20Scale%20Dataset%20and%20Benchmark%20for%20Object%20Tracking%20in%20the%20Wild.pdf\\n\\n Download the dataset using the toolkit https://github.com/SilvioGiancola/TrackingNet-devkit.\\n \\\"\\\"\\\"\\n def __init__(self, root=None, image_loader=jpeg4py_loader, set_ids=None, data_fraction=None):\\n \\\"\\\"\\\"\\n args:\\n root - The path to the TrackingNet folder, containing the training sets.\\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\\n is used by default.\\n set_ids (None) - List containing the ids of the TrackingNet sets to be used for training. If None, all the\\n sets (0 - 11) will be used.\\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\\n \\\"\\\"\\\"\\n root = env_settings().trackingnet_dir if root is None else root\\n super().__init__('TrackingNet', root, image_loader)\\n\\n if set_ids is None:\\n set_ids = [i for i in range(12)]\\n\\n self.set_ids = set_ids\\n\\n # Keep a list of all videos. Sequence list is a list of tuples (set_id, video_name) containing the set_id and\\n # video_name for each sequence\\n self.sequence_list = list_sequences(self.root, self.set_ids)\\n\\n if data_fraction is not None:\\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list) * data_fraction))\\n\\n self.seq_to_class_map, self.seq_per_class = self._load_class_info()\\n\\n # we do not have the class_lists for the tracking net\\n self.class_list = list(self.seq_per_class.keys())\\n self.class_list.sort()\\n\\n def _load_class_info(self):\\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\\n class_map_path = os.path.join(ltr_path, 'data_specs', 'trackingnet_classmap.txt')\\n\\n with open(class_map_path, 'r') as f:\\n seq_to_class_map = {seq_class.split('\\\\t')[0]: seq_class.rstrip().split('\\\\t')[1] for seq_class in f}\\n\\n seq_per_class = {}\\n for i, seq in enumerate(self.sequence_list):\\n class_name = seq_to_class_map.get(seq[1], 'Unknown')\\n if class_name not in seq_per_class:\\n seq_per_class[class_name] = [i]\\n else:\\n seq_per_class[class_name].append(i)\\n\\n return seq_to_class_map, seq_per_class\\n\\n def get_name(self):\\n return 'trackingnet'\\n\\n def has_class_info(self):\\n return True\\n\\n def get_sequences_in_class(self, class_name):\\n return self.seq_per_class[class_name]\\n\\n def _read_bb_anno(self, seq_id):\\n set_id = self.sequence_list[seq_id][0]\\n vid_name = self.sequence_list[seq_id][1]\\n bb_anno_file = os.path.join(self.root, \\\"TRAIN_\\\" + str(set_id), \\\"anno\\\", vid_name + \\\".txt\\\")\\n gt = pandas.read_csv(bb_anno_file, delimiter=',', header=None, dtype=np.float32, na_filter=False,\\n low_memory=False).values\\n return torch.tensor(gt)\\n\\n def get_sequence_info(self, seq_id):\\n bbox = self._read_bb_anno(seq_id)\\n\\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\\n visible = valid.clone().byte()\\n return {'bbox': bbox, 'valid': valid, 'visible': visible}\\n\\n def _get_frame(self, seq_id, frame_id):\\n set_id = self.sequence_list[seq_id][0]\\n vid_name = self.sequence_list[seq_id][1]\\n frame_path = os.path.join(self.root, \\\"TRAIN_\\\" + str(set_id), \\\"frames\\\", vid_name, str(frame_id) + \\\".jpg\\\")\\n return self.image_loader(frame_path)\\n\\n def _get_class(self, seq_id):\\n seq_name = self.sequence_list[seq_id][1]\\n return self.seq_to_class_map[seq_name]\\n\\n def get_class_name(self, seq_id):\\n obj_class = self._get_class(seq_id)\\n\\n return obj_class\\n\\n def get_frames(self, seq_id, frame_ids, anno=None):\\n frame_list = [self._get_frame(seq_id, f) for f in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\\n\\n obj_class = self._get_class(seq_id)\\n\\n object_meta = OrderedDict({'object_class_name': obj_class,\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n\\n return frame_list, anno_frames, object_meta\"\n },\n {\n \"identifier\": \"ImagenetVID\",\n \"path\": \"lib/train/dataset/imagenetvid.py\",\n \"snippet\": \"class ImagenetVID(BaseVideoDataset):\\n \\\"\\\"\\\" Imagenet VID dataset.\\n\\n Publication:\\n ImageNet Large Scale Visual Recognition Challenge\\n Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy,\\n Aditya Khosla, Michael Bernstein, Alexander C. Berg and Li Fei-Fei\\n IJCV, 2015\\n https://arxiv.org/pdf/1409.0575.pdf\\n\\n Download the dataset from http://image-net.org/\\n \\\"\\\"\\\"\\n def __init__(self, root=None, image_loader=jpeg4py_loader, min_length=0, max_target_area=1):\\n \\\"\\\"\\\"\\n args:\\n root - path to the imagenet vid dataset.\\n image_loader (default_image_loader) - The function to read the images. If installed,\\n jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,\\n opencv's imread is used.\\n min_length - Minimum allowed sequence length.\\n max_target_area - max allowed ratio between target area and image area. Can be used to filter out targets\\n which cover complete image.\\n \\\"\\\"\\\"\\n root = env_settings().imagenet_dir if root is None else root\\n super().__init__(\\\"imagenetvid\\\", root, image_loader)\\n\\n cache_file = os.path.join(root, 'cache.json')\\n if os.path.isfile(cache_file):\\n # If available, load the pre-processed cache file containing meta-info for each sequence\\n with open(cache_file, 'r') as f:\\n sequence_list_dict = json.load(f)\\n\\n self.sequence_list = sequence_list_dict\\n else:\\n # Else process the imagenet annotations and generate the cache file\\n self.sequence_list = self._process_anno(root)\\n\\n with open(cache_file, 'w') as f:\\n json.dump(self.sequence_list, f)\\n\\n # Filter the sequences based on min_length and max_target_area in the first frame\\n self.sequence_list = [x for x in self.sequence_list if len(x['anno']) >= min_length and\\n get_target_to_image_ratio(x) < max_target_area]\\n\\n def get_name(self):\\n return 'imagenetvid'\\n\\n def get_num_sequences(self):\\n return len(self.sequence_list)\\n\\n def get_sequence_info(self, seq_id):\\n bb_anno = torch.Tensor(self.sequence_list[seq_id]['anno'])\\n valid = (bb_anno[:, 2] > 0) & (bb_anno[:, 3] > 0)\\n visible = torch.ByteTensor(self.sequence_list[seq_id]['target_visible']) & valid.byte()\\n return {'bbox': bb_anno, 'valid': valid, 'visible': visible}\\n\\n def _get_frame(self, sequence, frame_id):\\n set_name = 'ILSVRC2015_VID_train_{:04d}'.format(sequence['set_id'])\\n vid_name = 'ILSVRC2015_train_{:08d}'.format(sequence['vid_id'])\\n frame_number = frame_id + sequence['start_frame']\\n frame_path = os.path.join(self.root, 'Data', 'VID', 'train', set_name, vid_name,\\n '{:06d}.JPEG'.format(frame_number))\\n return self.image_loader(frame_path)\\n\\n def get_frames(self, seq_id, frame_ids, anno=None):\\n sequence = self.sequence_list[seq_id]\\n\\n frame_list = [self._get_frame(sequence, f) for f in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n # Create anno dict\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\\n\\n # added the class info to the meta info\\n object_meta = OrderedDict({'object_class': sequence['class_name'],\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n\\n return frame_list, anno_frames, object_meta\\n\\n def _process_anno(self, root):\\n # Builds individual tracklets\\n base_vid_anno_path = os.path.join(root, 'Annotations', 'VID', 'train')\\n\\n all_sequences = []\\n for set in sorted(os.listdir(base_vid_anno_path)):\\n set_id = int(set.split('_')[-1])\\n for vid in sorted(os.listdir(os.path.join(base_vid_anno_path, set))):\\n\\n vid_id = int(vid.split('_')[-1])\\n anno_files = sorted(os.listdir(os.path.join(base_vid_anno_path, set, vid)))\\n\\n frame1_anno = ET.parse(os.path.join(base_vid_anno_path, set, vid, anno_files[0]))\\n image_size = [int(frame1_anno.find('size/width').text), int(frame1_anno.find('size/height').text)]\\n\\n objects = [ET.ElementTree(file=os.path.join(base_vid_anno_path, set, vid, f)).findall('object')\\n for f in anno_files]\\n\\n tracklets = {}\\n\\n # Find all tracklets along with start frame\\n for f_id, all_targets in enumerate(objects):\\n for target in all_targets:\\n tracklet_id = target.find('trackid').text\\n if tracklet_id not in tracklets:\\n tracklets[tracklet_id] = f_id\\n\\n for tracklet_id, tracklet_start in tracklets.items():\\n tracklet_anno = []\\n target_visible = []\\n class_name_id = None\\n\\n for f_id in range(tracklet_start, len(objects)):\\n found = False\\n for target in objects[f_id]:\\n if target.find('trackid').text == tracklet_id:\\n if not class_name_id:\\n class_name_id = target.find('name').text\\n x1 = int(target.find('bndbox/xmin').text)\\n y1 = int(target.find('bndbox/ymin').text)\\n x2 = int(target.find('bndbox/xmax').text)\\n y2 = int(target.find('bndbox/ymax').text)\\n\\n tracklet_anno.append([x1, y1, x2 - x1, y2 - y1])\\n target_visible.append(target.find('occluded').text == '0')\\n\\n found = True\\n break\\n if not found:\\n break\\n\\n new_sequence = {'set_id': set_id, 'vid_id': vid_id, 'class_name': class_name_id,\\n 'start_frame': tracklet_start, 'anno': tracklet_anno,\\n 'target_visible': target_visible, 'image_size': image_size}\\n all_sequences.append(new_sequence)\\n\\n return all_sequences\"\n },\n {\n \"identifier\": \"MSCOCOSeq\",\n \"path\": \"lib/train/dataset/coco_seq.py\",\n \"snippet\": \"class MSCOCOSeq(BaseVideoDataset):\\n \\\"\\\"\\\" The COCO dataset. COCO is an image dataset. Thus, we treat each image as a sequence of length 1.\\n\\n Publication:\\n Microsoft COCO: Common Objects in Context.\\n Tsung-Yi Lin, Michael Maire, Serge J. Belongie, Lubomir D. Bourdev, Ross B. Girshick, James Hays, Pietro Perona,\\n Deva Ramanan, Piotr Dollar and C. Lawrence Zitnick\\n ECCV, 2014\\n https://arxiv.org/pdf/1405.0312.pdf\\n\\n Download the images along with annotations from http://cocodataset.org/#download. The root folder should be\\n organized as follows.\\n - coco_root\\n - annotations\\n - instances_train2014.json\\n - instances_train2017.json\\n - images\\n - train2014\\n - train2017\\n\\n Note: You also have to install the coco pythonAPI from https://github.com/cocodataset/cocoapi.\\n \\\"\\\"\\\"\\n\\n def __init__(self, root=None, image_loader=jpeg4py_loader, data_fraction=None, split=\\\"train\\\", version=\\\"2014\\\"):\\n \\\"\\\"\\\"\\n args:\\n root - path to the coco dataset.\\n image_loader (default_image_loader) - The function to read the images. If installed,\\n jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,\\n opencv's imread is used.\\n data_fraction (None) - Fraction of images to be used. The images are selected randomly. If None, all the\\n images will be used\\n split - 'train' or 'val'.\\n version - version of coco dataset (2014 or 2017)\\n \\\"\\\"\\\"\\n root = env_settings().coco_dir if root is None else root\\n super().__init__('COCO', root, image_loader)\\n\\n self.img_pth = os.path.join(root, 'images/{}{}/'.format(split, version))\\n self.anno_path = os.path.join(root, 'annotations/instances_{}{}.json'.format(split, version))\\n\\n # Load the COCO set.\\n self.coco_set = COCO(self.anno_path)\\n\\n self.cats = self.coco_set.cats\\n\\n self.class_list = self.get_class_list()\\n\\n self.sequence_list = self._get_sequence_list()\\n\\n if data_fraction is not None:\\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\\n self.seq_per_class = self._build_seq_per_class()\\n\\n def _get_sequence_list(self):\\n ann_list = list(self.coco_set.anns.keys())\\n seq_list = [a for a in ann_list if self.coco_set.anns[a]['iscrowd'] == 0]\\n\\n return seq_list\\n\\n def is_video_sequence(self):\\n return False\\n\\n def get_num_classes(self):\\n return len(self.class_list)\\n\\n def get_name(self):\\n return 'coco'\\n\\n def has_class_info(self):\\n return True\\n\\n def get_class_list(self):\\n class_list = []\\n for cat_id in self.cats.keys():\\n class_list.append(self.cats[cat_id]['name'])\\n return class_list\\n\\n def has_segmentation_info(self):\\n return True\\n\\n def get_num_sequences(self):\\n return len(self.sequence_list)\\n\\n def _build_seq_per_class(self):\\n seq_per_class = {}\\n for i, seq in enumerate(self.sequence_list):\\n class_name = self.cats[self.coco_set.anns[seq]['category_id']]['name']\\n if class_name not in seq_per_class:\\n seq_per_class[class_name] = [i]\\n else:\\n seq_per_class[class_name].append(i)\\n\\n return seq_per_class\\n\\n def get_sequences_in_class(self, class_name):\\n return self.seq_per_class[class_name]\\n\\n def get_sequence_info(self, seq_id):\\n anno = self._get_anno(seq_id)\\n\\n bbox = torch.Tensor(anno['bbox']).view(1, 4)\\n\\n mask = torch.Tensor(self.coco_set.annToMask(anno)).unsqueeze(dim=0)\\n\\n '''2021.1.3 To avoid too small bounding boxes. Here we change the threshold to 50 pixels'''\\n valid = (bbox[:, 2] > 50) & (bbox[:, 3] > 50)\\n\\n visible = valid.clone().byte()\\n\\n return {'bbox': bbox, 'mask': mask, 'valid': valid, 'visible': visible}\\n\\n def _get_anno(self, seq_id):\\n anno = self.coco_set.anns[self.sequence_list[seq_id]]\\n\\n return anno\\n\\n def _get_frames(self, seq_id):\\n path = self.coco_set.loadImgs([self.coco_set.anns[self.sequence_list[seq_id]]['image_id']])[0]['file_name']\\n img = self.image_loader(os.path.join(self.img_pth, path))\\n return img\\n\\n def get_meta_info(self, seq_id):\\n try:\\n cat_dict_current = self.cats[self.coco_set.anns[self.sequence_list[seq_id]]['category_id']]\\n object_meta = OrderedDict({'object_class_name': cat_dict_current['name'],\\n 'motion_class': None,\\n 'major_class': cat_dict_current['supercategory'],\\n 'root_class': None,\\n 'motion_adverb': None})\\n except:\\n object_meta = OrderedDict({'object_class_name': None,\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n return object_meta\\n\\n\\n def get_class_name(self, seq_id):\\n cat_dict_current = self.cats[self.coco_set.anns[self.sequence_list[seq_id]]['category_id']]\\n return cat_dict_current['name']\\n\\n def get_frames(self, seq_id=None, frame_ids=None, anno=None):\\n # COCO is an image dataset. Thus we replicate the image denoted by seq_id len(frame_ids) times, and return a\\n # list containing these replicated images.\\n frame = self._get_frames(seq_id)\\n\\n frame_list = [frame.copy() for _ in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[0, ...] for _ in frame_ids]\\n\\n object_meta = self.get_meta_info(seq_id)\\n\\n return frame_list, anno_frames, object_meta\"\n },\n {\n \"identifier\": \"Got10k_lmdb\",\n \"path\": \"lib/train/dataset/got10k_lmdb.py\",\n \"snippet\": \"class Got10k_lmdb(BaseVideoDataset):\\n\\n def __init__(self, root=None, image_loader=jpeg4py_loader, split=None, seq_ids=None, data_fraction=None):\\n \\\"\\\"\\\"\\n args:\\n root - path to the got-10k training data. Note: This should point to the 'train' folder inside GOT-10k\\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\\n is used by default.\\n split - 'train' or 'val'. Note: The validation split here is a subset of the official got-10k train split,\\n not NOT the official got-10k validation split. To use the official validation split, provide that as\\n the root folder instead.\\n seq_ids - List containing the ids of the videos to be used for training. Note: Only one of 'split' or 'seq_ids'\\n options can be used at the same time.\\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\\n use_lmdb - whether the dataset is stored in lmdb format\\n \\\"\\\"\\\"\\n root = env_settings().got10k_lmdb_dir if root is None else root\\n super().__init__('GOT10k_lmdb', root, image_loader)\\n\\n # all folders inside the root\\n self.sequence_list = self._get_sequence_list()\\n\\n # seq_id is the index of the folder inside the got10k root path\\n if split is not None:\\n if seq_ids is not None:\\n raise ValueError('Cannot set both split_name and seq_ids.')\\n train_lib_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\\n if split == 'train':\\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_train_split.txt')\\n elif split == 'val':\\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_val_split.txt')\\n elif split == 'train_full':\\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_train_full_split.txt')\\n elif split == 'vottrain':\\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_vot_train_split.txt')\\n elif split == 'votval':\\n file_path = os.path.join(train_lib_path, 'data_specs', 'got10k_vot_val_split.txt')\\n else:\\n raise ValueError('Unknown split name.')\\n seq_ids = pandas.read_csv(file_path, header=None, squeeze=True, dtype=np.int64).values.tolist()\\n elif seq_ids is None:\\n seq_ids = list(range(0, len(self.sequence_list)))\\n\\n self.sequence_list = [self.sequence_list[i] for i in seq_ids]\\n\\n if data_fraction is not None:\\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\\n\\n self.sequence_meta_info = self._load_meta_info()\\n self.seq_per_class = self._build_seq_per_class()\\n\\n self.class_list = list(self.seq_per_class.keys())\\n self.class_list.sort()\\n\\n def get_name(self):\\n return 'got10k_lmdb'\\n\\n def has_class_info(self):\\n return True\\n\\n def has_occlusion_info(self):\\n return True\\n\\n def _load_meta_info(self):\\n def _read_meta(meta_info):\\n\\n object_meta = OrderedDict({'object_class_name': meta_info[5].split(': ')[-1],\\n 'motion_class': meta_info[6].split(': ')[-1],\\n 'major_class': meta_info[7].split(': ')[-1],\\n 'root_class': meta_info[8].split(': ')[-1],\\n 'motion_adverb': meta_info[9].split(': ')[-1]})\\n\\n return object_meta\\n sequence_meta_info = {}\\n for s in self.sequence_list:\\n try:\\n meta_str = decode_str(self.root, \\\"train/%s/meta_info.ini\\\" %s)\\n sequence_meta_info[s] = _read_meta(meta_str.split('\\\\n'))\\n except:\\n sequence_meta_info[s] = OrderedDict({'object_class_name': None,\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n return sequence_meta_info\\n\\n def _build_seq_per_class(self):\\n seq_per_class = {}\\n\\n for i, s in enumerate(self.sequence_list):\\n object_class = self.sequence_meta_info[s]['object_class_name']\\n if object_class in seq_per_class:\\n seq_per_class[object_class].append(i)\\n else:\\n seq_per_class[object_class] = [i]\\n\\n return seq_per_class\\n\\n def get_sequences_in_class(self, class_name):\\n return self.seq_per_class[class_name]\\n\\n def _get_sequence_list(self):\\n dir_str = decode_str(self.root, 'train/list.txt')\\n dir_list = dir_str.split('\\\\n')\\n return dir_list\\n\\n def _read_bb_anno(self, seq_path):\\n bb_anno_file = os.path.join(seq_path, \\\"groundtruth.txt\\\")\\n gt_str_list = decode_str(self.root, bb_anno_file).split('\\\\n')[:-1] # the last line in got10k is empty\\n gt_list = [list(map(float, line.split(','))) for line in gt_str_list]\\n gt_arr = np.array(gt_list).astype(np.float32)\\n\\n return torch.tensor(gt_arr)\\n\\n def _read_target_visible(self, seq_path):\\n # full occlusion and out_of_view files\\n occlusion_file = os.path.join(seq_path, \\\"absence.label\\\")\\n cover_file = os.path.join(seq_path, \\\"cover.label\\\")\\n # Read these files\\n occ_list = list(map(int, decode_str(self.root, occlusion_file).split('\\\\n')[:-1])) # the last line in got10k is empty\\n occlusion = torch.ByteTensor(occ_list)\\n cover_list = list(map(int, decode_str(self.root, cover_file).split('\\\\n')[:-1])) # the last line in got10k is empty\\n cover = torch.ByteTensor(cover_list)\\n\\n target_visible = ~occlusion & (cover>0).byte()\\n\\n visible_ratio = cover.float() / 8\\n return target_visible, visible_ratio\\n\\n def _get_sequence_path(self, seq_id):\\n return os.path.join(\\\"train\\\", self.sequence_list[seq_id])\\n\\n def get_sequence_info(self, seq_id):\\n seq_path = self._get_sequence_path(seq_id)\\n bbox = self._read_bb_anno(seq_path)\\n\\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\\n visible, visible_ratio = self._read_target_visible(seq_path)\\n visible = visible & valid.byte()\\n\\n return {'bbox': bbox, 'valid': valid, 'visible': visible, 'visible_ratio': visible_ratio}\\n\\n def _get_frame_path(self, seq_path, frame_id):\\n return os.path.join(seq_path, '{:08}.jpg'.format(frame_id+1)) # frames start from 1\\n\\n def _get_frame(self, seq_path, frame_id):\\n return decode_img(self.root, self._get_frame_path(seq_path, frame_id))\\n\\n def get_class_name(self, seq_id):\\n obj_meta = self.sequence_meta_info[self.sequence_list[seq_id]]\\n\\n return obj_meta['object_class_name']\\n\\n def get_frames(self, seq_id, frame_ids, anno=None):\\n seq_path = self._get_sequence_path(seq_id)\\n obj_meta = self.sequence_meta_info[self.sequence_list[seq_id]]\\n\\n frame_list = [self._get_frame(seq_path, f_id) for f_id in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\\n\\n return frame_list, anno_frames, obj_meta\"\n },\n {\n \"identifier\": \"Lasot_lmdb\",\n \"path\": \"lib/train/dataset/lasot_lmdb.py\",\n \"snippet\": \"class Lasot_lmdb(BaseVideoDataset):\\n\\n def __init__(self, root=None, image_loader=jpeg4py_loader, vid_ids=None, split=None, data_fraction=None):\\n \\\"\\\"\\\"\\n args:\\n root - path to the lasot dataset.\\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\\n is used by default.\\n vid_ids - List containing the ids of the videos (1 - 20) used for training. If vid_ids = [1, 3, 5], then the\\n videos with subscripts -1, -3, and -5 from each class will be used for training.\\n split - If split='train', the official train split (protocol-II) is used for training. Note: Only one of\\n vid_ids or split option can be used at a time.\\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\\n \\\"\\\"\\\"\\n root = env_settings().lasot_lmdb_dir if root is None else root\\n super().__init__('LaSOT_lmdb', root, image_loader)\\n\\n self.sequence_list = self._build_sequence_list(vid_ids, split)\\n class_list = [seq_name.split('-')[0] for seq_name in self.sequence_list]\\n self.class_list = []\\n for ele in class_list:\\n if ele not in self.class_list:\\n self.class_list.append(ele)\\n # Keep a list of all classes\\n self.class_to_id = {cls_name: cls_id for cls_id, cls_name in enumerate(self.class_list)}\\n\\n if data_fraction is not None:\\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\\n\\n self.seq_per_class = self._build_class_list()\\n\\n def _build_sequence_list(self, vid_ids=None, split=None):\\n if split is not None:\\n if vid_ids is not None:\\n raise ValueError('Cannot set both split_name and vid_ids.')\\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\\n if split == 'train':\\n file_path = os.path.join(ltr_path, 'data_specs', 'lasot_train_split.txt')\\n else:\\n raise ValueError('Unknown split name.')\\n sequence_list = pandas.read_csv(file_path, header=None, squeeze=True).values.tolist()\\n elif vid_ids is not None:\\n sequence_list = [c+'-'+str(v) for c in self.class_list for v in vid_ids]\\n else:\\n raise ValueError('Set either split_name or vid_ids.')\\n\\n return sequence_list\\n\\n def _build_class_list(self):\\n seq_per_class = {}\\n for seq_id, seq_name in enumerate(self.sequence_list):\\n class_name = seq_name.split('-')[0]\\n if class_name in seq_per_class:\\n seq_per_class[class_name].append(seq_id)\\n else:\\n seq_per_class[class_name] = [seq_id]\\n\\n return seq_per_class\\n\\n def get_name(self):\\n return 'lasot_lmdb'\\n\\n def has_class_info(self):\\n return True\\n\\n def has_occlusion_info(self):\\n return True\\n\\n def get_num_sequences(self):\\n return len(self.sequence_list)\\n\\n def get_num_classes(self):\\n return len(self.class_list)\\n\\n def get_sequences_in_class(self, class_name):\\n return self.seq_per_class[class_name]\\n\\n def _read_bb_anno(self, seq_path):\\n bb_anno_file = os.path.join(seq_path, \\\"groundtruth.txt\\\")\\n gt_str_list = decode_str(self.root, bb_anno_file).split('\\\\n')[:-1] # the last line is empty\\n gt_list = [list(map(float, line.split(','))) for line in gt_str_list]\\n gt_arr = np.array(gt_list).astype(np.float32)\\n return torch.tensor(gt_arr)\\n\\n def _read_target_visible(self, seq_path):\\n # Read full occlusion and out_of_view\\n occlusion_file = os.path.join(seq_path, \\\"full_occlusion.txt\\\")\\n out_of_view_file = os.path.join(seq_path, \\\"out_of_view.txt\\\")\\n\\n occ_list = list(map(int, decode_str(self.root, occlusion_file).split(',')))\\n occlusion = torch.ByteTensor(occ_list)\\n out_view_list = list(map(int, decode_str(self.root, out_of_view_file).split(',')))\\n out_of_view = torch.ByteTensor(out_view_list)\\n\\n target_visible = ~occlusion & ~out_of_view\\n\\n return target_visible\\n\\n def _get_sequence_path(self, seq_id):\\n seq_name = self.sequence_list[seq_id]\\n class_name = seq_name.split('-')[0]\\n vid_id = seq_name.split('-')[1]\\n\\n return os.path.join(class_name, class_name + '-' + vid_id)\\n\\n def get_sequence_info(self, seq_id):\\n seq_path = self._get_sequence_path(seq_id)\\n bbox = self._read_bb_anno(seq_path)\\n\\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\\n visible = self._read_target_visible(seq_path) & valid.byte()\\n\\n return {'bbox': bbox, 'valid': valid, 'visible': visible}\\n\\n def _get_frame_path(self, seq_path, frame_id):\\n return os.path.join(seq_path, 'img', '{:08}.jpg'.format(frame_id+1)) # frames start from 1\\n\\n def _get_frame(self, seq_path, frame_id):\\n return decode_img(self.root, self._get_frame_path(seq_path, frame_id))\\n\\n def _get_class(self, seq_path):\\n raw_class = seq_path.split('/')[-2]\\n return raw_class\\n\\n def get_class_name(self, seq_id):\\n seq_path = self._get_sequence_path(seq_id)\\n obj_class = self._get_class(seq_path)\\n\\n return obj_class\\n\\n def get_frames(self, seq_id, frame_ids, anno=None):\\n seq_path = self._get_sequence_path(seq_id)\\n\\n obj_class = self._get_class(seq_path)\\n frame_list = [self._get_frame(seq_path, f_id) for f_id in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\\n\\n object_meta = OrderedDict({'object_class_name': obj_class,\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n\\n return frame_list, anno_frames, object_meta\"\n },\n {\n \"identifier\": \"ImagenetVID_lmdb\",\n \"path\": \"lib/train/dataset/imagenetvid_lmdb.py\",\n \"snippet\": \"class ImagenetVID_lmdb(BaseVideoDataset):\\n \\\"\\\"\\\" Imagenet VID dataset.\\n\\n Publication:\\n ImageNet Large Scale Visual Recognition Challenge\\n Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy,\\n Aditya Khosla, Michael Bernstein, Alexander C. Berg and Li Fei-Fei\\n IJCV, 2015\\n https://arxiv.org/pdf/1409.0575.pdf\\n\\n Download the dataset from http://image-net.org/\\n \\\"\\\"\\\"\\n def __init__(self, root=None, image_loader=jpeg4py_loader, min_length=0, max_target_area=1):\\n \\\"\\\"\\\"\\n args:\\n root - path to the imagenet vid dataset.\\n image_loader (default_image_loader) - The function to read the images. If installed,\\n jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,\\n opencv's imread is used.\\n min_length - Minimum allowed sequence length.\\n max_target_area - max allowed ratio between target area and image area. Can be used to filter out targets\\n which cover complete image.\\n \\\"\\\"\\\"\\n root = env_settings().imagenet_dir if root is None else root\\n super().__init__(\\\"imagenetvid_lmdb\\\", root, image_loader)\\n\\n sequence_list_dict = decode_json(root, \\\"cache.json\\\")\\n self.sequence_list = sequence_list_dict\\n\\n # Filter the sequences based on min_length and max_target_area in the first frame\\n self.sequence_list = [x for x in self.sequence_list if len(x['anno']) >= min_length and\\n get_target_to_image_ratio(x) < max_target_area]\\n\\n def get_name(self):\\n return 'imagenetvid_lmdb'\\n\\n def get_num_sequences(self):\\n return len(self.sequence_list)\\n\\n def get_sequence_info(self, seq_id):\\n bb_anno = torch.Tensor(self.sequence_list[seq_id]['anno'])\\n valid = (bb_anno[:, 2] > 0) & (bb_anno[:, 3] > 0)\\n visible = torch.ByteTensor(self.sequence_list[seq_id]['target_visible']) & valid.byte()\\n return {'bbox': bb_anno, 'valid': valid, 'visible': visible}\\n\\n def _get_frame(self, sequence, frame_id):\\n set_name = 'ILSVRC2015_VID_train_{:04d}'.format(sequence['set_id'])\\n vid_name = 'ILSVRC2015_train_{:08d}'.format(sequence['vid_id'])\\n frame_number = frame_id + sequence['start_frame']\\n frame_path = os.path.join('Data', 'VID', 'train', set_name, vid_name,\\n '{:06d}.JPEG'.format(frame_number))\\n return decode_img(self.root, frame_path)\\n\\n def get_frames(self, seq_id, frame_ids, anno=None):\\n sequence = self.sequence_list[seq_id]\\n\\n frame_list = [self._get_frame(sequence, f) for f in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n # Create anno dict\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\\n\\n # added the class info to the meta info\\n object_meta = OrderedDict({'object_class': sequence['class_name'],\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n\\n return frame_list, anno_frames, object_meta\"\n },\n {\n \"identifier\": \"MSCOCOSeq_lmdb\",\n \"path\": \"lib/train/dataset/coco_seq_lmdb.py\",\n \"snippet\": \"class MSCOCOSeq_lmdb(BaseVideoDataset):\\n \\\"\\\"\\\" The COCO dataset. COCO is an image dataset. Thus, we treat each image as a sequence of length 1.\\n\\n Publication:\\n Microsoft COCO: Common Objects in Context.\\n Tsung-Yi Lin, Michael Maire, Serge J. Belongie, Lubomir D. Bourdev, Ross B. Girshick, James Hays, Pietro Perona,\\n Deva Ramanan, Piotr Dollar and C. Lawrence Zitnick\\n ECCV, 2014\\n https://arxiv.org/pdf/1405.0312.pdf\\n\\n Download the images along with annotations from http://cocodataset.org/#download. The root folder should be\\n organized as follows.\\n - coco_root\\n - annotations\\n - instances_train2014.json\\n - instances_train2017.json\\n - images\\n - train2014\\n - train2017\\n\\n Note: You also have to install the coco pythonAPI from https://github.com/cocodataset/cocoapi.\\n \\\"\\\"\\\"\\n\\n def __init__(self, root=None, image_loader=jpeg4py_loader, data_fraction=None, split=\\\"train\\\", version=\\\"2014\\\"):\\n \\\"\\\"\\\"\\n args:\\n root - path to the coco dataset.\\n image_loader (default_image_loader) - The function to read the images. If installed,\\n jpeg4py (https://github.com/ajkxyz/jpeg4py) is used by default. Else,\\n opencv's imread is used.\\n data_fraction (None) - Fraction of images to be used. The images are selected randomly. If None, all the\\n images will be used\\n split - 'train' or 'val'.\\n version - version of coco dataset (2014 or 2017)\\n \\\"\\\"\\\"\\n root = env_settings().coco_dir if root is None else root\\n super().__init__('COCO_lmdb', root, image_loader)\\n self.root = root\\n self.img_pth = 'images/{}{}/'.format(split, version)\\n self.anno_path = 'annotations/instances_{}{}.json'.format(split, version)\\n\\n # Load the COCO set.\\n print('loading annotations into memory...')\\n tic = time.time()\\n coco_json = decode_json(root, self.anno_path)\\n print('Done (t={:0.2f}s)'.format(time.time() - tic))\\n\\n self.coco_set = COCO(coco_json)\\n\\n self.cats = self.coco_set.cats\\n\\n self.class_list = self.get_class_list()\\n\\n self.sequence_list = self._get_sequence_list()\\n\\n if data_fraction is not None:\\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list)*data_fraction))\\n self.seq_per_class = self._build_seq_per_class()\\n\\n def _get_sequence_list(self):\\n ann_list = list(self.coco_set.anns.keys())\\n seq_list = [a for a in ann_list if self.coco_set.anns[a]['iscrowd'] == 0]\\n\\n return seq_list\\n\\n def is_video_sequence(self):\\n return False\\n\\n def get_num_classes(self):\\n return len(self.class_list)\\n\\n def get_name(self):\\n return 'coco_lmdb'\\n\\n def has_class_info(self):\\n return True\\n\\n def get_class_list(self):\\n class_list = []\\n for cat_id in self.cats.keys():\\n class_list.append(self.cats[cat_id]['name'])\\n return class_list\\n\\n def has_segmentation_info(self):\\n return True\\n\\n def get_num_sequences(self):\\n return len(self.sequence_list)\\n\\n def _build_seq_per_class(self):\\n seq_per_class = {}\\n for i, seq in enumerate(self.sequence_list):\\n class_name = self.cats[self.coco_set.anns[seq]['category_id']]['name']\\n if class_name not in seq_per_class:\\n seq_per_class[class_name] = [i]\\n else:\\n seq_per_class[class_name].append(i)\\n\\n return seq_per_class\\n\\n def get_sequences_in_class(self, class_name):\\n return self.seq_per_class[class_name]\\n\\n def get_sequence_info(self, seq_id):\\n anno = self._get_anno(seq_id)\\n\\n bbox = torch.Tensor(anno['bbox']).view(1, 4)\\n\\n mask = torch.Tensor(self.coco_set.annToMask(anno)).unsqueeze(dim=0)\\n\\n '''2021.1.3 To avoid too small bounding boxes. Here we change the threshold to 50 pixels'''\\n valid = (bbox[:, 2] > 50) & (bbox[:, 3] > 50)\\n\\n visible = valid.clone().byte()\\n\\n return {'bbox': bbox, 'mask': mask, 'valid': valid, 'visible': visible}\\n\\n def _get_anno(self, seq_id):\\n anno = self.coco_set.anns[self.sequence_list[seq_id]]\\n\\n return anno\\n\\n def _get_frames(self, seq_id):\\n path = self.coco_set.loadImgs([self.coco_set.anns[self.sequence_list[seq_id]]['image_id']])[0]['file_name']\\n # img = self.image_loader(os.path.join(self.img_pth, path))\\n img = decode_img(self.root, os.path.join(self.img_pth, path))\\n return img\\n\\n def get_meta_info(self, seq_id):\\n try:\\n cat_dict_current = self.cats[self.coco_set.anns[self.sequence_list[seq_id]]['category_id']]\\n object_meta = OrderedDict({'object_class_name': cat_dict_current['name'],\\n 'motion_class': None,\\n 'major_class': cat_dict_current['supercategory'],\\n 'root_class': None,\\n 'motion_adverb': None})\\n except:\\n object_meta = OrderedDict({'object_class_name': None,\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n return object_meta\\n\\n\\n def get_class_name(self, seq_id):\\n cat_dict_current = self.cats[self.coco_set.anns[self.sequence_list[seq_id]]['category_id']]\\n return cat_dict_current['name']\\n\\n def get_frames(self, seq_id=None, frame_ids=None, anno=None):\\n # COCO is an image dataset. Thus we replicate the image denoted by seq_id len(frame_ids) times, and return a\\n # list containing these replicated images.\\n frame = self._get_frames(seq_id)\\n\\n frame_list = [frame.copy() for _ in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[0, ...] for _ in frame_ids]\\n\\n object_meta = self.get_meta_info(seq_id)\\n\\n return frame_list, anno_frames, object_meta\"\n },\n {\n \"identifier\": \"TrackingNet_lmdb\",\n \"path\": \"lib/train/dataset/tracking_net_lmdb.py\",\n \"snippet\": \"class TrackingNet_lmdb(BaseVideoDataset):\\n \\\"\\\"\\\" TrackingNet dataset.\\n\\n Publication:\\n TrackingNet: A Large-Scale Dataset and Benchmark for Object Tracking in the Wild.\\n Matthias Mueller,Adel Bibi, Silvio Giancola, Salman Al-Subaihi and Bernard Ghanem\\n ECCV, 2018\\n https://ivul.kaust.edu.sa/Documents/Publications/2018/TrackingNet%20A%20Large%20Scale%20Dataset%20and%20Benchmark%20for%20Object%20Tracking%20in%20the%20Wild.pdf\\n\\n Download the dataset using the toolkit https://github.com/SilvioGiancola/TrackingNet-devkit.\\n \\\"\\\"\\\"\\n def __init__(self, root=None, image_loader=jpeg4py_loader, set_ids=None, data_fraction=None):\\n \\\"\\\"\\\"\\n args:\\n root - The path to the TrackingNet folder, containing the training sets.\\n image_loader (jpeg4py_loader) - The function to read the images. jpeg4py (https://github.com/ajkxyz/jpeg4py)\\n is used by default.\\n set_ids (None) - List containing the ids of the TrackingNet sets to be used for training. If None, all the\\n sets (0 - 11) will be used.\\n data_fraction - Fraction of dataset to be used. The complete dataset is used by default\\n \\\"\\\"\\\"\\n root = env_settings().trackingnet_lmdb_dir if root is None else root\\n super().__init__('TrackingNet_lmdb', root, image_loader)\\n\\n if set_ids is None:\\n set_ids = [i for i in range(12)]\\n\\n self.set_ids = set_ids\\n\\n # Keep a list of all videos. Sequence list is a list of tuples (set_id, video_name) containing the set_id and\\n # video_name for each sequence\\n self.sequence_list = list_sequences(self.root)\\n\\n if data_fraction is not None:\\n self.sequence_list = random.sample(self.sequence_list, int(len(self.sequence_list) * data_fraction))\\n\\n self.seq_to_class_map, self.seq_per_class = self._load_class_info()\\n\\n # we do not have the class_lists for the tracking net\\n self.class_list = list(self.seq_per_class.keys())\\n self.class_list.sort()\\n\\n def _load_class_info(self):\\n ltr_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')\\n class_map_path = os.path.join(ltr_path, 'data_specs', 'trackingnet_classmap.txt')\\n\\n with open(class_map_path, 'r') as f:\\n seq_to_class_map = {seq_class.split('\\\\t')[0]: seq_class.rstrip().split('\\\\t')[1] for seq_class in f}\\n\\n seq_per_class = {}\\n for i, seq in enumerate(self.sequence_list):\\n class_name = seq_to_class_map.get(seq[1], 'Unknown')\\n if class_name not in seq_per_class:\\n seq_per_class[class_name] = [i]\\n else:\\n seq_per_class[class_name].append(i)\\n\\n return seq_to_class_map, seq_per_class\\n\\n def get_name(self):\\n return 'trackingnet_lmdb'\\n\\n def has_class_info(self):\\n return True\\n\\n def get_sequences_in_class(self, class_name):\\n return self.seq_per_class[class_name]\\n\\n def _read_bb_anno(self, seq_id):\\n set_id = self.sequence_list[seq_id][0]\\n vid_name = self.sequence_list[seq_id][1]\\n gt_str_list = decode_str(os.path.join(self.root, \\\"TRAIN_%d_lmdb\\\" % set_id),\\n os.path.join(\\\"anno\\\", vid_name + \\\".txt\\\")).split('\\\\n')[:-1]\\n gt_list = [list(map(float, line.split(','))) for line in gt_str_list]\\n gt_arr = np.array(gt_list).astype(np.float32)\\n return torch.tensor(gt_arr)\\n\\n def get_sequence_info(self, seq_id):\\n bbox = self._read_bb_anno(seq_id)\\n\\n valid = (bbox[:, 2] > 0) & (bbox[:, 3] > 0)\\n visible = valid.clone().byte()\\n return {'bbox': bbox, 'valid': valid, 'visible': visible}\\n\\n def _get_frame(self, seq_id, frame_id):\\n set_id = self.sequence_list[seq_id][0]\\n vid_name = self.sequence_list[seq_id][1]\\n return decode_img(os.path.join(self.root, \\\"TRAIN_%d_lmdb\\\" % set_id),\\n os.path.join(\\\"frames\\\", vid_name, str(frame_id) + \\\".jpg\\\"))\\n\\n def _get_class(self, seq_id):\\n seq_name = self.sequence_list[seq_id][1]\\n return self.seq_to_class_map[seq_name]\\n\\n def get_class_name(self, seq_id):\\n obj_class = self._get_class(seq_id)\\n\\n return obj_class\\n\\n def get_frames(self, seq_id, frame_ids, anno=None):\\n frame_list = [self._get_frame(seq_id, f) for f in frame_ids]\\n\\n if anno is None:\\n anno = self.get_sequence_info(seq_id)\\n\\n anno_frames = {}\\n for key, value in anno.items():\\n anno_frames[key] = [value[f_id, ...].clone() for f_id in frame_ids]\\n\\n obj_class = self._get_class(seq_id)\\n\\n object_meta = OrderedDict({'object_class_name': obj_class,\\n 'motion_class': None,\\n 'major_class': None,\\n 'root_class': None,\\n 'motion_adverb': None})\\n\\n return frame_list, anno_frames, object_meta\"\n },\n {\n \"identifier\": \"sampler\",\n \"path\": \"lib/train/data/sampler.py\",\n \"snippet\": \"def no_processing(data):\\n def __init__(self, datasets, p_datasets, samples_per_epoch, max_gap,\\n num_search_frames, num_template_frames=1, processing=no_processing, frame_sample_mode='causal',\\n train_cls=False, pos_prob=0.5):\\n def __len__(self):\\n def _sample_visible_ids(self, visible, num_ids=1, min_id=None, max_id=None,\\n allow_invisible=False, force_invisible=False):\\n def __getitem__(self, index):\\n def getitem(self):\\n def getitem_cls(self):\\n def get_center_box(self, H, W, ratio=1/8):\\n def sample_seq_from_dataset(self, dataset, is_video_dataset):\\n def get_one_search(self):\\n def get_frame_ids_trident(self, visible):\\n def get_frame_ids_stark(self, visible, valid):\\nclass TrackingSampler(torch.utils.data.Dataset):\\n H, W, _ = template_frames[0].shape\\n H, W, _ = template_frames[0].shape\\n H, W, _ = search_frames[0].shape\"\n },\n {\n \"identifier\": \"processing\",\n \"path\": \"lib/train/data/processing.py\",\n \"snippet\": \"def stack_tensors(x):\\n def __init__(self, transform=transforms.ToTensor(), template_transform=None, search_transform=None, joint_transform=None):\\n def __call__(self, data: TensorDict):\\n def __init__(self, search_area_factor, output_sz, center_jitter_factor, scale_jitter_factor,\\n mode='pair', settings=None, *args, **kwargs):\\n def _get_jittered_box(self, box, mode):\\n def __call__(self, data: TensorDict):\\nclass BaseProcessing:\\nclass STARKProcessing(BaseProcessing):\"\n },\n {\n \"identifier\": \"LTRLoader\",\n \"path\": \"lib/train/data/loader.py\",\n \"snippet\": \"class LTRLoader(torch.utils.data.dataloader.DataLoader):\\n \\\"\\\"\\\"\\n Data loader. Combines a dataset and a sampler, and provides\\n single- or multi-process iterators over the dataset.\\n\\n Note: The only difference with default pytorch DataLoader is that an additional option stack_dim is available to\\n select along which dimension the data should be stacked to form a batch.\\n\\n Arguments:\\n dataset (Dataset): dataset from which to load the data.\\n batch_size (int, optional): how many samples per batch to load\\n (default: 1).\\n shuffle (bool, optional): set to ``True`` to have the data reshuffled\\n at every epoch (default: False).\\n sampler (Sampler, optional): defines the strategy to draw samples from\\n the dataset. If specified, ``shuffle`` must be False.\\n batch_sampler (Sampler, optional): like sampler, but returns a batch of\\n indices at a time. Mutually exclusive with batch_size, shuffle,\\n sampler, and drop_last.\\n num_workers (int, optional): how many subprocesses to use for data\\n loading. 0 means that the data will be loaded in the main process.\\n (default: 0)\\n collate_fn (callable, optional): merges a list of samples to form a mini-batch.\\n stack_dim (int): Dimension along which to stack to form the batch. (default: 0)\\n pin_memory (bool, optional): If ``True``, the data loader will copy tensors\\n into CUDA pinned memory before returning them.\\n drop_last (bool, optional): set to ``True`` to drop the last incomplete batch,\\n if the dataset size is not divisible by the batch size. If ``False`` and\\n the size of dataset is not divisible by the batch size, then the last batch\\n will be smaller. (default: False)\\n timeout (numeric, optional): if positive, the timeout value for collecting a batch\\n from workers. Should always be non-negative. (default: 0)\\n worker_init_fn (callable, optional): If not None, this will be called on each\\n worker subprocess with the worker id (an int in ``[0, num_workers - 1]``) as\\n input, after seeding and before data loading. (default: None)\\n\\n .. note:: By default, each worker will have its PyTorch seed set to\\n ``base_seed + worker_id``, where ``base_seed`` is a long generated\\n by main process using its RNG. However, seeds for other libraries\\n may be duplicated upon initializing workers (w.g., NumPy), causing\\n each worker to return identical random numbers. (See\\n :ref:`dataloader-workers-random-seed` section in FAQ.) You may\\n use ``torch.initial_seed()`` to access the PyTorch seed for each\\n worker in :attr:`worker_init_fn`, and use it to set other seeds\\n before data loading.\\n\\n .. warning:: If ``spawn`` start method is used, :attr:`worker_init_fn` cannot be an\\n unpicklable object, e.g., a lambda function.\\n \\\"\\\"\\\"\\n\\n __initialized = False\\n\\n def __init__(self, name, dataset, training=True, batch_size=1, shuffle=False, sampler=None, batch_sampler=None,\\n num_workers=0, epoch_interval=1, collate_fn=None, stack_dim=0, pin_memory=False, drop_last=False,\\n timeout=0, worker_init_fn=None):\\n if collate_fn is None:\\n if stack_dim == 0:\\n collate_fn = ltr_collate\\n elif stack_dim == 1:\\n collate_fn = ltr_collate_stack1\\n else:\\n raise ValueError('Stack dim no supported. Must be 0 or 1.')\\n\\n super(LTRLoader, self).__init__(dataset, batch_size, shuffle, sampler, batch_sampler,\\n num_workers, collate_fn, pin_memory, drop_last,\\n timeout, worker_init_fn)\\n\\n self.name = name\\n self.training = training\\n self.epoch_interval = epoch_interval\\n self.stack_dim = stack_dim\"\n },\n {\n \"identifier\": \"opencv_loader\",\n \"path\": \"lib/train/data/image_loader.py\",\n \"snippet\": \"def opencv_loader(path):\\n \\\"\\\"\\\" Read image using opencv's imread function and returns it in rgb format\\\"\\\"\\\"\\n try:\\n im = cv.imread(path, cv.IMREAD_COLOR)\\n\\n # convert to rgb and return\\n return cv.cvtColor(im, cv.COLOR_BGR2RGB)\\n except Exception as e:\\n print('ERROR: Could not read image \\\"{}\\\"'.format(path))\\n print(e)\\n return None\"\n },\n {\n \"identifier\": \"is_main_process\",\n \"path\": \"lib/utils/misc.py\",\n \"snippet\": \"def is_main_process():\\n return get_rank() == 0\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import os\nimport torch\nimport lib.train.data.transforms as tfm\nfrom torch.utils.data.distributed import DistributedSampler\nfrom lib.train.dataset import Lasot, Got10k, MSCOCOSeq, ImagenetVID, TrackingNet\nfrom lib.train.dataset import Lasot_lmdb, Got10k_lmdb, MSCOCOSeq_lmdb, ImagenetVID_lmdb, TrackingNet_lmdb\nfrom lib.train.data import sampler, opencv_loader, processing, LTRLoader\nfrom lib.utils.misc import is_main_process"},"token_num":{"kind":"number","value":18050,"string":"18,050"},"cropped_code":{"kind":"string","value":"# datasets related\n\n\ndef update_settings(settings, cfg):\n settings.print_interval = cfg.TRAIN.PRINT_INTERVAL\n settings.search_area_factor = {'template': cfg.DATA.TEMPLATE.FACTOR,\n 'search': cfg.DATA.SEARCH.FACTOR}\n settings.output_sz = {'template': cfg.DATA.TEMPLATE.SIZE,\n 'search': cfg.DATA.SEARCH.SIZE}\n settings.center_jitter_factor = {'template': cfg.DATA.TEMPLATE.CENTER_JITTER,\n 'search': cfg.DATA.SEARCH.CENTER_JITTER}\n settings.scale_jitter_factor = {'template': cfg.DATA.TEMPLATE.SCALE_JITTER,\n 'search': cfg.DATA.SEARCH.SCALE_JITTER}\n settings.grad_clip_norm = cfg.TRAIN.GRAD_CLIP_NORM\n settings.print_stats = None\n settings.batchsize = cfg.TRAIN.BATCH_SIZE\n settings.scheduler_type = cfg.TRAIN.SCHEDULER.TYPE\n\n\ndef names2datasets(name_list: list, settings, image_loader):\n assert isinstance(name_list, list)\n datasets = []\n for name in name_list:\n assert name in [\"LASOT\", \"GOT10K_vottrain\", \"GOT10K_votval\", \"GOT10K_train_full\", \"GOT10K_official_val\",\n \"COCO17\", \"VID\", \"TRACKINGNET\",\n ]\n # Tracking Task\n if name == \"LASOT\":\n if settings.use_lmdb:\n print(\"Building lasot dataset from lmdb\")\n datasets.append(Lasot_lmdb(settings.env.lasot_lmdb_dir, split='train', image_loader=image_loader))\n else:\n datasets.append(Lasot(settings.env.lasot_dir, split='train', image_loader=image_loader))\n if name == \"GOT10K_vottrain\":\n if settings.use_lmdb:\n print(\"Building got10k from lmdb\")\n datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='vottrain', image_loader=image_loader))\n else:\n datasets.append(Got10k(settings.env.got10k_dir, split='vottrain', image_loader=image_loader))\n if name == \"GOT10K_train_full\":\n if settings.use_lmdb:\n print(\"Building got10k_train_full from lmdb\")\n datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='train_full', image_loader=image_loader))\n else:\n datasets.append(Got10k(settings.env.got10k_dir, split='train_full', image_loader=image_loader))\n if name == \"GOT10K_votval\":\n if settings.use_lmdb:\n print(\"Building got10k from lmdb\")\n datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='votval', image_loader=image_loader))\n else:\n datasets.append(Got10k(settings.env.got10k_dir, split='votval', image_loader=image_loader))\n if name == \"GOT10K_official_val\":\n if settings.use_lmdb:\n raise ValueError(\"Not implement\")\n else:\n datasets.append(Got10k(settings.env.got10k_val_dir, split=None, image_loader=image_loader))\n if name == \"COCO17\":\n if settings.use_lmdb:\n print(\"Building COCO2017 from lmdb\")\n"},"all_code":{"kind":"string","value":"# datasets related\n\n\ndef update_settings(settings, cfg):\n settings.print_interval = cfg.TRAIN.PRINT_INTERVAL\n settings.search_area_factor = {'template': cfg.DATA.TEMPLATE.FACTOR,\n 'search': cfg.DATA.SEARCH.FACTOR}\n settings.output_sz = {'template': cfg.DATA.TEMPLATE.SIZE,\n 'search': cfg.DATA.SEARCH.SIZE}\n settings.center_jitter_factor = {'template': cfg.DATA.TEMPLATE.CENTER_JITTER,\n 'search': cfg.DATA.SEARCH.CENTER_JITTER}\n settings.scale_jitter_factor = {'template': cfg.DATA.TEMPLATE.SCALE_JITTER,\n 'search': cfg.DATA.SEARCH.SCALE_JITTER}\n settings.grad_clip_norm = cfg.TRAIN.GRAD_CLIP_NORM\n settings.print_stats = None\n settings.batchsize = cfg.TRAIN.BATCH_SIZE\n settings.scheduler_type = cfg.TRAIN.SCHEDULER.TYPE\n\n\ndef names2datasets(name_list: list, settings, image_loader):\n assert isinstance(name_list, list)\n datasets = []\n for name in name_list:\n assert name in [\"LASOT\", \"GOT10K_vottrain\", \"GOT10K_votval\", \"GOT10K_train_full\", \"GOT10K_official_val\",\n \"COCO17\", \"VID\", \"TRACKINGNET\",\n ]\n # Tracking Task\n if name == \"LASOT\":\n if settings.use_lmdb:\n print(\"Building lasot dataset from lmdb\")\n datasets.append(Lasot_lmdb(settings.env.lasot_lmdb_dir, split='train', image_loader=image_loader))\n else:\n datasets.append(Lasot(settings.env.lasot_dir, split='train', image_loader=image_loader))\n if name == \"GOT10K_vottrain\":\n if settings.use_lmdb:\n print(\"Building got10k from lmdb\")\n datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='vottrain', image_loader=image_loader))\n else:\n datasets.append(Got10k(settings.env.got10k_dir, split='vottrain', image_loader=image_loader))\n if name == \"GOT10K_train_full\":\n if settings.use_lmdb:\n print(\"Building got10k_train_full from lmdb\")\n datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='train_full', image_loader=image_loader))\n else:\n datasets.append(Got10k(settings.env.got10k_dir, split='train_full', image_loader=image_loader))\n if name == \"GOT10K_votval\":\n if settings.use_lmdb:\n print(\"Building got10k from lmdb\")\n datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='votval', image_loader=image_loader))\n else:\n datasets.append(Got10k(settings.env.got10k_dir, split='votval', image_loader=image_loader))\n if name == \"GOT10K_official_val\":\n if settings.use_lmdb:\n raise ValueError(\"Not implement\")\n else:\n datasets.append(Got10k(settings.env.got10k_val_dir, split=None, image_loader=image_loader))\n if name == \"COCO17\":\n if settings.use_lmdb:\n print(\"Building COCO2017 from lmdb\")"},"next_line":{"kind":"string","value":" datasets.append(MSCOCOSeq_lmdb(settings.env.coco_lmdb_dir, version=\"2017\", image_loader=image_loader))"},"gold_snippet_index":{"kind":"number","value":8,"string":"8"},"created_at":{"kind":"string","value":"2023-12-10 03:57:19+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5980,"cells":{"repo_name":{"kind":"string","value":"lumina-test/lumina"},"file_path":{"kind":"string","value":"lumina/e2e_test/test_gbn.py"},"context":{"kind":"list like","value":[{"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 list of dict: The list of queue pair (QP) information if successful or None otherwise.\n The list of QP information is in the following format:\n [{'psn_rcv': initial packet sequence number from the receiver qp,\n 'psn_snd': initial packet sequence number from the sender qp,\n 'qpn_rcv': receiver qp number,\n 'qpn_snd': sender qp number,\n 'ip_rcv' : receiver IP\n 'ip_snd' : sender IP}]\n \"\"\"\n try:\n with open(switch_msg_snapshot, 'r') as stream:\n qp_info_list = yaml.safe_load(stream)\n except:\n logging.error(\"Read switch message snapshot %s error.\" % switch_msg_snapshot)\n return None\n\n logging.info(\"Read switch message snapshot %s.\" % switch_msg_snapshot)\n return qp_info_list"},{"identifier":"Orchestrator","path":"lumina/orchestrator/main.py","snippet":"class Orchestrator:\n \"\"\" Class to manage the experiment \"\"\"\n def __init__(self, config_file):\n \"\"\" Constructor for Orchestrator class\n\n Args:\n config_file (str): path to the yaml (config) file.\n The file contains configs for switch, requester, responder, traffic, etc.\n\n Returns:\n N/A\n \"\"\"\n with open(config_file, \"r\") as stream:\n conf = yaml.safe_load(stream)\n try:\n local_workspace = conf['local-workspace']\n result_path = conf['result-path']\n switch_conf = conf['switch']\n requester_conf = conf['requester']\n responder_conf = conf['responder']\n requester_mirror_conf = conf['requester-mirror']\n responder_mirror_conf = conf['responder-mirror']\n traffic_conf = conf['traffic']\n rewrite_udp_dst_port = conf['rewrite-udp-dst-port']\n num_repeats = conf['num-repeats']\n agg_pcap_filename = conf['aggregate-pcap-filename']\n except KeyError as e:\n print(\"Config file %s has a bad yaml format (key error: %s)\" % (config_file, e))\n sys.exit(-1)\n\n switch_conf['rewrite-udp-dst-port'] = rewrite_udp_dst_port\n requester_mirror_conf['pkt-dump-conf']['rewrite-udp-dst-port'] = rewrite_udp_dst_port\n responder_mirror_conf['pkt-dump-conf']['rewrite-udp-dst-port'] = rewrite_udp_dst_port\n\n self.local_workspace = local_workspace\n self.result_path = result_path\n self.traffic_conf = traffic_conf\n self.num_repeats = num_repeats\n self.switch = switch.Switch(switch_conf)\n self.requester = host.RDMAHost(requester_conf)\n self.responder = host.RDMAHost(responder_conf)\n self.requester_mirror = host.MirrorHost(requester_mirror_conf)\n self.responder_mirror = host.MirrorHost(responder_mirror_conf)\n self.aggregate_pcap_filename = agg_pcap_filename\n\n cmd = \"mkdir -p %s\" % self.result_path\n subprocess.call(cmd, shell = True)\n\n def rm_old_files(self):\n \"\"\" Remove result files left by previous experiments \"\"\"\n old_iter_id = 0\n old_iter_result_path = os.path.join(self.result_path, str(old_iter_id))\n\n while os.path.exists(old_iter_result_path) and not os.path.isfile(old_iter_result_path):\n cmd = \"rm -rf %s\" % (old_iter_result_path)\n subprocess.call(cmd, shell=True)\n\n old_iter_id += 1\n old_iter_result_path = os.path.join(self.result_path, str(old_iter_id))\n\n def get_requester_ip_list(self):\n \"\"\" Return the list of requester IP addresses (without prefix length info) \"\"\"\n return [x.split('/')[0] for x in self.requester.conf['nic']['ip-list']]\n\n def get_responder_ip_list(self):\n \"\"\" Return the list of responder IP addresses (without prefix length info) \"\"\"\n return [x.split('/')[0] for x in self.responder.conf['nic']['ip-list']]\n\n def get_num_repeats(self):\n \"\"\" Return the number of experiment repeats \"\"\"\n return self.num_repeats\n\n def sync_and_compile(self):\n \"\"\" Syncronize and compile the code on all the hosts\n\n Returns:\n bool: True if the code is synced and compiled successfully, False otherwise\n \"\"\"\n logging.info(\"Sync and compile the code\")\n\n ## Sync and compile the switch code\n ret = self.switch.sync_and_compile(self.local_workspace,\n switch.SWITCH_PROG_DIR_NAME,\n switch.SWITCH_PROG_FILE_NAME)\n if ret == False:\n logging.error(\"Failed to sync and compile the switch code\")\n return False\n\n ## Sync and compile the traffic generator code\n rdma_verb = self.traffic_conf['rdma-verb'].strip().lower()\n if rdma_verb not in host.VALID_IB_VERB_LIST_LOWER:\n logging.error(\"Invalid RDMA verb: %s\" % rdma_verb)\n return False\n\n ret = self.requester.sync_and_compile(local_workspace=self.local_workspace,\n prog_dir_name=self.requester.traffic_gen_dir_name(),\n prog_file_name=self.requester.traffic_gen_client_name(rdma_verb))\n if ret == False:\n logging.error(\"Failed to sync and compile the traffic generator code on requester\")\n return False\n\n ret = self.responder.sync_and_compile(local_workspace=self.local_workspace,\n prog_dir_name=self.requester.traffic_gen_dir_name(),\n prog_file_name=self.requester.traffic_gen_server_name(rdma_verb))\n if ret == False:\n logging.error(\"Failed to sync and compile the traffic generator code on responder\")\n return False\n\n ret = self.requester.sync(local_workspace=self.local_workspace,\n prog_dir_name=host.DUMP_COUNTER_DIR_NAME)\n if ret == False:\n logging.error(\"Failed to sync the dump counter code on requester\")\n return False\n\n ret = self.responder.sync(local_workspace=self.local_workspace,\n prog_dir_name=host.DUMP_COUNTER_DIR_NAME)\n if ret == False:\n logging.error(\"Failed to sync the dump counter code on responder\")\n return False\n\n ## Sync and compile the packet capture code\n ret = self.requester_mirror.sync_and_compile(local_workspace=self.local_workspace,\n prog_dir_name=host.PKT_CAPTURE_DIR_NAME,\n prog_file_name=host.PKT_CAPTURE_FILE_NAME)\n if ret == False:\n logging.error(\"Failed to sync and compile the packet capture code on requester_mirror\")\n return False\n\n ret = self.responder_mirror.sync_and_compile(local_workspace=self.local_workspace,\n prog_dir_name=host.PKT_CAPTURE_DIR_NAME,\n prog_file_name=host.PKT_CAPTURE_FILE_NAME)\n if ret == False:\n logging.error(\"Failed to sync and compile the packet capture code on responder_mirror\")\n return False\n\n return True\n\n def generate_switch_table_config(self):\n \"\"\" Generate the switch configuration, including:\n 1. Forward table\n 2. Mirror table\n 3. ARP table\n 4. Traffic table, including the events to inject\n\n Returns:\n bool: True if the switch configuration is generated successfully, False otherwise\n \"\"\"\n requester_nic_conf = self.requester.conf['nic']\n responder_nic_conf = self.responder.conf['nic']\n requester_mirror_nic_conf = self.requester_mirror.conf['nic']\n responder_mirror_nic_conf = self.responder_mirror.conf['nic']\n\n ## Set up forward table entries\n self.switch.conf['forward-table'] = []\n try:\n for nic_conf, host_type in zip([requester_nic_conf, responder_nic_conf, \\\n requester_mirror_nic_conf, responder_mirror_nic_conf],\n ['requester', 'responder', 'requester_mirror', 'responder_mirror']):\n forward_table_entry = {'dst-mac': nic_conf['mac'],\n 'eg-port': nic_conf['switch-port'],\n 'host': host_type}\n self.switch.conf['forward-table'].append(forward_table_entry)\n except:\n logging.error(\"Failed to set forward table\")\n return False\n\n ## Set up mirror table entries, use ingress_to_egress\n try:\n requester_mirror_entry = {'direction': 'ingress_to_egress',\n 'src-port': requester_nic_conf['switch-port'],\n 'dst-port': requester_mirror_nic_conf['switch-port']}\n\n responder_mirror_entry = {'direction': 'ingress_to_egress',\n 'src-port': responder_nic_conf['switch-port'],\n 'dst-port': responder_mirror_nic_conf['switch-port']}\n self.switch.conf['mirror-table'] = [requester_mirror_entry, responder_mirror_entry]\n except:\n logging.error(\"Failed to set mirror table\")\n return False\n\n requester_mac = requester_nic_conf['mac']\n responder_mac = responder_nic_conf['mac']\n requester_ip_list = requester_nic_conf['ip-list']\n responder_ip_list = responder_nic_conf['ip-list']\n ## Set up arp table entries\n arp_entries = []\n try:\n for dst_ip_list, dst_mac in zip([requester_ip_list, responder_ip_list],\n [requester_mac, responder_mac]):\n for dst_ip_subnet in dst_ip_list:\n dst_ip = dst_ip_subnet.split('/')[0]\n arp_entries.append({'dst-ip': dst_ip, 'dst-mac': dst_mac})\n self.switch.conf['arp-table'] = arp_entries\n except:\n logging.error(\"Failed to set ARP table\")\n return False\n\n ## Generate the events of each iteration for switch config\n per_iter_event_list = self.traffic_conf['data-pkt-events']\n msg_size = self.traffic_conf['message-size']\n mtu = self.traffic_conf['mtu']\n num_msgs_per_qp = self.traffic_conf['num-msgs-per-qp']\n num_pkts_per_msg = int(math.ceil(msg_size / mtu))\n self.switch.conf['traffic'] = {}\n self.switch.conf['traffic']['num-msgs-per-qp'] = num_msgs_per_qp\n self.switch.conf['traffic']['num-pkts-per-msg'] = num_pkts_per_msg\n self.switch.conf['traffic']['data-pkt-events'] = []\n\n if per_iter_event_list is None or len(per_iter_event_list) == 0:\n ## No events at all\n return True\n\n for i in range(num_msgs_per_qp):\n for per_iter_event in per_iter_event_list:\n global_event = copy.deepcopy(per_iter_event)\n\n ## This event is applied to all the packets of the message. We need to expand it!\n if str(global_event['psn']).lower() == 'all':\n for psn in range(num_pkts_per_msg):\n global_event['psn'] = psn + i * num_pkts_per_msg\n self.switch.conf['traffic']['data-pkt-events'].append(copy.deepcopy(global_event))\n else:\n global_event['psn'] += i * num_pkts_per_msg\n self.switch.conf['traffic']['data-pkt-events'].append(copy.deepcopy(global_event))\n\n return True\n\n def ping_mesh(self):\n \"\"\" Ping all the IP addresses between requester and responder to check the connectivity\n\n Returns:\n bool: True if all the IP addresses can be pinged successfully, False otherwise\n \"\"\"\n for requester_ip_subnet in self.requester.conf['nic']['ip-list']:\n requester_ip = requester_ip_subnet.split('/')[0]\n command = \"ping \" + requester_ip + \" -c 5 -i 0.2\"\n ret_val, err_info, exit_status = self.responder.execute_command(command)\n if exit_status != 0:\n logging.error(\"Failed to ping ip \" + requester_ip)\n logging.error(\"[Command return info]: %s %s\" % (', '.join(ret_val), ', '.join(err_info)))\n return False\n\n for responder_ip_subnet in self.responder.conf['nic']['ip-list']:\n responder_ip = responder_ip_subnet.split('/')[0]\n command = \"ping \" + responder_ip + \" -c 5 -i 0.2\"\n ret_val, err_info, exit_status = self.requester.execute_command(command)\n if exit_status != 0:\n logging.error(\"Failed to ping ip \" + responder_ip)\n logging.error(\"[Command return info]: %s %s\" % (ret_val, err_info))\n return False\n\n logging.info(\"Successfully pinged all the IP addresses between requester and responder\")\n return True\n\n def generate_switch_config_file(self):\n \"\"\" Generate the switch configuration file and copy it to the switch\n\n Returns:\n bool: True if the switch configuration file is generated and copied successfully, False otherwise\n \"\"\"\n ## Get the mac address for all the hosts\n self.requester.get_mac_address()\n self.responder.get_mac_address()\n self.requester_mirror.get_mac_address()\n self.responder_mirror.get_mac_address()\n\n ## Generate config for Match-Action table in switch\n if self.generate_switch_table_config() == False:\n logging.error(\"Failed to generate switch table configuration\")\n return False\n\n ## Dump the switch configuration into a file, and copy it to the switch\n if self.switch.dump_controller_config(self.local_workspace) == False:\n logging.error(\"Failed to dump switch config\")\n return False\n\n return True\n\n def __is_valid_traffc(self):\n \"\"\" Check if the traffic configuration is valid, including:\n 1. The tx-depth should be 1 or > 1\n 2. If tx-depth > 1, then we can only inject ECN marking events\n\n Returns:\n bool: True if the traffic configuration is valid, False otherwise\n \"\"\"\n try:\n data_pkt_events = self.traffic_conf['data-pkt-events']\n tx_depth = self.traffic_conf['tx-depth']\n\n if tx_depth == 1:\n return True\n elif tx_depth <= 0:\n return False\n\n for event in data_pkt_events:\n if event['type'] != 'ecn':\n logging.error(\"Cannot inject %s event when tx depth = %d\" % (event['type'], tx_depth))\n return False\n except:\n logging.error(\"Failed to parse traffic configuration\")\n return False\n\n return True\n\n def run_experiment(self):\n \"\"\" Run the experiment\n\n Returns:\n bool: True if the experiment is completed successfully, False otherwise\n \"\"\"\n\n ## Check if traffic configuration is valid\n if self.__is_valid_traffc() == False:\n logging.error(\"Invalid traffic configuration\")\n return False\n\n ## Run switch program\n if self.switch.run_switch() == False:\n logging.error(\"Failed to run switch\")\n return False\n\n ## Sleep for 1 second to make sure control plane is listenning (for client message)\n time.sleep(1)\n\n ## Configure the servers\n if self.requester.config_traffic_gen() == False:\n logging.error(\"Failed to config RDMA requester\")\n return False\n\n if self.responder.config_traffic_gen() == False:\n logging.error(\"Failed to config RDMA responder\")\n return False\n\n if self.requester_mirror.config_packet_capture() == False:\n logging.error(\"Failed to config packet capture on requester mirror\")\n return False\n\n if self.responder_mirror.config_packet_capture() == False:\n logging.error(\"Failed to config packet capture on responder mirror\")\n return False\n\n ## Check the connectivity through pingmesh (try 5 rounds)\n num_tries = 0\n pingmesh_ret = False\n\n while num_tries < 5:\n pingmesh_ret = self.ping_mesh()\n if pingmesh_ret == True:\n break\n num_tries += 1\n time.sleep(1)\n\n if pingmesh_ret == False:\n logging.error(\"Failed to ping all the IP addresses between requester and responder\")\n return False\n\n ## Launch packet capture for both side\n ## Prerequisite: config hugepage and igb_uio if needed\n if self.requester_mirror.run_packet_capture() == False:\n logging.error(\"Failed to run packet capture on requester mirror\")\n return False\n\n if self.responder_mirror.run_packet_capture() == False:\n logging.error(\"Failed to run packet capture on responder mirror\")\n return False\n\n time.sleep(3)\n\n ## Dump the counters before running\n if self.requester.dump_counters(host.REQ_START_COUNTER_FILE_NAME) == False:\n logging.error(\"Failed to dump counters on requester before running\")\n return False\n\n if self.responder.dump_counters(host.RSP_START_COUNTER_FILE_NAME) == False:\n logging.error(\"Failed to dump counters on responder before running\")\n return False\n\n ## Launch RDMA server first\n run_server_ret = self.responder.run_traffic_gen_server(self.traffic_conf)\n if run_server_ret == False:\n logging.error(\"Failed to run RDMA server\")\n return False\n\n time.sleep(2)\n\n ## Launch RDMA client\n try:\n destination_ip_subnet = self.responder.conf['nic']['ip-list'][0]\n destination_ip = destination_ip_subnet.split('/')[0]\n except:\n logging.error(\"Failed to get destination IP\")\n return False\n\n run_client_ret = self.requester.run_traffic_gen_client(traffic_conf=self.traffic_conf,\n destination_ip=destination_ip,\n controller_ip=self.switch.conf['control-ip'],\n controller_listen_port=self.switch.conf['listen-port'])\n if run_client_ret == False:\n logging.error(\"Failed to run RDMA client\")\n return False\n\n if self.switch.dump_results() == False:\n logging.error(\"Failed to dump results from switch\")\n return False\n\n if self.requester.dump_counters(host.REQ_FINISH_COUNTER_FILE_NAME) == False:\n logging.error(\"Failed to dump counters on requester after running\")\n return False\n\n if self.responder.dump_counters(host.RSP_FINISH_COUNTER_FILE_NAME) == False:\n logging.error(\"Failed to dump counters on responder after running\")\n return False\n\n logging.info(\"Experiment completed successfully\")\n return True\n\n def clean_up(self):\n \"\"\" Clean up the environment after the experiment\n\n Returns:\n bool: True if the clean up is completed successfully, False otherwise\n \"\"\"\n logging.info(\"Start cleaning up the environment\")\n\n if self.switch.clean_up() == False:\n logging.error(\"Failed to clean up switch\")\n return False\n\n if self.requester.clean_up() == False:\n logging.error(\"Failed to clean up requester\")\n return False\n\n if self.responder.clean_up() == False:\n logging.error(\"Failed to clean up responder\")\n return False\n\n if self.requester_mirror.clean_up() == False:\n logging.error(\"Failed to clean up requester mirror\")\n return False\n\n if self.responder_mirror.clean_up() == False:\n logging.error(\"Failed to clean up responder mirror\")\n return False\n\n return True\n\n def fetch_results(self, iter_id=0):\n \"\"\" Fetch the results of iteration 'iter_id', including:\n 1. Switch table entries and counters\n 2. Packet trace (pcap file)\n 3. Configs and end-to-end results from RDMA hosts\n\n Args:\n iter_id (int, optional): iteration ID, defaults to 0\n\n Returns:\n bool: True if the result collection is completed successfully, False otherwise\n \"\"\"\n ## Make the results dir if it does not exist\n iter_result_path = os.path.join(self.result_path, str(iter_id))\n cmd = \"mkdir -p %s\" % iter_result_path\n try:\n subprocess.call(cmd, shell=True)\n except:\n logging.error(\"Failed to create result directory %s\" % iter_result_path)\n return False\n\n if self.switch.fetch_results(iter_result_path) == False:\n logging.error(\"Failed to fetch results from switch\")\n return False\n\n if self.requester_mirror.fetch_results(iter_result_path) == False:\n logging.error(\"Failed to fetch results from requester mirror\")\n return False\n\n if self.responder_mirror.fetch_results(iter_result_path) == False:\n logging.error(\"Failed to fetch results from responder mirror\")\n return False\n\n if self.requester.fetch_results(iter_result_path) == False:\n logging.error(\"Failed to fetch results from requester\")\n return False\n\n if self.responder.fetch_results(iter_result_path) == False:\n logging.error(\"Failed to fetch results from responder\")\n return False\n\n logging.info(\"Finished fetching results for iteration %d\" % iter_id)\n return True\n\n def merge_traces(self, iter_id=0):\n iter_pcap_dir_path = os.path.join(self.result_path, str(iter_id), host.PCAP_RESULT_DIR)\n src_pcap_file_list = [os.path.join(iter_pcap_dir_path,\n self.requester_mirror.conf['pkt-dump-conf']['dump-filename']),\n os.path.join(iter_pcap_dir_path,\n self.responder_mirror.conf['pkt-dump-conf']['dump-filename'])]\n target_pcap_path = os.path.join(self.result_path,\n str(iter_id),\n host.PCAP_RESULT_DIR,\n self.aggregate_pcap_filename)\n packet_list = pcap_process.merge_pcaps(src_pcap_file_list)\n if packet_list is None:\n logging.error(\"Failed to merge pcap files for iteration %d\" % iter_id)\n return False\n\n if pcap_process.dump_pkts_to_pcap(target_pcap_path, packet_list) == False:\n logging.error(\"Failed to dump packets to pcap file %s\" % target_pcap_path)\n return False\n\n logging.info(\"Successfully merged pcap files for iteration %d\" % iter_id)\n\n def check_integrity(self, iter_id=0):\n ## Check if the collected packet trace passes integrity check\n pcap_path = os.path.join(self.result_path,\n str(iter_id),\n host.PCAP_RESULT_DIR,\n self.aggregate_pcap_filename)\n packet_list = get_packet_list(pcap_path)\n packet_list.sort(key=lambda x:x.get_switch_seqnum())\n logging.info(\"Packet trace sorted by switch sequence number.\")\n\n switch_state_snapshot = os.path.join(self.result_path,\n str(iter_id),\n switch.SWITCH_RESULT_DIR,\n switch.SWITCH_STATE_SNAPSHOT)\n port_map = {'requester': self.requester.conf['nic']['switch-port'],\n 'responder': self.responder.conf['nic']['switch-port'],\n 'requester-mirror': self.requester_mirror.conf['nic']['switch-port'],\n 'responder-mirror': self.responder_mirror.conf['nic']['switch-port']}\n switch_counter = SwitchCounter(switch_state_snapshot, port_map)\n\n integrity_checker = IntegrityCheck(packet_list=packet_list,\n switch_counter=switch_counter,\n requester_ip_list=self.get_requester_ip_list(),\n responder_ip_list=self.get_responder_ip_list())\n\n if integrity_checker.check() == True:\n logging.info(\"Integrity check passed\")\n return True\n else:\n logging.info(\"Integrity check failed\")\n return False"},{"identifier":"SwitchCounter","path":"lumina/analyzer/counter/switch_counter.py","snippet":"class SwitchCounter:\n \"\"\" Class to parse switch counter files\n\n Attributes:\n _counter (dict of dict): the switch counters with the following format:\n {'requester': {'ingress': counter_value, 'egress': counter_value},\n 'responder': {'ingress': counter_value, 'egress': counter_value},\n 'requester-mirror': {'ingress': counter_value, 'egress': counter_value},\n 'responder-mirror': {'ingress': counter_value, 'egress': counter_value}}\n \"\"\"\n def __init__(self, snapshot_filename, port_map):\n \"\"\" Constructor\n\n Args:\n snapshot_filename (str): the file where switch dumps its counters\n port_map (dict): the mapping between port name and port number\n\n Returns:\n N/A\n \"\"\"\n with open(snapshot_filename, \"r\") as stream:\n conf = yaml.safe_load(stream)\n try:\n ingress_counters = conf['counter']['ingress']\n egress_counters = conf['counter']['egress']\n except:\n print(\"Bad yaml format in %s\" % snapshot_filename)\n sys.exit(-1)\n\n requester_port = port_map['requester']\n responder_port = port_map['responder']\n requester_mirror_port = port_map['requester-mirror']\n responder_mirror_port = port_map['responder-mirror']\n\n self._counter = {'requester' : {'ingress':0, 'egress': 0},\n 'responder' : {'ingress':0, 'egress': 0},\n 'requester-mirror' : {'ingress':0, 'egress': 0},\n 'responder-mirror' : {'ingress':0, 'egress': 0}}\n try:\n self._counter['requester']['ingress'] = ingress_counters[requester_port]\n self._counter['responder']['ingress'] = ingress_counters[responder_port]\n self._counter['requester-mirror']['ingress'] = ingress_counters[requester_mirror_port]\n self._counter['responder-mirror']['ingress'] = ingress_counters[responder_mirror_port]\n\n self._counter['requester']['egress'] = egress_counters[requester_port]\n self._counter['responder']['egress'] = egress_counters[responder_port]\n self._counter['requester-mirror']['egress'] = egress_counters[requester_mirror_port]\n self._counter['responder-mirror']['egress'] = egress_counters[responder_mirror_port]\n\n except:\n print(\"Port number not exist in the switch snapshot\")\n sys.exit(-1)\n\n def get_counter(self):\n \"\"\" Return the switch counters (dict of dict) \"\"\"\n return self._counter"},{"identifier":"MLNXHostCounter","path":"lumina/analyzer/counter/host_counter.py","snippet":"class MLNXHostCounter(HostCounter):\n \"\"\" Class to parse MLNX host counter files \"\"\"\n def __init__(self, counter_start_filename, counter_finish_filename):\n \"\"\" Constructor\n\n Args:\n counter_start_filename (str): the file where host dumps its counters at the start phase\n counter_finish_filename (str): the file where host dumps its counters at the finish phase\n\n Returns:\n N/A\n \"\"\"\n super().__init__(counter_start_filename, counter_finish_filename)\n\n def get_port_rcv_packets(self):\n \"\"\" Return the number of received packets \"\"\"\n return self._counter['port-counters']['port_rcv_packets']\n\n def get_port_xmit_packets(self):\n \"\"\" Return the number of transmitted packets \"\"\"\n return self._counter['port-counters']['port_xmit_packets']\n\n def get_num_packet_seq_err(self):\n \"\"\" Return the number of received NAK sequence error packets \"\"\"\n return self._counter['hw-counters']['packet_seq_err']\n\n def get_num_out_of_sequence(self):\n \"\"\" Return the number of out-of-sequence packets received \"\"\"\n return self._counter['hw-counters']['out_of_sequence']\n\n def get_num_dup_requests(self):\n \"\"\" Return the number of duplicate requests \"\"\"\n return self._counter['hw-counters']['duplicate_request']\n\n def implied_nak_seq_err(self):\n \"\"\" Return the number of READ requests implying sequence errors \"\"\"\n return self._counter['hw-counters']['implied_nak_seq_err']\n\n def get_num_cnp_sent(self):\n \"\"\" Return the number of congestion notification packets sent by notification point \"\"\"\n return self._counter['hw-counters']['np_cnp_sent']\n\n def get_num_ecn_marked_packets(self):\n \"\"\" Return the number of ECN marked RoCEv2 packets received by notification point \"\"\"\n return self._counter['hw-counters']['np_ecn_marked_roce_packets']\n\n def get_num_cnp_handled(self):\n \"\"\" Return the number of congestion notification packets handled by reaction point \"\"\"\n return self._counter['hw-counters']['rp_cnp_handled']\n\n def get_num_icrc_errors(self):\n \"\"\" Return the number of RoCE packets with ICRC errors received \"\"\"\n return self._counter['hw-counters']['rx_icrc_encapsulated']\n\n def get_num_timeout_err(self):\n \"\"\" Return the number of times QP's ack timer expired for RC, XRC, DCT QPs at the sender side \"\"\"\n return self._counter['hw-counters']['local_ack_timeout_err']\n\n def get_num_discards_dict_tx(self):\n \"\"\" Return the number of TX discarded packets (dict)\"\"\"\n discards_dict_tx = {}\n for x in self._counter['ethtool-counters'].keys():\n if 'discard' in x and 'tx' in x:\n discards_dict_tx[x] = self._counter['ethtool-counters'][x]\n return discards_dict_tx\n\n def get_num_discards_dict_rx(self):\n \"\"\" Return the number of RX discarded packets (dict) \"\"\"\n discards_dict_rx = {}\n for x in self._counter['ethtool-counters'].keys():\n if 'discard' in x and 'rx' in x:\n discards_dict_rx[x] = self._counter['ethtool-counters'][x]\n return discards_dict_rx"},{"identifier":"IntelHostCounter","path":"lumina/analyzer/counter/host_counter.py","snippet":"class IntelHostCounter(HostCounter):\n \"\"\" Class to parse Intel host counter files \"\"\"\n def __init__(self, counter_start_filename, counter_finish_filename):\n \"\"\" Constructor\n\n Args:\n counter_start_filename (str): the file where host dumps its counters at the start phase\n counter_finish_filename (str): the file where host dumps its counters at the finish phase\n\n Returns:\n N/A\n \"\"\"\n super().__init__(counter_start_filename, counter_finish_filename)\n\n def get_num_cnp_sent(self):\n \"\"\" Return the number of congestion notification packets sent by notification point \"\"\"\n return self._counter['hw-counters']['cnpSent']\n\n def get_num_ecn_marked_packets(self):\n \"\"\" Return the number of ECN marked RoCEv2 packets received by notification point \"\"\"\n return self._counter['hw-counters']['RxECNMrkd']\n\n def get_num_cnp_handled(self):\n \"\"\" Return the number of congestion notification packets handled by reaction point \"\"\"\n return self._counter['hw-counters']['cnpHandled']\n\n def get_num_discards_dict(self):\n \"\"\" Return the number of discarded packets (dict) \"\"\"\n discards_dict= {}\n for x in self._counter['hw-counters'].keys():\n if 'discard' in x:\n discards_dict[x] = self._counter['hw-counters'][x]\n return discards_dict"},{"identifier":"get_packet_list","path":"lumina/analyzer/pcap_processor/pcap_process.py","snippet":"def get_packet_list(pcap_file):\n \"\"\" Read a pcap file and return a list of packets\n\n Args:\n pcap_file (str): The pcap file to read\n\n Returns:\n list: The list of packets if successful, empty list otherwise\n\n Raises:\n IOError: If the pcap file cannot be opened for reading\n Exception: If the pcap file cannot be read\n \"\"\"\n packet_list = []\n try:\n with open(pcap_file, 'rb') as file_read:\n pcap = dpkt.pcap.Reader(file_read)\n for packet in pcap:\n packet_list.append(roce_packet.RRoCEPacket(packet))\n except IOError:\n logging.error(\"Unable to open pcap file %s. Please check your filename.\" % pcap_file)\n raise IOError\n\n except:\n logging.error(\"Failed to read pcap file %s.\" % pcap_file)\n raise Exception\n\n logging.info(\"Successfully read %d packets from %s.\" % (len(packet_list), pcap_file))\n return packet_list"},{"identifier":"LatencyMeasure","path":"lumina/analyzer/measurer/latency_measure.py","snippet":"class LatencyMeasure:\n \"\"\" Class to measure the latency between packets for some events,\n e.g., NACK latency, Retransmission latency, CNP latency\n\n Attributes:\n packet_list (list of RRoCEPacket objects): list of packets\n qp_info_list (list of dict): list of QP info with the following format:\n [{'psn_rcv': initial packet sequence number from the receiver qp,\n 'psn_snd': initial packet sequence number from the sender qp,\n 'qpn_rcv': receiver qp number,\n 'qpn_snd': sender qp number,\n 'ip_rcv' : receiver IP\n 'ip_snd' : sender IP}]\n is_read (bool): if the QPs use RDMA read verb\n \"\"\"\n def __init__(self, packet_list, qp_info_list, is_read=False):\n \"\"\" Constructor\n\n Args:\n packet_list (list of RRoCEPacket objects): list of packets\n qp_info_list (list of dict): list of QP info with the following format:\n [{'psn_rcv': initial packet sequence number from the receiver qp,\n 'psn_snd': initial packet sequence number from the sender qp,\n 'qpn_rcv': receiver qp number,\n 'qpn_snd': sender qp number,\n 'ip_rcv' : receiver IP\n 'ip_snd' : sender IP}]\n is_read (bool): if the QPs use RDMA read verb (default: False)\n\n Returns:\n N/A\n \"\"\"\n self.packet_list = packet_list\n self.qp_info_list = qp_info_list\n self.is_read = is_read\n\n def get_peer_qp_info(self, dest_qpn, dest_ip):\n \"\"\" Get the info of the peer QP (qpn, ip) of a given qp (qpn, ip)\n\n Args:\n dest_qpn (int): destination QP number\n dest_ip (str): destination IP\n\n Returns:\n int: peer QP number (None if not found)\n str: peer IP (None if not found)\n \"\"\"\n for qp_info in self.qp_info_list:\n if qp_info['qpn_snd'] == dest_qpn and qp_info['ip_snd'] == dest_ip:\n return qp_info['qpn_rcv'], qp_info['ip_rcv']\n elif qp_info['qpn_rcv'] == dest_qpn and qp_info['ip_rcv'] == dest_ip:\n return qp_info['qpn_snd'], qp_info['ip_snd']\n\n return None, None\n\n def get_bit_error_pkts(self, relative_dest_qpn=None):\n \"\"\" Get the packets marked with bit error flag\n\n Args:\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\n\n Returns:\n list of RRoCEPacket objects: the list of packets marked with bit error flag\n \"\"\"\n error_pkt_list = []\n\n if relative_dest_qpn != None:\n dest_qpn = self.qp_info_list[relative_dest_qpn]['qpn_rcv']\n dest_ip = self.qp_info_list[relative_dest_qpn]['ip_rcv']\n\n for packet in self.packet_list:\n if packet.is_bit_error() == False:\n continue\n\n if relative_dest_qpn == None or \\\n (packet.get_roce_dest_qp() == dest_qpn and packet.get_dst_ip() == dest_ip):\n error_pkt_list.append(packet)\n\n return error_pkt_list\n\n def get_dropped_pkts(self, relative_dest_qpn=None):\n \"\"\" Get the packets marked with drop flag\n\n Args:\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\n\n Returns:\n list of RRoCEPacket objects: the list of packets marked with drop flag\n \"\"\"\n dropped_pkt_list = []\n\n if relative_dest_qpn != None:\n dest_qpn = self.qp_info_list[relative_dest_qpn]['qpn_rcv']\n dest_ip = self.qp_info_list[relative_dest_qpn]['ip_rcv']\n\n for packet in self.packet_list:\n if packet.is_dropped() == False:\n continue\n\n if relative_dest_qpn == None or \\\n (packet.get_roce_dest_qp() == dest_qpn and packet.get_dst_ip() == dest_ip):\n dropped_pkt_list.append(packet)\n\n return dropped_pkt_list\n\n def get_ecn_pkts(self):\n \"\"\" Get the packets marked with ECN\n\n Returns:\n list of RRoCEPacket objects: the list of packets marked with ECN\n \"\"\"\n ecn_pkt_list = []\n\n for packet in self.packet_list:\n if packet.is_ecn():\n ecn_pkt_list.append(packet)\n\n return ecn_pkt_list\n\n def get_cnp_pkts(self):\n \"\"\" Get the congestion notification packets\n\n Returns:\n list of RRoCEPacket objects: the list of congestion notification packets\n \"\"\"\n cnp_pkt_list = []\n\n for packet in self.packet_list:\n if packet.is_cnp():\n cnp_pkt_list.append(packet)\n\n return cnp_pkt_list\n\n def get_undelivered_pkts(self, relative_dest_qpn = None):\n \"\"\" Get the undelivered packets (dropped or marked with bit error)\n\n Args:\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\n\n Returns:\n list of RRoCEPacket objects: the list of undelivered packets\n \"\"\"\n undelivered_pkt_list = []\n\n if relative_dest_qpn != None:\n dest_qpn = self.qp_info_list[relative_dest_qpn]['qpn_rcv']\n dest_ip = self.qp_info_list[relative_dest_qpn]['ip_rcv']\n\n for packet in self.packet_list:\n if packet.is_delivered() == True:\n continue\n\n if relative_dest_qpn == None or \\\n (packet.get_roce_dest_qp() == dest_qpn and packet.get_dst_ip() == dest_ip):\n undelivered_pkt_list.append(packet)\n\n return undelivered_pkt_list\n\n def get_nack(self, undelivered_pkt):\n \"\"\" Given an undelivered packet, return the NACK packet that triggers its retransmission.\n If there's no NACK packet found for the undelivered packet, return None.\n Note that for RDMA READ, NACK is essentially a READ request packet that triggers retransmission\n\n Args:\n undelivered_pkt (RRoCEPacket object): the undelivered packet\n\n Returns:\n RRoCEPacket object: the NACK packet that triggers the retransmission of the undelivered packet\n (None if not found)\n \"\"\"\n undelivered_pkt_dest_qpn = undelivered_pkt.get_roce_dest_qp()\n undelivered_pkt_dst_ip = undelivered_pkt.get_dst_ip()\n undelivered_pkt_psn = undelivered_pkt.get_roce_pkt_seq()\n undelivered_pkt_switch_seqnum = undelivered_pkt.get_switch_seqnum()\n matched_dest_qpn, matched_dst_ip = self.get_peer_qp_info(undelivered_pkt_dest_qpn, undelivered_pkt_dst_ip)\n\n if matched_dest_qpn == None or matched_dst_ip == None:\n logging.error(\"QP info of the undelivered packet not found in qp_info_list dumped by switch\")\n return None\n\n for packet in self.packet_list:\n if self.is_same_roce_data_pkt(packet, undelivered_pkt) and \\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\n return None\n\n if ((self.is_read and packet.is_roce_read_req()) or packet.is_roce_nack()) and \\\n packet.get_dst_ip() == matched_dst_ip and \\\n packet.get_roce_dest_qp() == matched_dest_qpn and \\\n packet.get_roce_pkt_seq() == undelivered_pkt_psn and \\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\n ## We return the first packet appears after the undelivered packet and matches the undelivered packet\n return packet\n\n return None\n\n def get_qp_first_nack_before_retrans(self, undelivered_pkt):\n \"\"\" For an undelivered packet, return the first NACK packet on its QP between it and its retransmission.\n If there's no NACK packet found before the retransmission, return None.\n Note that for RDMA READ, NACK is essentially a READ request packet\n\n Args:\n undelivered_pkt (RRoCEPacket object): the undelivered packet\n\n Returns:\n RRoCEPacket object: the first NACK packet on the QP between the undelivered packet and its retransmission\n (None if not found)\n \"\"\"\n undelivered_pkt_dest_qpn = undelivered_pkt.get_roce_dest_qp()\n undelivered_pkt_dst_ip = undelivered_pkt.get_dst_ip()\n undelivered_pkt_psn = undelivered_pkt.get_roce_pkt_seq()\n undelivered_pkt_switch_seqnum = undelivered_pkt.get_switch_seqnum()\n matched_dest_qpn, matched_dst_ip = self.get_peer_qp_info(undelivered_pkt_dest_qpn, undelivered_pkt_dst_ip)\n\n if matched_dest_qpn == None or matched_dst_ip == None:\n logging.error(\"QP info of the undelivered packet not found in qp_info_list dumped by switch\")\n return None\n\n for packet in self.packet_list:\n if self.is_same_roce_data_pkt(packet, undelivered_pkt) and \\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\n return None\n\n if ((self.is_read and packet.is_roce_read_req()) or packet.is_roce_nack()) and \\\n packet.get_dst_ip() == matched_dst_ip and \\\n packet.get_roce_dest_qp() == matched_dest_qpn and \\\n packet.get_roce_pkt_seq() <= undelivered_pkt_psn and \\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\n return packet\n\n return None\n\n def get_qp_next_delivered_pkt(self, current_pkt):\n \"\"\" For a packet, return the next delivered packet on the same QP.\n\n Args:\n current_pkt (RRoCEPacket object): the current packet\n\n Returns:\n RRoCEPacket object: the next delivered packet on the same QP (None if not found)\n \"\"\"\n switch_seqnum = current_pkt.get_switch_seqnum()\n\n for packet in self.packet_list:\n if self.is_same_qp_roce_data_pkt(packet, current_pkt) and \\\n packet.get_switch_seqnum() > switch_seqnum and \\\n packet.is_delivered():\n return packet\n\n return None\n\n def get_retransmit_pkt(self, undelivered_pkt):\n \"\"\" Given an undelivered packet, return its retransmission packet.\n\n Args:\n undelivered_pkt (RRoCEPacket object): the undelivered packet\n\n Returns:\n RRoCEPacket object: the retransmission packet of the undelivered packet (None if not found)\n \"\"\"\n undelivered_pkt_switch_seqnum = undelivered_pkt.get_switch_seqnum()\n\n for packet in self.packet_list:\n if self.is_same_roce_data_pkt(packet, undelivered_pkt) and \\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\n ## We return the first packet appears after the undelivered packet and matches the undelivered packet\n return packet\n\n return None\n\n def get_latency_between_pkts(self, packet_alpha, packet_beta):\n \"\"\" Return the time of packet_beta - time of packet_alpha in seconds\n\n Args:\n packet_alpha (RRoCEPacket object): the first packet\n packet_beta (RRoCEPacket object): the second packet\n\n Returns:\n float: the time difference between two packets in seconds\n \"\"\"\n return packet_beta.get_switch_timestamp() - packet_alpha.get_switch_timestamp()\n\n def is_same_roce_data_pkt(self, packet_alpha, packet_beta):\n \"\"\" Return if two packets are the same RoCE data packet (same src ip, dst ip, dest qp, and psn)\n\n Args:\n packet_alpha (RRoCEPacket object): the first packet\n packet_beta (RRoCEPacket object): the second packet\n\n Returns:\n bool: True if two packets are the same RoCE data packet, False otherwise\n \"\"\"\n return packet_alpha.get_src_ip() == packet_beta.get_src_ip() and \\\n packet_alpha.get_dst_ip() == packet_beta.get_dst_ip() and \\\n packet_alpha.get_roce_dest_qp() == packet_beta.get_roce_dest_qp() and \\\n packet_alpha.get_roce_pkt_seq() == packet_beta.get_roce_pkt_seq()\n\n def is_same_qp_roce_data_pkt(self, packet_alpha, packet_beta):\n \"\"\" Return if two packets are RoCE data packets on the same QP (same src ip, dst ip, and dest qp)\n\n Args:\n packet_alpha (RRoCEPacket object): the first packet\n packet_beta (RRoCEPacket object): the second packet\n\n Returns:\n bool: True if two packets are RoCE data packets on the same QP, False otherwise\n \"\"\"\n return packet_alpha.get_src_ip() == packet_beta.get_src_ip() and \\\n packet_alpha.get_dst_ip() == packet_beta.get_dst_ip() and \\\n packet_alpha.get_roce_dest_qp() == packet_beta.get_roce_dest_qp()\n\n def get_qp_next_delivered_pkt_latency(self, pkt):\n \"\"\" Get the latency between 'pkt' and next 'delivered' packet on the same QP\n\n Args:\n pkt (RRoCEPacket object): the packet\n\n Returns:\n float: the latency between 'pkt' and next 'delivered' packet on the same QP\n (None if not found)\n \"\"\"\n\n next_pkt = self.get_qp_next_delivered_pkt(pkt)\n if next_pkt is None:\n return None\n\n return self.get_latency_between_pkts(pkt, next_pkt)\n\n def get_nack_gen_latency(self, undelivered_pkt):\n \"\"\" For an undelivered packet, return the NACK generation latency, i.e., the duration from the detection of\n the undelivered packet to the generation of the NACK packet that triggers its retransmission.\n\n Args:\n undelivered_pkt (RRoCEPacket object): the undelivered packet\n\n Returns:\n float: the NACK generation latency for the undelivered packet (None if not found)\n \"\"\"\n nack_pkt = self.get_nack(undelivered_pkt)\n if nack_pkt == None:\n return None\n\n # NACK should be triggered by the next delivered packet on the same QP\n next_delivered_pkt = self.get_qp_next_delivered_pkt(undelivered_pkt)\n if self.is_same_roce_data_pkt(next_delivered_pkt, undelivered_pkt):\n # We should never reach here\n return None\n\n nack_gen_latency = self.get_latency_between_pkts(next_delivered_pkt, nack_pkt)\n return nack_gen_latency\n\n def get_nack_resp_latency(self, undelivered_pkt):\n \"\"\" For an undelivered packet, return the NACK response latency, i.e., the duration from the generation of\n the NACK packet to the retransmission of this undelivered packet.\n\n Args:\n undelivered_pkt (RRoCEPacket object): the undelivered packet\n\n Returns:\n float: the NACK response latency for the undelivered packet (None if not found)\n \"\"\"\n nack_pkt = self.get_nack(undelivered_pkt)\n if nack_pkt == None:\n return None\n\n retransmit_pkt = self.get_retransmit_pkt(undelivered_pkt)\n if retransmit_pkt == None:\n return None\n\n nack_resp_latency = self.get_latency_between_pkts(nack_pkt, retransmit_pkt)\n return nack_resp_latency\n\n def get_retransmit_latency(self, undelivered_pkt):\n \"\"\" For an undelivered packet, return the retransmission latency, i.e., the duration from the packet\n to its retransmission.\n\n Args:\n undelivered_pkt (RRoCEPacket object): the undelivered packet\n\n Returns:\n float: the retransmission latency for the undelivered packet (None if not found)\n \"\"\"\n retransmit_pkt = self.get_retransmit_pkt(undelivered_pkt)\n if retransmit_pkt == None:\n return None\n\n retransmit_latency = self.get_latency_between_pkts(undelivered_pkt, retransmit_pkt)\n return retransmit_latency\n\n def get_nack_gen_latency_list(self, relative_dest_qpn=None):\n \"\"\" Return a list of NACK generation latency for all undelivered packets with relative_dest_qpn\n\n Args:\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\n\n Returns:\n list of float: a list of NACK generation latency for all undelivered packets with relative_dest_qpn\n \"\"\"\n undelivered_pkts = self.get_undelivered_pkts(relative_dest_qpn)\n nack_latency_list = []\n\n for undelivered_pkt in undelivered_pkts:\n nack_pkt = self.get_nack(undelivered_pkt)\n if nack_pkt == None:\n nack_latency_list.append(None)\n else:\n nack_latency = self.get_latency_between_pkts(undelivered_pkt, nack_pkt)\n nack_latency_list.append(nack_latency)\n\n return nack_latency_list\n\n def get_retransmit_latency_list(self, relative_dest_qpn):\n \"\"\" Return a list of retransmission latency for all undelivered packets with relative_dest_qpn\n\n Args:\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\n\n Returns:\n list of float: a list of retransmission latency for all undelivered packets with relative_dest_qpn\n \"\"\"\n undelivered_pkts = self.get_undelivered_pkts(relative_dest_qpn)\n retransmit_latency_list = []\n\n for undelivered_pkt in undelivered_pkts:\n retransmit_pkt = self.get_retransmit_pkt(undelivered_pkt)\n if retransmit_pkt == None:\n retransmit_latency_list.append(None)\n else:\n retransmit_latency = self.get_latency_between_pkts(undelivered_pkt, retransmit_pkt)\n retransmit_latency_list.append(retransmit_latency)\n\n return retransmit_latency_list"},{"identifier":"config_stream_handler","path":"lumina/utils/config_loggers.py","snippet":"def config_stream_handler(logger):\n \"\"\" Configure stream handler\n\n Args:\n logger (logging.Logger): Logger object\n\n Returns:\n N/A\n \"\"\"\n logger.setLevel(logging.INFO)\n console = logging.StreamHandler()\n console.setLevel(logging.INFO)\n console.setFormatter(logging.Formatter('%(name)-18s: %(levelname)-8s %(message)s'))\n logger.addHandler(console)"},{"identifier":"config_file_handler","path":"lumina/utils/config_loggers.py","snippet":"def config_file_handler(logger, log_file, no_format=False):\n \"\"\" Configure file handler\n\n Args:\n logger (logging.Logger): Logger object\n log_file (str): Log file path\n no_format (bool): If True, do not format log messages (default: False)\n\n Returns:\n N/A\n \"\"\"\n logger.setLevel(logging.INFO)\n file_handler = logging.FileHandler(log_file, mode=\"w\")\n if no_format == False:\n file_handler.setFormatter(logging.Formatter('%(name)-18s: %(levelname)-8s %(message)s'))\n file_handler.setLevel(logging.INFO)\n logger.addHandler(file_handler)"},{"identifier":"TRIGGER_OOS","path":"lumina/analyzer/packet_parser/roce_packet.py","snippet":"TRIGGER_OOS = 1"},{"identifier":"TRIGGER_TIMEOUT","path":"lumina/analyzer/packet_parser/roce_packet.py","snippet":"TRIGGER_TIMEOUT = 2"}],"string":"[\n {\n \"identifier\": \"get_qp_info_list\",\n \"path\": \"lumina/analyzer/main.py\",\n \"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 list of dict: The list of queue pair (QP) information if successful or None otherwise.\\n The list of QP information is in the following format:\\n [{'psn_rcv': initial packet sequence number from the receiver qp,\\n 'psn_snd': initial packet sequence number from the sender qp,\\n 'qpn_rcv': receiver qp number,\\n 'qpn_snd': sender qp number,\\n 'ip_rcv' : receiver IP\\n 'ip_snd' : sender IP}]\\n \\\"\\\"\\\"\\n try:\\n with open(switch_msg_snapshot, 'r') as stream:\\n qp_info_list = yaml.safe_load(stream)\\n except:\\n logging.error(\\\"Read switch message snapshot %s error.\\\" % switch_msg_snapshot)\\n return None\\n\\n logging.info(\\\"Read switch message snapshot %s.\\\" % switch_msg_snapshot)\\n return qp_info_list\"\n },\n {\n \"identifier\": \"Orchestrator\",\n \"path\": \"lumina/orchestrator/main.py\",\n \"snippet\": \"class Orchestrator:\\n \\\"\\\"\\\" Class to manage the experiment \\\"\\\"\\\"\\n def __init__(self, config_file):\\n \\\"\\\"\\\" Constructor for Orchestrator class\\n\\n Args:\\n config_file (str): path to the yaml (config) file.\\n The file contains configs for switch, requester, responder, traffic, etc.\\n\\n Returns:\\n N/A\\n \\\"\\\"\\\"\\n with open(config_file, \\\"r\\\") as stream:\\n conf = yaml.safe_load(stream)\\n try:\\n local_workspace = conf['local-workspace']\\n result_path = conf['result-path']\\n switch_conf = conf['switch']\\n requester_conf = conf['requester']\\n responder_conf = conf['responder']\\n requester_mirror_conf = conf['requester-mirror']\\n responder_mirror_conf = conf['responder-mirror']\\n traffic_conf = conf['traffic']\\n rewrite_udp_dst_port = conf['rewrite-udp-dst-port']\\n num_repeats = conf['num-repeats']\\n agg_pcap_filename = conf['aggregate-pcap-filename']\\n except KeyError as e:\\n print(\\\"Config file %s has a bad yaml format (key error: %s)\\\" % (config_file, e))\\n sys.exit(-1)\\n\\n switch_conf['rewrite-udp-dst-port'] = rewrite_udp_dst_port\\n requester_mirror_conf['pkt-dump-conf']['rewrite-udp-dst-port'] = rewrite_udp_dst_port\\n responder_mirror_conf['pkt-dump-conf']['rewrite-udp-dst-port'] = rewrite_udp_dst_port\\n\\n self.local_workspace = local_workspace\\n self.result_path = result_path\\n self.traffic_conf = traffic_conf\\n self.num_repeats = num_repeats\\n self.switch = switch.Switch(switch_conf)\\n self.requester = host.RDMAHost(requester_conf)\\n self.responder = host.RDMAHost(responder_conf)\\n self.requester_mirror = host.MirrorHost(requester_mirror_conf)\\n self.responder_mirror = host.MirrorHost(responder_mirror_conf)\\n self.aggregate_pcap_filename = agg_pcap_filename\\n\\n cmd = \\\"mkdir -p %s\\\" % self.result_path\\n subprocess.call(cmd, shell = True)\\n\\n def rm_old_files(self):\\n \\\"\\\"\\\" Remove result files left by previous experiments \\\"\\\"\\\"\\n old_iter_id = 0\\n old_iter_result_path = os.path.join(self.result_path, str(old_iter_id))\\n\\n while os.path.exists(old_iter_result_path) and not os.path.isfile(old_iter_result_path):\\n cmd = \\\"rm -rf %s\\\" % (old_iter_result_path)\\n subprocess.call(cmd, shell=True)\\n\\n old_iter_id += 1\\n old_iter_result_path = os.path.join(self.result_path, str(old_iter_id))\\n\\n def get_requester_ip_list(self):\\n \\\"\\\"\\\" Return the list of requester IP addresses (without prefix length info) \\\"\\\"\\\"\\n return [x.split('/')[0] for x in self.requester.conf['nic']['ip-list']]\\n\\n def get_responder_ip_list(self):\\n \\\"\\\"\\\" Return the list of responder IP addresses (without prefix length info) \\\"\\\"\\\"\\n return [x.split('/')[0] for x in self.responder.conf['nic']['ip-list']]\\n\\n def get_num_repeats(self):\\n \\\"\\\"\\\" Return the number of experiment repeats \\\"\\\"\\\"\\n return self.num_repeats\\n\\n def sync_and_compile(self):\\n \\\"\\\"\\\" Syncronize and compile the code on all the hosts\\n\\n Returns:\\n bool: True if the code is synced and compiled successfully, False otherwise\\n \\\"\\\"\\\"\\n logging.info(\\\"Sync and compile the code\\\")\\n\\n ## Sync and compile the switch code\\n ret = self.switch.sync_and_compile(self.local_workspace,\\n switch.SWITCH_PROG_DIR_NAME,\\n switch.SWITCH_PROG_FILE_NAME)\\n if ret == False:\\n logging.error(\\\"Failed to sync and compile the switch code\\\")\\n return False\\n\\n ## Sync and compile the traffic generator code\\n rdma_verb = self.traffic_conf['rdma-verb'].strip().lower()\\n if rdma_verb not in host.VALID_IB_VERB_LIST_LOWER:\\n logging.error(\\\"Invalid RDMA verb: %s\\\" % rdma_verb)\\n return False\\n\\n ret = self.requester.sync_and_compile(local_workspace=self.local_workspace,\\n prog_dir_name=self.requester.traffic_gen_dir_name(),\\n prog_file_name=self.requester.traffic_gen_client_name(rdma_verb))\\n if ret == False:\\n logging.error(\\\"Failed to sync and compile the traffic generator code on requester\\\")\\n return False\\n\\n ret = self.responder.sync_and_compile(local_workspace=self.local_workspace,\\n prog_dir_name=self.requester.traffic_gen_dir_name(),\\n prog_file_name=self.requester.traffic_gen_server_name(rdma_verb))\\n if ret == False:\\n logging.error(\\\"Failed to sync and compile the traffic generator code on responder\\\")\\n return False\\n\\n ret = self.requester.sync(local_workspace=self.local_workspace,\\n prog_dir_name=host.DUMP_COUNTER_DIR_NAME)\\n if ret == False:\\n logging.error(\\\"Failed to sync the dump counter code on requester\\\")\\n return False\\n\\n ret = self.responder.sync(local_workspace=self.local_workspace,\\n prog_dir_name=host.DUMP_COUNTER_DIR_NAME)\\n if ret == False:\\n logging.error(\\\"Failed to sync the dump counter code on responder\\\")\\n return False\\n\\n ## Sync and compile the packet capture code\\n ret = self.requester_mirror.sync_and_compile(local_workspace=self.local_workspace,\\n prog_dir_name=host.PKT_CAPTURE_DIR_NAME,\\n prog_file_name=host.PKT_CAPTURE_FILE_NAME)\\n if ret == False:\\n logging.error(\\\"Failed to sync and compile the packet capture code on requester_mirror\\\")\\n return False\\n\\n ret = self.responder_mirror.sync_and_compile(local_workspace=self.local_workspace,\\n prog_dir_name=host.PKT_CAPTURE_DIR_NAME,\\n prog_file_name=host.PKT_CAPTURE_FILE_NAME)\\n if ret == False:\\n logging.error(\\\"Failed to sync and compile the packet capture code on responder_mirror\\\")\\n return False\\n\\n return True\\n\\n def generate_switch_table_config(self):\\n \\\"\\\"\\\" Generate the switch configuration, including:\\n 1. Forward table\\n 2. Mirror table\\n 3. ARP table\\n 4. Traffic table, including the events to inject\\n\\n Returns:\\n bool: True if the switch configuration is generated successfully, False otherwise\\n \\\"\\\"\\\"\\n requester_nic_conf = self.requester.conf['nic']\\n responder_nic_conf = self.responder.conf['nic']\\n requester_mirror_nic_conf = self.requester_mirror.conf['nic']\\n responder_mirror_nic_conf = self.responder_mirror.conf['nic']\\n\\n ## Set up forward table entries\\n self.switch.conf['forward-table'] = []\\n try:\\n for nic_conf, host_type in zip([requester_nic_conf, responder_nic_conf, \\\\\\n requester_mirror_nic_conf, responder_mirror_nic_conf],\\n ['requester', 'responder', 'requester_mirror', 'responder_mirror']):\\n forward_table_entry = {'dst-mac': nic_conf['mac'],\\n 'eg-port': nic_conf['switch-port'],\\n 'host': host_type}\\n self.switch.conf['forward-table'].append(forward_table_entry)\\n except:\\n logging.error(\\\"Failed to set forward table\\\")\\n return False\\n\\n ## Set up mirror table entries, use ingress_to_egress\\n try:\\n requester_mirror_entry = {'direction': 'ingress_to_egress',\\n 'src-port': requester_nic_conf['switch-port'],\\n 'dst-port': requester_mirror_nic_conf['switch-port']}\\n\\n responder_mirror_entry = {'direction': 'ingress_to_egress',\\n 'src-port': responder_nic_conf['switch-port'],\\n 'dst-port': responder_mirror_nic_conf['switch-port']}\\n self.switch.conf['mirror-table'] = [requester_mirror_entry, responder_mirror_entry]\\n except:\\n logging.error(\\\"Failed to set mirror table\\\")\\n return False\\n\\n requester_mac = requester_nic_conf['mac']\\n responder_mac = responder_nic_conf['mac']\\n requester_ip_list = requester_nic_conf['ip-list']\\n responder_ip_list = responder_nic_conf['ip-list']\\n ## Set up arp table entries\\n arp_entries = []\\n try:\\n for dst_ip_list, dst_mac in zip([requester_ip_list, responder_ip_list],\\n [requester_mac, responder_mac]):\\n for dst_ip_subnet in dst_ip_list:\\n dst_ip = dst_ip_subnet.split('/')[0]\\n arp_entries.append({'dst-ip': dst_ip, 'dst-mac': dst_mac})\\n self.switch.conf['arp-table'] = arp_entries\\n except:\\n logging.error(\\\"Failed to set ARP table\\\")\\n return False\\n\\n ## Generate the events of each iteration for switch config\\n per_iter_event_list = self.traffic_conf['data-pkt-events']\\n msg_size = self.traffic_conf['message-size']\\n mtu = self.traffic_conf['mtu']\\n num_msgs_per_qp = self.traffic_conf['num-msgs-per-qp']\\n num_pkts_per_msg = int(math.ceil(msg_size / mtu))\\n self.switch.conf['traffic'] = {}\\n self.switch.conf['traffic']['num-msgs-per-qp'] = num_msgs_per_qp\\n self.switch.conf['traffic']['num-pkts-per-msg'] = num_pkts_per_msg\\n self.switch.conf['traffic']['data-pkt-events'] = []\\n\\n if per_iter_event_list is None or len(per_iter_event_list) == 0:\\n ## No events at all\\n return True\\n\\n for i in range(num_msgs_per_qp):\\n for per_iter_event in per_iter_event_list:\\n global_event = copy.deepcopy(per_iter_event)\\n\\n ## This event is applied to all the packets of the message. We need to expand it!\\n if str(global_event['psn']).lower() == 'all':\\n for psn in range(num_pkts_per_msg):\\n global_event['psn'] = psn + i * num_pkts_per_msg\\n self.switch.conf['traffic']['data-pkt-events'].append(copy.deepcopy(global_event))\\n else:\\n global_event['psn'] += i * num_pkts_per_msg\\n self.switch.conf['traffic']['data-pkt-events'].append(copy.deepcopy(global_event))\\n\\n return True\\n\\n def ping_mesh(self):\\n \\\"\\\"\\\" Ping all the IP addresses between requester and responder to check the connectivity\\n\\n Returns:\\n bool: True if all the IP addresses can be pinged successfully, False otherwise\\n \\\"\\\"\\\"\\n for requester_ip_subnet in self.requester.conf['nic']['ip-list']:\\n requester_ip = requester_ip_subnet.split('/')[0]\\n command = \\\"ping \\\" + requester_ip + \\\" -c 5 -i 0.2\\\"\\n ret_val, err_info, exit_status = self.responder.execute_command(command)\\n if exit_status != 0:\\n logging.error(\\\"Failed to ping ip \\\" + requester_ip)\\n logging.error(\\\"[Command return info]: %s %s\\\" % (', '.join(ret_val), ', '.join(err_info)))\\n return False\\n\\n for responder_ip_subnet in self.responder.conf['nic']['ip-list']:\\n responder_ip = responder_ip_subnet.split('/')[0]\\n command = \\\"ping \\\" + responder_ip + \\\" -c 5 -i 0.2\\\"\\n ret_val, err_info, exit_status = self.requester.execute_command(command)\\n if exit_status != 0:\\n logging.error(\\\"Failed to ping ip \\\" + responder_ip)\\n logging.error(\\\"[Command return info]: %s %s\\\" % (ret_val, err_info))\\n return False\\n\\n logging.info(\\\"Successfully pinged all the IP addresses between requester and responder\\\")\\n return True\\n\\n def generate_switch_config_file(self):\\n \\\"\\\"\\\" Generate the switch configuration file and copy it to the switch\\n\\n Returns:\\n bool: True if the switch configuration file is generated and copied successfully, False otherwise\\n \\\"\\\"\\\"\\n ## Get the mac address for all the hosts\\n self.requester.get_mac_address()\\n self.responder.get_mac_address()\\n self.requester_mirror.get_mac_address()\\n self.responder_mirror.get_mac_address()\\n\\n ## Generate config for Match-Action table in switch\\n if self.generate_switch_table_config() == False:\\n logging.error(\\\"Failed to generate switch table configuration\\\")\\n return False\\n\\n ## Dump the switch configuration into a file, and copy it to the switch\\n if self.switch.dump_controller_config(self.local_workspace) == False:\\n logging.error(\\\"Failed to dump switch config\\\")\\n return False\\n\\n return True\\n\\n def __is_valid_traffc(self):\\n \\\"\\\"\\\" Check if the traffic configuration is valid, including:\\n 1. The tx-depth should be 1 or > 1\\n 2. If tx-depth > 1, then we can only inject ECN marking events\\n\\n Returns:\\n bool: True if the traffic configuration is valid, False otherwise\\n \\\"\\\"\\\"\\n try:\\n data_pkt_events = self.traffic_conf['data-pkt-events']\\n tx_depth = self.traffic_conf['tx-depth']\\n\\n if tx_depth == 1:\\n return True\\n elif tx_depth <= 0:\\n return False\\n\\n for event in data_pkt_events:\\n if event['type'] != 'ecn':\\n logging.error(\\\"Cannot inject %s event when tx depth = %d\\\" % (event['type'], tx_depth))\\n return False\\n except:\\n logging.error(\\\"Failed to parse traffic configuration\\\")\\n return False\\n\\n return True\\n\\n def run_experiment(self):\\n \\\"\\\"\\\" Run the experiment\\n\\n Returns:\\n bool: True if the experiment is completed successfully, False otherwise\\n \\\"\\\"\\\"\\n\\n ## Check if traffic configuration is valid\\n if self.__is_valid_traffc() == False:\\n logging.error(\\\"Invalid traffic configuration\\\")\\n return False\\n\\n ## Run switch program\\n if self.switch.run_switch() == False:\\n logging.error(\\\"Failed to run switch\\\")\\n return False\\n\\n ## Sleep for 1 second to make sure control plane is listenning (for client message)\\n time.sleep(1)\\n\\n ## Configure the servers\\n if self.requester.config_traffic_gen() == False:\\n logging.error(\\\"Failed to config RDMA requester\\\")\\n return False\\n\\n if self.responder.config_traffic_gen() == False:\\n logging.error(\\\"Failed to config RDMA responder\\\")\\n return False\\n\\n if self.requester_mirror.config_packet_capture() == False:\\n logging.error(\\\"Failed to config packet capture on requester mirror\\\")\\n return False\\n\\n if self.responder_mirror.config_packet_capture() == False:\\n logging.error(\\\"Failed to config packet capture on responder mirror\\\")\\n return False\\n\\n ## Check the connectivity through pingmesh (try 5 rounds)\\n num_tries = 0\\n pingmesh_ret = False\\n\\n while num_tries < 5:\\n pingmesh_ret = self.ping_mesh()\\n if pingmesh_ret == True:\\n break\\n num_tries += 1\\n time.sleep(1)\\n\\n if pingmesh_ret == False:\\n logging.error(\\\"Failed to ping all the IP addresses between requester and responder\\\")\\n return False\\n\\n ## Launch packet capture for both side\\n ## Prerequisite: config hugepage and igb_uio if needed\\n if self.requester_mirror.run_packet_capture() == False:\\n logging.error(\\\"Failed to run packet capture on requester mirror\\\")\\n return False\\n\\n if self.responder_mirror.run_packet_capture() == False:\\n logging.error(\\\"Failed to run packet capture on responder mirror\\\")\\n return False\\n\\n time.sleep(3)\\n\\n ## Dump the counters before running\\n if self.requester.dump_counters(host.REQ_START_COUNTER_FILE_NAME) == False:\\n logging.error(\\\"Failed to dump counters on requester before running\\\")\\n return False\\n\\n if self.responder.dump_counters(host.RSP_START_COUNTER_FILE_NAME) == False:\\n logging.error(\\\"Failed to dump counters on responder before running\\\")\\n return False\\n\\n ## Launch RDMA server first\\n run_server_ret = self.responder.run_traffic_gen_server(self.traffic_conf)\\n if run_server_ret == False:\\n logging.error(\\\"Failed to run RDMA server\\\")\\n return False\\n\\n time.sleep(2)\\n\\n ## Launch RDMA client\\n try:\\n destination_ip_subnet = self.responder.conf['nic']['ip-list'][0]\\n destination_ip = destination_ip_subnet.split('/')[0]\\n except:\\n logging.error(\\\"Failed to get destination IP\\\")\\n return False\\n\\n run_client_ret = self.requester.run_traffic_gen_client(traffic_conf=self.traffic_conf,\\n destination_ip=destination_ip,\\n controller_ip=self.switch.conf['control-ip'],\\n controller_listen_port=self.switch.conf['listen-port'])\\n if run_client_ret == False:\\n logging.error(\\\"Failed to run RDMA client\\\")\\n return False\\n\\n if self.switch.dump_results() == False:\\n logging.error(\\\"Failed to dump results from switch\\\")\\n return False\\n\\n if self.requester.dump_counters(host.REQ_FINISH_COUNTER_FILE_NAME) == False:\\n logging.error(\\\"Failed to dump counters on requester after running\\\")\\n return False\\n\\n if self.responder.dump_counters(host.RSP_FINISH_COUNTER_FILE_NAME) == False:\\n logging.error(\\\"Failed to dump counters on responder after running\\\")\\n return False\\n\\n logging.info(\\\"Experiment completed successfully\\\")\\n return True\\n\\n def clean_up(self):\\n \\\"\\\"\\\" Clean up the environment after the experiment\\n\\n Returns:\\n bool: True if the clean up is completed successfully, False otherwise\\n \\\"\\\"\\\"\\n logging.info(\\\"Start cleaning up the environment\\\")\\n\\n if self.switch.clean_up() == False:\\n logging.error(\\\"Failed to clean up switch\\\")\\n return False\\n\\n if self.requester.clean_up() == False:\\n logging.error(\\\"Failed to clean up requester\\\")\\n return False\\n\\n if self.responder.clean_up() == False:\\n logging.error(\\\"Failed to clean up responder\\\")\\n return False\\n\\n if self.requester_mirror.clean_up() == False:\\n logging.error(\\\"Failed to clean up requester mirror\\\")\\n return False\\n\\n if self.responder_mirror.clean_up() == False:\\n logging.error(\\\"Failed to clean up responder mirror\\\")\\n return False\\n\\n return True\\n\\n def fetch_results(self, iter_id=0):\\n \\\"\\\"\\\" Fetch the results of iteration 'iter_id', including:\\n 1. Switch table entries and counters\\n 2. Packet trace (pcap file)\\n 3. Configs and end-to-end results from RDMA hosts\\n\\n Args:\\n iter_id (int, optional): iteration ID, defaults to 0\\n\\n Returns:\\n bool: True if the result collection is completed successfully, False otherwise\\n \\\"\\\"\\\"\\n ## Make the results dir if it does not exist\\n iter_result_path = os.path.join(self.result_path, str(iter_id))\\n cmd = \\\"mkdir -p %s\\\" % iter_result_path\\n try:\\n subprocess.call(cmd, shell=True)\\n except:\\n logging.error(\\\"Failed to create result directory %s\\\" % iter_result_path)\\n return False\\n\\n if self.switch.fetch_results(iter_result_path) == False:\\n logging.error(\\\"Failed to fetch results from switch\\\")\\n return False\\n\\n if self.requester_mirror.fetch_results(iter_result_path) == False:\\n logging.error(\\\"Failed to fetch results from requester mirror\\\")\\n return False\\n\\n if self.responder_mirror.fetch_results(iter_result_path) == False:\\n logging.error(\\\"Failed to fetch results from responder mirror\\\")\\n return False\\n\\n if self.requester.fetch_results(iter_result_path) == False:\\n logging.error(\\\"Failed to fetch results from requester\\\")\\n return False\\n\\n if self.responder.fetch_results(iter_result_path) == False:\\n logging.error(\\\"Failed to fetch results from responder\\\")\\n return False\\n\\n logging.info(\\\"Finished fetching results for iteration %d\\\" % iter_id)\\n return True\\n\\n def merge_traces(self, iter_id=0):\\n iter_pcap_dir_path = os.path.join(self.result_path, str(iter_id), host.PCAP_RESULT_DIR)\\n src_pcap_file_list = [os.path.join(iter_pcap_dir_path,\\n self.requester_mirror.conf['pkt-dump-conf']['dump-filename']),\\n os.path.join(iter_pcap_dir_path,\\n self.responder_mirror.conf['pkt-dump-conf']['dump-filename'])]\\n target_pcap_path = os.path.join(self.result_path,\\n str(iter_id),\\n host.PCAP_RESULT_DIR,\\n self.aggregate_pcap_filename)\\n packet_list = pcap_process.merge_pcaps(src_pcap_file_list)\\n if packet_list is None:\\n logging.error(\\\"Failed to merge pcap files for iteration %d\\\" % iter_id)\\n return False\\n\\n if pcap_process.dump_pkts_to_pcap(target_pcap_path, packet_list) == False:\\n logging.error(\\\"Failed to dump packets to pcap file %s\\\" % target_pcap_path)\\n return False\\n\\n logging.info(\\\"Successfully merged pcap files for iteration %d\\\" % iter_id)\\n\\n def check_integrity(self, iter_id=0):\\n ## Check if the collected packet trace passes integrity check\\n pcap_path = os.path.join(self.result_path,\\n str(iter_id),\\n host.PCAP_RESULT_DIR,\\n self.aggregate_pcap_filename)\\n packet_list = get_packet_list(pcap_path)\\n packet_list.sort(key=lambda x:x.get_switch_seqnum())\\n logging.info(\\\"Packet trace sorted by switch sequence number.\\\")\\n\\n switch_state_snapshot = os.path.join(self.result_path,\\n str(iter_id),\\n switch.SWITCH_RESULT_DIR,\\n switch.SWITCH_STATE_SNAPSHOT)\\n port_map = {'requester': self.requester.conf['nic']['switch-port'],\\n 'responder': self.responder.conf['nic']['switch-port'],\\n 'requester-mirror': self.requester_mirror.conf['nic']['switch-port'],\\n 'responder-mirror': self.responder_mirror.conf['nic']['switch-port']}\\n switch_counter = SwitchCounter(switch_state_snapshot, port_map)\\n\\n integrity_checker = IntegrityCheck(packet_list=packet_list,\\n switch_counter=switch_counter,\\n requester_ip_list=self.get_requester_ip_list(),\\n responder_ip_list=self.get_responder_ip_list())\\n\\n if integrity_checker.check() == True:\\n logging.info(\\\"Integrity check passed\\\")\\n return True\\n else:\\n logging.info(\\\"Integrity check failed\\\")\\n return False\"\n },\n {\n \"identifier\": \"SwitchCounter\",\n \"path\": \"lumina/analyzer/counter/switch_counter.py\",\n \"snippet\": \"class SwitchCounter:\\n \\\"\\\"\\\" Class to parse switch counter files\\n\\n Attributes:\\n _counter (dict of dict): the switch counters with the following format:\\n {'requester': {'ingress': counter_value, 'egress': counter_value},\\n 'responder': {'ingress': counter_value, 'egress': counter_value},\\n 'requester-mirror': {'ingress': counter_value, 'egress': counter_value},\\n 'responder-mirror': {'ingress': counter_value, 'egress': counter_value}}\\n \\\"\\\"\\\"\\n def __init__(self, snapshot_filename, port_map):\\n \\\"\\\"\\\" Constructor\\n\\n Args:\\n snapshot_filename (str): the file where switch dumps its counters\\n port_map (dict): the mapping between port name and port number\\n\\n Returns:\\n N/A\\n \\\"\\\"\\\"\\n with open(snapshot_filename, \\\"r\\\") as stream:\\n conf = yaml.safe_load(stream)\\n try:\\n ingress_counters = conf['counter']['ingress']\\n egress_counters = conf['counter']['egress']\\n except:\\n print(\\\"Bad yaml format in %s\\\" % snapshot_filename)\\n sys.exit(-1)\\n\\n requester_port = port_map['requester']\\n responder_port = port_map['responder']\\n requester_mirror_port = port_map['requester-mirror']\\n responder_mirror_port = port_map['responder-mirror']\\n\\n self._counter = {'requester' : {'ingress':0, 'egress': 0},\\n 'responder' : {'ingress':0, 'egress': 0},\\n 'requester-mirror' : {'ingress':0, 'egress': 0},\\n 'responder-mirror' : {'ingress':0, 'egress': 0}}\\n try:\\n self._counter['requester']['ingress'] = ingress_counters[requester_port]\\n self._counter['responder']['ingress'] = ingress_counters[responder_port]\\n self._counter['requester-mirror']['ingress'] = ingress_counters[requester_mirror_port]\\n self._counter['responder-mirror']['ingress'] = ingress_counters[responder_mirror_port]\\n\\n self._counter['requester']['egress'] = egress_counters[requester_port]\\n self._counter['responder']['egress'] = egress_counters[responder_port]\\n self._counter['requester-mirror']['egress'] = egress_counters[requester_mirror_port]\\n self._counter['responder-mirror']['egress'] = egress_counters[responder_mirror_port]\\n\\n except:\\n print(\\\"Port number not exist in the switch snapshot\\\")\\n sys.exit(-1)\\n\\n def get_counter(self):\\n \\\"\\\"\\\" Return the switch counters (dict of dict) \\\"\\\"\\\"\\n return self._counter\"\n },\n {\n \"identifier\": \"MLNXHostCounter\",\n \"path\": \"lumina/analyzer/counter/host_counter.py\",\n \"snippet\": \"class MLNXHostCounter(HostCounter):\\n \\\"\\\"\\\" Class to parse MLNX host counter files \\\"\\\"\\\"\\n def __init__(self, counter_start_filename, counter_finish_filename):\\n \\\"\\\"\\\" Constructor\\n\\n Args:\\n counter_start_filename (str): the file where host dumps its counters at the start phase\\n counter_finish_filename (str): the file where host dumps its counters at the finish phase\\n\\n Returns:\\n N/A\\n \\\"\\\"\\\"\\n super().__init__(counter_start_filename, counter_finish_filename)\\n\\n def get_port_rcv_packets(self):\\n \\\"\\\"\\\" Return the number of received packets \\\"\\\"\\\"\\n return self._counter['port-counters']['port_rcv_packets']\\n\\n def get_port_xmit_packets(self):\\n \\\"\\\"\\\" Return the number of transmitted packets \\\"\\\"\\\"\\n return self._counter['port-counters']['port_xmit_packets']\\n\\n def get_num_packet_seq_err(self):\\n \\\"\\\"\\\" Return the number of received NAK sequence error packets \\\"\\\"\\\"\\n return self._counter['hw-counters']['packet_seq_err']\\n\\n def get_num_out_of_sequence(self):\\n \\\"\\\"\\\" Return the number of out-of-sequence packets received \\\"\\\"\\\"\\n return self._counter['hw-counters']['out_of_sequence']\\n\\n def get_num_dup_requests(self):\\n \\\"\\\"\\\" Return the number of duplicate requests \\\"\\\"\\\"\\n return self._counter['hw-counters']['duplicate_request']\\n\\n def implied_nak_seq_err(self):\\n \\\"\\\"\\\" Return the number of READ requests implying sequence errors \\\"\\\"\\\"\\n return self._counter['hw-counters']['implied_nak_seq_err']\\n\\n def get_num_cnp_sent(self):\\n \\\"\\\"\\\" Return the number of congestion notification packets sent by notification point \\\"\\\"\\\"\\n return self._counter['hw-counters']['np_cnp_sent']\\n\\n def get_num_ecn_marked_packets(self):\\n \\\"\\\"\\\" Return the number of ECN marked RoCEv2 packets received by notification point \\\"\\\"\\\"\\n return self._counter['hw-counters']['np_ecn_marked_roce_packets']\\n\\n def get_num_cnp_handled(self):\\n \\\"\\\"\\\" Return the number of congestion notification packets handled by reaction point \\\"\\\"\\\"\\n return self._counter['hw-counters']['rp_cnp_handled']\\n\\n def get_num_icrc_errors(self):\\n \\\"\\\"\\\" Return the number of RoCE packets with ICRC errors received \\\"\\\"\\\"\\n return self._counter['hw-counters']['rx_icrc_encapsulated']\\n\\n def get_num_timeout_err(self):\\n \\\"\\\"\\\" Return the number of times QP's ack timer expired for RC, XRC, DCT QPs at the sender side \\\"\\\"\\\"\\n return self._counter['hw-counters']['local_ack_timeout_err']\\n\\n def get_num_discards_dict_tx(self):\\n \\\"\\\"\\\" Return the number of TX discarded packets (dict)\\\"\\\"\\\"\\n discards_dict_tx = {}\\n for x in self._counter['ethtool-counters'].keys():\\n if 'discard' in x and 'tx' in x:\\n discards_dict_tx[x] = self._counter['ethtool-counters'][x]\\n return discards_dict_tx\\n\\n def get_num_discards_dict_rx(self):\\n \\\"\\\"\\\" Return the number of RX discarded packets (dict) \\\"\\\"\\\"\\n discards_dict_rx = {}\\n for x in self._counter['ethtool-counters'].keys():\\n if 'discard' in x and 'rx' in x:\\n discards_dict_rx[x] = self._counter['ethtool-counters'][x]\\n return discards_dict_rx\"\n },\n {\n \"identifier\": \"IntelHostCounter\",\n \"path\": \"lumina/analyzer/counter/host_counter.py\",\n \"snippet\": \"class IntelHostCounter(HostCounter):\\n \\\"\\\"\\\" Class to parse Intel host counter files \\\"\\\"\\\"\\n def __init__(self, counter_start_filename, counter_finish_filename):\\n \\\"\\\"\\\" Constructor\\n\\n Args:\\n counter_start_filename (str): the file where host dumps its counters at the start phase\\n counter_finish_filename (str): the file where host dumps its counters at the finish phase\\n\\n Returns:\\n N/A\\n \\\"\\\"\\\"\\n super().__init__(counter_start_filename, counter_finish_filename)\\n\\n def get_num_cnp_sent(self):\\n \\\"\\\"\\\" Return the number of congestion notification packets sent by notification point \\\"\\\"\\\"\\n return self._counter['hw-counters']['cnpSent']\\n\\n def get_num_ecn_marked_packets(self):\\n \\\"\\\"\\\" Return the number of ECN marked RoCEv2 packets received by notification point \\\"\\\"\\\"\\n return self._counter['hw-counters']['RxECNMrkd']\\n\\n def get_num_cnp_handled(self):\\n \\\"\\\"\\\" Return the number of congestion notification packets handled by reaction point \\\"\\\"\\\"\\n return self._counter['hw-counters']['cnpHandled']\\n\\n def get_num_discards_dict(self):\\n \\\"\\\"\\\" Return the number of discarded packets (dict) \\\"\\\"\\\"\\n discards_dict= {}\\n for x in self._counter['hw-counters'].keys():\\n if 'discard' in x:\\n discards_dict[x] = self._counter['hw-counters'][x]\\n return discards_dict\"\n },\n {\n \"identifier\": \"get_packet_list\",\n \"path\": \"lumina/analyzer/pcap_processor/pcap_process.py\",\n \"snippet\": \"def get_packet_list(pcap_file):\\n \\\"\\\"\\\" Read a pcap file and return a list of packets\\n\\n Args:\\n pcap_file (str): The pcap file to read\\n\\n Returns:\\n list: The list of packets if successful, empty list otherwise\\n\\n Raises:\\n IOError: If the pcap file cannot be opened for reading\\n Exception: If the pcap file cannot be read\\n \\\"\\\"\\\"\\n packet_list = []\\n try:\\n with open(pcap_file, 'rb') as file_read:\\n pcap = dpkt.pcap.Reader(file_read)\\n for packet in pcap:\\n packet_list.append(roce_packet.RRoCEPacket(packet))\\n except IOError:\\n logging.error(\\\"Unable to open pcap file %s. Please check your filename.\\\" % pcap_file)\\n raise IOError\\n\\n except:\\n logging.error(\\\"Failed to read pcap file %s.\\\" % pcap_file)\\n raise Exception\\n\\n logging.info(\\\"Successfully read %d packets from %s.\\\" % (len(packet_list), pcap_file))\\n return packet_list\"\n },\n {\n \"identifier\": \"LatencyMeasure\",\n \"path\": \"lumina/analyzer/measurer/latency_measure.py\",\n \"snippet\": \"class LatencyMeasure:\\n \\\"\\\"\\\" Class to measure the latency between packets for some events,\\n e.g., NACK latency, Retransmission latency, CNP latency\\n\\n Attributes:\\n packet_list (list of RRoCEPacket objects): list of packets\\n qp_info_list (list of dict): list of QP info with the following format:\\n [{'psn_rcv': initial packet sequence number from the receiver qp,\\n 'psn_snd': initial packet sequence number from the sender qp,\\n 'qpn_rcv': receiver qp number,\\n 'qpn_snd': sender qp number,\\n 'ip_rcv' : receiver IP\\n 'ip_snd' : sender IP}]\\n is_read (bool): if the QPs use RDMA read verb\\n \\\"\\\"\\\"\\n def __init__(self, packet_list, qp_info_list, is_read=False):\\n \\\"\\\"\\\" Constructor\\n\\n Args:\\n packet_list (list of RRoCEPacket objects): list of packets\\n qp_info_list (list of dict): list of QP info with the following format:\\n [{'psn_rcv': initial packet sequence number from the receiver qp,\\n 'psn_snd': initial packet sequence number from the sender qp,\\n 'qpn_rcv': receiver qp number,\\n 'qpn_snd': sender qp number,\\n 'ip_rcv' : receiver IP\\n 'ip_snd' : sender IP}]\\n is_read (bool): if the QPs use RDMA read verb (default: False)\\n\\n Returns:\\n N/A\\n \\\"\\\"\\\"\\n self.packet_list = packet_list\\n self.qp_info_list = qp_info_list\\n self.is_read = is_read\\n\\n def get_peer_qp_info(self, dest_qpn, dest_ip):\\n \\\"\\\"\\\" Get the info of the peer QP (qpn, ip) of a given qp (qpn, ip)\\n\\n Args:\\n dest_qpn (int): destination QP number\\n dest_ip (str): destination IP\\n\\n Returns:\\n int: peer QP number (None if not found)\\n str: peer IP (None if not found)\\n \\\"\\\"\\\"\\n for qp_info in self.qp_info_list:\\n if qp_info['qpn_snd'] == dest_qpn and qp_info['ip_snd'] == dest_ip:\\n return qp_info['qpn_rcv'], qp_info['ip_rcv']\\n elif qp_info['qpn_rcv'] == dest_qpn and qp_info['ip_rcv'] == dest_ip:\\n return qp_info['qpn_snd'], qp_info['ip_snd']\\n\\n return None, None\\n\\n def get_bit_error_pkts(self, relative_dest_qpn=None):\\n \\\"\\\"\\\" Get the packets marked with bit error flag\\n\\n Args:\\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\\n\\n Returns:\\n list of RRoCEPacket objects: the list of packets marked with bit error flag\\n \\\"\\\"\\\"\\n error_pkt_list = []\\n\\n if relative_dest_qpn != None:\\n dest_qpn = self.qp_info_list[relative_dest_qpn]['qpn_rcv']\\n dest_ip = self.qp_info_list[relative_dest_qpn]['ip_rcv']\\n\\n for packet in self.packet_list:\\n if packet.is_bit_error() == False:\\n continue\\n\\n if relative_dest_qpn == None or \\\\\\n (packet.get_roce_dest_qp() == dest_qpn and packet.get_dst_ip() == dest_ip):\\n error_pkt_list.append(packet)\\n\\n return error_pkt_list\\n\\n def get_dropped_pkts(self, relative_dest_qpn=None):\\n \\\"\\\"\\\" Get the packets marked with drop flag\\n\\n Args:\\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\\n\\n Returns:\\n list of RRoCEPacket objects: the list of packets marked with drop flag\\n \\\"\\\"\\\"\\n dropped_pkt_list = []\\n\\n if relative_dest_qpn != None:\\n dest_qpn = self.qp_info_list[relative_dest_qpn]['qpn_rcv']\\n dest_ip = self.qp_info_list[relative_dest_qpn]['ip_rcv']\\n\\n for packet in self.packet_list:\\n if packet.is_dropped() == False:\\n continue\\n\\n if relative_dest_qpn == None or \\\\\\n (packet.get_roce_dest_qp() == dest_qpn and packet.get_dst_ip() == dest_ip):\\n dropped_pkt_list.append(packet)\\n\\n return dropped_pkt_list\\n\\n def get_ecn_pkts(self):\\n \\\"\\\"\\\" Get the packets marked with ECN\\n\\n Returns:\\n list of RRoCEPacket objects: the list of packets marked with ECN\\n \\\"\\\"\\\"\\n ecn_pkt_list = []\\n\\n for packet in self.packet_list:\\n if packet.is_ecn():\\n ecn_pkt_list.append(packet)\\n\\n return ecn_pkt_list\\n\\n def get_cnp_pkts(self):\\n \\\"\\\"\\\" Get the congestion notification packets\\n\\n Returns:\\n list of RRoCEPacket objects: the list of congestion notification packets\\n \\\"\\\"\\\"\\n cnp_pkt_list = []\\n\\n for packet in self.packet_list:\\n if packet.is_cnp():\\n cnp_pkt_list.append(packet)\\n\\n return cnp_pkt_list\\n\\n def get_undelivered_pkts(self, relative_dest_qpn = None):\\n \\\"\\\"\\\" Get the undelivered packets (dropped or marked with bit error)\\n\\n Args:\\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\\n\\n Returns:\\n list of RRoCEPacket objects: the list of undelivered packets\\n \\\"\\\"\\\"\\n undelivered_pkt_list = []\\n\\n if relative_dest_qpn != None:\\n dest_qpn = self.qp_info_list[relative_dest_qpn]['qpn_rcv']\\n dest_ip = self.qp_info_list[relative_dest_qpn]['ip_rcv']\\n\\n for packet in self.packet_list:\\n if packet.is_delivered() == True:\\n continue\\n\\n if relative_dest_qpn == None or \\\\\\n (packet.get_roce_dest_qp() == dest_qpn and packet.get_dst_ip() == dest_ip):\\n undelivered_pkt_list.append(packet)\\n\\n return undelivered_pkt_list\\n\\n def get_nack(self, undelivered_pkt):\\n \\\"\\\"\\\" Given an undelivered packet, return the NACK packet that triggers its retransmission.\\n If there's no NACK packet found for the undelivered packet, return None.\\n Note that for RDMA READ, NACK is essentially a READ request packet that triggers retransmission\\n\\n Args:\\n undelivered_pkt (RRoCEPacket object): the undelivered packet\\n\\n Returns:\\n RRoCEPacket object: the NACK packet that triggers the retransmission of the undelivered packet\\n (None if not found)\\n \\\"\\\"\\\"\\n undelivered_pkt_dest_qpn = undelivered_pkt.get_roce_dest_qp()\\n undelivered_pkt_dst_ip = undelivered_pkt.get_dst_ip()\\n undelivered_pkt_psn = undelivered_pkt.get_roce_pkt_seq()\\n undelivered_pkt_switch_seqnum = undelivered_pkt.get_switch_seqnum()\\n matched_dest_qpn, matched_dst_ip = self.get_peer_qp_info(undelivered_pkt_dest_qpn, undelivered_pkt_dst_ip)\\n\\n if matched_dest_qpn == None or matched_dst_ip == None:\\n logging.error(\\\"QP info of the undelivered packet not found in qp_info_list dumped by switch\\\")\\n return None\\n\\n for packet in self.packet_list:\\n if self.is_same_roce_data_pkt(packet, undelivered_pkt) and \\\\\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\\n return None\\n\\n if ((self.is_read and packet.is_roce_read_req()) or packet.is_roce_nack()) and \\\\\\n packet.get_dst_ip() == matched_dst_ip and \\\\\\n packet.get_roce_dest_qp() == matched_dest_qpn and \\\\\\n packet.get_roce_pkt_seq() == undelivered_pkt_psn and \\\\\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\\n ## We return the first packet appears after the undelivered packet and matches the undelivered packet\\n return packet\\n\\n return None\\n\\n def get_qp_first_nack_before_retrans(self, undelivered_pkt):\\n \\\"\\\"\\\" For an undelivered packet, return the first NACK packet on its QP between it and its retransmission.\\n If there's no NACK packet found before the retransmission, return None.\\n Note that for RDMA READ, NACK is essentially a READ request packet\\n\\n Args:\\n undelivered_pkt (RRoCEPacket object): the undelivered packet\\n\\n Returns:\\n RRoCEPacket object: the first NACK packet on the QP between the undelivered packet and its retransmission\\n (None if not found)\\n \\\"\\\"\\\"\\n undelivered_pkt_dest_qpn = undelivered_pkt.get_roce_dest_qp()\\n undelivered_pkt_dst_ip = undelivered_pkt.get_dst_ip()\\n undelivered_pkt_psn = undelivered_pkt.get_roce_pkt_seq()\\n undelivered_pkt_switch_seqnum = undelivered_pkt.get_switch_seqnum()\\n matched_dest_qpn, matched_dst_ip = self.get_peer_qp_info(undelivered_pkt_dest_qpn, undelivered_pkt_dst_ip)\\n\\n if matched_dest_qpn == None or matched_dst_ip == None:\\n logging.error(\\\"QP info of the undelivered packet not found in qp_info_list dumped by switch\\\")\\n return None\\n\\n for packet in self.packet_list:\\n if self.is_same_roce_data_pkt(packet, undelivered_pkt) and \\\\\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\\n return None\\n\\n if ((self.is_read and packet.is_roce_read_req()) or packet.is_roce_nack()) and \\\\\\n packet.get_dst_ip() == matched_dst_ip and \\\\\\n packet.get_roce_dest_qp() == matched_dest_qpn and \\\\\\n packet.get_roce_pkt_seq() <= undelivered_pkt_psn and \\\\\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\\n return packet\\n\\n return None\\n\\n def get_qp_next_delivered_pkt(self, current_pkt):\\n \\\"\\\"\\\" For a packet, return the next delivered packet on the same QP.\\n\\n Args:\\n current_pkt (RRoCEPacket object): the current packet\\n\\n Returns:\\n RRoCEPacket object: the next delivered packet on the same QP (None if not found)\\n \\\"\\\"\\\"\\n switch_seqnum = current_pkt.get_switch_seqnum()\\n\\n for packet in self.packet_list:\\n if self.is_same_qp_roce_data_pkt(packet, current_pkt) and \\\\\\n packet.get_switch_seqnum() > switch_seqnum and \\\\\\n packet.is_delivered():\\n return packet\\n\\n return None\\n\\n def get_retransmit_pkt(self, undelivered_pkt):\\n \\\"\\\"\\\" Given an undelivered packet, return its retransmission packet.\\n\\n Args:\\n undelivered_pkt (RRoCEPacket object): the undelivered packet\\n\\n Returns:\\n RRoCEPacket object: the retransmission packet of the undelivered packet (None if not found)\\n \\\"\\\"\\\"\\n undelivered_pkt_switch_seqnum = undelivered_pkt.get_switch_seqnum()\\n\\n for packet in self.packet_list:\\n if self.is_same_roce_data_pkt(packet, undelivered_pkt) and \\\\\\n packet.get_switch_seqnum() > undelivered_pkt_switch_seqnum:\\n ## We return the first packet appears after the undelivered packet and matches the undelivered packet\\n return packet\\n\\n return None\\n\\n def get_latency_between_pkts(self, packet_alpha, packet_beta):\\n \\\"\\\"\\\" Return the time of packet_beta - time of packet_alpha in seconds\\n\\n Args:\\n packet_alpha (RRoCEPacket object): the first packet\\n packet_beta (RRoCEPacket object): the second packet\\n\\n Returns:\\n float: the time difference between two packets in seconds\\n \\\"\\\"\\\"\\n return packet_beta.get_switch_timestamp() - packet_alpha.get_switch_timestamp()\\n\\n def is_same_roce_data_pkt(self, packet_alpha, packet_beta):\\n \\\"\\\"\\\" Return if two packets are the same RoCE data packet (same src ip, dst ip, dest qp, and psn)\\n\\n Args:\\n packet_alpha (RRoCEPacket object): the first packet\\n packet_beta (RRoCEPacket object): the second packet\\n\\n Returns:\\n bool: True if two packets are the same RoCE data packet, False otherwise\\n \\\"\\\"\\\"\\n return packet_alpha.get_src_ip() == packet_beta.get_src_ip() and \\\\\\n packet_alpha.get_dst_ip() == packet_beta.get_dst_ip() and \\\\\\n packet_alpha.get_roce_dest_qp() == packet_beta.get_roce_dest_qp() and \\\\\\n packet_alpha.get_roce_pkt_seq() == packet_beta.get_roce_pkt_seq()\\n\\n def is_same_qp_roce_data_pkt(self, packet_alpha, packet_beta):\\n \\\"\\\"\\\" Return if two packets are RoCE data packets on the same QP (same src ip, dst ip, and dest qp)\\n\\n Args:\\n packet_alpha (RRoCEPacket object): the first packet\\n packet_beta (RRoCEPacket object): the second packet\\n\\n Returns:\\n bool: True if two packets are RoCE data packets on the same QP, False otherwise\\n \\\"\\\"\\\"\\n return packet_alpha.get_src_ip() == packet_beta.get_src_ip() and \\\\\\n packet_alpha.get_dst_ip() == packet_beta.get_dst_ip() and \\\\\\n packet_alpha.get_roce_dest_qp() == packet_beta.get_roce_dest_qp()\\n\\n def get_qp_next_delivered_pkt_latency(self, pkt):\\n \\\"\\\"\\\" Get the latency between 'pkt' and next 'delivered' packet on the same QP\\n\\n Args:\\n pkt (RRoCEPacket object): the packet\\n\\n Returns:\\n float: the latency between 'pkt' and next 'delivered' packet on the same QP\\n (None if not found)\\n \\\"\\\"\\\"\\n\\n next_pkt = self.get_qp_next_delivered_pkt(pkt)\\n if next_pkt is None:\\n return None\\n\\n return self.get_latency_between_pkts(pkt, next_pkt)\\n\\n def get_nack_gen_latency(self, undelivered_pkt):\\n \\\"\\\"\\\" For an undelivered packet, return the NACK generation latency, i.e., the duration from the detection of\\n the undelivered packet to the generation of the NACK packet that triggers its retransmission.\\n\\n Args:\\n undelivered_pkt (RRoCEPacket object): the undelivered packet\\n\\n Returns:\\n float: the NACK generation latency for the undelivered packet (None if not found)\\n \\\"\\\"\\\"\\n nack_pkt = self.get_nack(undelivered_pkt)\\n if nack_pkt == None:\\n return None\\n\\n # NACK should be triggered by the next delivered packet on the same QP\\n next_delivered_pkt = self.get_qp_next_delivered_pkt(undelivered_pkt)\\n if self.is_same_roce_data_pkt(next_delivered_pkt, undelivered_pkt):\\n # We should never reach here\\n return None\\n\\n nack_gen_latency = self.get_latency_between_pkts(next_delivered_pkt, nack_pkt)\\n return nack_gen_latency\\n\\n def get_nack_resp_latency(self, undelivered_pkt):\\n \\\"\\\"\\\" For an undelivered packet, return the NACK response latency, i.e., the duration from the generation of\\n the NACK packet to the retransmission of this undelivered packet.\\n\\n Args:\\n undelivered_pkt (RRoCEPacket object): the undelivered packet\\n\\n Returns:\\n float: the NACK response latency for the undelivered packet (None if not found)\\n \\\"\\\"\\\"\\n nack_pkt = self.get_nack(undelivered_pkt)\\n if nack_pkt == None:\\n return None\\n\\n retransmit_pkt = self.get_retransmit_pkt(undelivered_pkt)\\n if retransmit_pkt == None:\\n return None\\n\\n nack_resp_latency = self.get_latency_between_pkts(nack_pkt, retransmit_pkt)\\n return nack_resp_latency\\n\\n def get_retransmit_latency(self, undelivered_pkt):\\n \\\"\\\"\\\" For an undelivered packet, return the retransmission latency, i.e., the duration from the packet\\n to its retransmission.\\n\\n Args:\\n undelivered_pkt (RRoCEPacket object): the undelivered packet\\n\\n Returns:\\n float: the retransmission latency for the undelivered packet (None if not found)\\n \\\"\\\"\\\"\\n retransmit_pkt = self.get_retransmit_pkt(undelivered_pkt)\\n if retransmit_pkt == None:\\n return None\\n\\n retransmit_latency = self.get_latency_between_pkts(undelivered_pkt, retransmit_pkt)\\n return retransmit_latency\\n\\n def get_nack_gen_latency_list(self, relative_dest_qpn=None):\\n \\\"\\\"\\\" Return a list of NACK generation latency for all undelivered packets with relative_dest_qpn\\n\\n Args:\\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\\n\\n Returns:\\n list of float: a list of NACK generation latency for all undelivered packets with relative_dest_qpn\\n \\\"\\\"\\\"\\n undelivered_pkts = self.get_undelivered_pkts(relative_dest_qpn)\\n nack_latency_list = []\\n\\n for undelivered_pkt in undelivered_pkts:\\n nack_pkt = self.get_nack(undelivered_pkt)\\n if nack_pkt == None:\\n nack_latency_list.append(None)\\n else:\\n nack_latency = self.get_latency_between_pkts(undelivered_pkt, nack_pkt)\\n nack_latency_list.append(nack_latency)\\n\\n return nack_latency_list\\n\\n def get_retransmit_latency_list(self, relative_dest_qpn):\\n \\\"\\\"\\\" Return a list of retransmission latency for all undelivered packets with relative_dest_qpn\\n\\n Args:\\n relative_dest_qpn (int): the relative destination QP number (None if not specified)\\n\\n Returns:\\n list of float: a list of retransmission latency for all undelivered packets with relative_dest_qpn\\n \\\"\\\"\\\"\\n undelivered_pkts = self.get_undelivered_pkts(relative_dest_qpn)\\n retransmit_latency_list = []\\n\\n for undelivered_pkt in undelivered_pkts:\\n retransmit_pkt = self.get_retransmit_pkt(undelivered_pkt)\\n if retransmit_pkt == None:\\n retransmit_latency_list.append(None)\\n else:\\n retransmit_latency = self.get_latency_between_pkts(undelivered_pkt, retransmit_pkt)\\n retransmit_latency_list.append(retransmit_latency)\\n\\n return retransmit_latency_list\"\n },\n {\n \"identifier\": \"config_stream_handler\",\n \"path\": \"lumina/utils/config_loggers.py\",\n \"snippet\": \"def config_stream_handler(logger):\\n \\\"\\\"\\\" Configure stream handler\\n\\n Args:\\n logger (logging.Logger): Logger object\\n\\n Returns:\\n N/A\\n \\\"\\\"\\\"\\n logger.setLevel(logging.INFO)\\n console = logging.StreamHandler()\\n console.setLevel(logging.INFO)\\n console.setFormatter(logging.Formatter('%(name)-18s: %(levelname)-8s %(message)s'))\\n logger.addHandler(console)\"\n },\n {\n \"identifier\": \"config_file_handler\",\n \"path\": \"lumina/utils/config_loggers.py\",\n \"snippet\": \"def config_file_handler(logger, log_file, no_format=False):\\n \\\"\\\"\\\" Configure file handler\\n\\n Args:\\n logger (logging.Logger): Logger object\\n log_file (str): Log file path\\n no_format (bool): If True, do not format log messages (default: False)\\n\\n Returns:\\n N/A\\n \\\"\\\"\\\"\\n logger.setLevel(logging.INFO)\\n file_handler = logging.FileHandler(log_file, mode=\\\"w\\\")\\n if no_format == False:\\n file_handler.setFormatter(logging.Formatter('%(name)-18s: %(levelname)-8s %(message)s'))\\n file_handler.setLevel(logging.INFO)\\n logger.addHandler(file_handler)\"\n },\n {\n \"identifier\": \"TRIGGER_OOS\",\n \"path\": \"lumina/analyzer/packet_parser/roce_packet.py\",\n \"snippet\": \"TRIGGER_OOS = 1\"\n },\n {\n \"identifier\": \"TRIGGER_TIMEOUT\",\n \"path\": \"lumina/analyzer/packet_parser/roce_packet.py\",\n \"snippet\": \"TRIGGER_TIMEOUT = 2\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import argparse, os, math, glob, logging, time\nimport lumina.analyzer.checker.integrity_check as integrity_check\nimport lumina.analyzer.checker.host_check as host_check\nimport lumina.analyzer.checker.gbn_check as gbn_check\nimport lumina.analyzer.checker.read_gbn_check as read_gbn_check\nimport lumina.orchestrator.host as host\nimport lumina.orchestrator.switch as switch\nfrom lumina.analyzer.main import get_qp_info_list\nfrom lumina.orchestrator.main import Orchestrator\nfrom lumina.analyzer.counter.switch_counter import SwitchCounter\nfrom lumina.analyzer.counter.host_counter import MLNXHostCounter, IntelHostCounter\nfrom lumina.analyzer.pcap_processor.pcap_process import get_packet_list\nfrom lumina.analyzer.measurer.latency_measure import LatencyMeasure\nfrom lumina.utils.config_loggers import config_stream_handler, config_file_handler\nfrom lumina.analyzer.packet_parser.roce_packet import TRIGGER_OOS, TRIGGER_TIMEOUT"},"token_num":{"kind":"number","value":15233,"string":"15,233"},"cropped_code":{"kind":"string","value":"\n trigger = nack.get_trigger()\n if trigger == TRIGGER_OOS:\n logger.info(\"\\t\\t Out of sequence (OOS) triggered retransmission\")\n logger.info(\"\\t\\t But the NACK READ request indicates a loss (%d) before this packet (%d)\" %\\\n (nack.get_roce_pkt_seq(), pkt.get_roce_pkt_seq()))\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n\n elif trigger == TRIGGER_TIMEOUT:\n logger.info(\"\\t\\t Timeout triggered retransmission\")\n logger.info(\"\\t\\t But the NACK READ request indicates a loss (%d) before this packet (%d)\" %\\\n (nack.get_roce_pkt_seq(), pkt.get_roce_pkt_seq()))\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n\n else:\n logger.error(\"\\t\\t NACK READ request should be triggered by either OOS or timeout\")\n\n else:\n # For other verbs, we can only find a NACK in case of out of sequence arriving packets\n if latency_measurement.get_nack(pkt) != None:\n # Out of sequence/NACK triggered retransmission\n next_delivered_pkt_delay = latency_measurement.get_qp_next_delivered_pkt_latency(pkt)\n nack_gen_latency = latency_measurement.get_nack_gen_latency(pkt)\n nack_resp_latency = latency_measurement.get_nack_resp_latency(pkt)\n\n logger.info(\"\\t\\t Out of sequence (OOS) triggered retransmission\")\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n logger.info('\\t\\t Next delivered packet delay: %fus' % (next_delivered_pkt_delay * 1e6))\n logger.info(\"\\t\\t NACK generation latency: %fus\" % (nack_gen_latency * 1e6))\n logger.info('\\t\\t NACK response latency: %fus' % (nack_resp_latency * 1e6))\n\n elif latency_measurement.get_qp_first_nack_before_retrans(pkt) != None:\n logger.info(\"\\t\\t Out of sequence (OOS) triggered retransmission\")\n logger.info(\"\\t\\t But the NACK indicates a loss (%d) before this packet (%d)\")\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n\n else:\n logger.info(\"\\t\\t Timeout triggered retransmission\")\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n\ndef verify_results(orchestrator):\n \"\"\" Verify the experiment results\n\n Args:\n orchestrator (Orchestrator object): Orchestrator object that contains all the configurations\n\n Returns:\n N/A\n \"\"\"\n result_dir = orchestrator.result_path\n num_repeats = orchestrator.num_repeats\n mtu = orchestrator.traffic_conf['mtu']\n msg_size = orchestrator.traffic_conf['message-size']\n num_msgs_per_qp = orchestrator.traffic_conf['num-msgs-per-qp']\n aggregate_pcap_filename = orchestrator.aggregate_pcap_filename\n port_map = {'requester': orchestrator.requester.conf['nic']['switch-port'],\n 'responder': orchestrator.responder.conf['nic']['switch-port'],\n 'requester-mirror': orchestrator.requester_mirror.conf['nic']['switch-port'],\n 'responder-mirror': orchestrator.responder_mirror.conf['nic']['switch-port']}\n\n requester_ip_list = orchestrator.get_requester_ip_list()\n responder_ip_list = orchestrator.get_responder_ip_list()\n\n for iter in range(num_repeats):\n iter = str(iter)\n result_logger = logging.getLogger('Analysis iter %s' % (iter))\n result_logger.handlers.clear()\n config_file_handler(logger=result_logger,\n log_file=os.path.join(result_dir, iter, RESULT_FILENAME),\n no_format=True)\n result_logger.info(\"=\" * 100)\n result_logger.info(\"Iteration %s\" % iter)\n\n switch_msg_snapshot = os.path.join(result_dir,\n iter,\n switch.SWITCH_RESULT_DIR,\n switch.SWITCH_MESSAGE_SNAPSHOT)\n switch_state_snapshot = os.path.join(result_dir,\n iter,\n switch.SWITCH_RESULT_DIR,\n switch.SWITCH_STATE_SNAPSHOT)\n pcap_filename = os.path.join(result_dir,\n iter,\n host.PCAP_RESULT_DIR,\n aggregate_pcap_filename)\n requester_counter_start = os.path.join(result_dir,\n iter,\n host.RDMA_RESULT_DIR,\n host.REQ_START_COUNTER_FILE_NAME)\n requester_counter_finish = os.path.join(result_dir,\n iter,\n host.RDMA_RESULT_DIR,\n host.REQ_FINISH_COUNTER_FILE_NAME)\n responder_counter_start = os.path.join(result_dir,\n iter,\n host.RDMA_RESULT_DIR,\n host.RSP_START_COUNTER_FILE_NAME)\n responder_counter_finish = os.path.join(result_dir,\n iter,\n host.RDMA_RESULT_DIR,\n host.RSP_FINISH_COUNTER_FILE_NAME)\n\n switch_counter = SwitchCounter(switch_state_snapshot, port_map)\n\n if orchestrator.requester.is_mlnx_nic():\n requester_counter = MLNXHostCounter(requester_counter_start, requester_counter_finish)\n elif orchestrator.requester.is_intel_nic():\n requester_counter = IntelHostCounter(requester_counter_start, requester_counter_finish)\n else:\n logging.error(\"Unkown NIC Vendor for rdma requester.\")\n requester_counter = None\n\n if orchestrator.responder.is_mlnx_nic():\n responder_counter = MLNXHostCounter(responder_counter_start, responder_counter_finish)\n elif orchestrator.responder.is_intel_nic():\n responder_counter = IntelHostCounter(responder_counter_start, responder_counter_finish)\n else:\n logging.error(\"Unkown NIC Vendor for rdma responder.\")\n responder_counter = None\n\n"},"all_code":{"kind":"string","value":"\n## All logs will be logged into file LOG_FILENAME\nLOG_FILENAME = \"test_gbn.log\"\n## Results (checkers and measurements) will also be dumped into file RESULT_FILENAME\nRESULT_FILENAME = \"result.log\"\n## Max # of retries for each experiment iteration\nMAX_NB_EXP_RETRIES = 3\n\ndef setup_root_logger(orchestrator):\n \"\"\" Setup the root logger for the test\n\n Args:\n orchestrator (Orchestrator object): Orchestrator object that contains all the configurations\n\n Returns:\n N/A\n \"\"\"\n root_logger = logging.getLogger()\n root_logger.handlers.clear()\n config_stream_handler(root_logger)\n config_file_handler(logger=root_logger,\n log_file=os.path.join(orchestrator.result_path, LOG_FILENAME),\n no_format=False)\n\ndef run_traffic(orchestrator):\n \"\"\" Run the traffic and collect the results\n\n Args:\n orchestrator (Orchestrator object): Orchestrator object that contains all the configurations\n\n Returns:\n bool: True if the experiment is successful, False otherwise\n \"\"\"\n orchestrator.rm_old_files()\n if orchestrator.sync_and_compile() == False:\n logging.error(\"Failed to sync and compile the code\")\n sys.exit(-1)\n logging.info(\"Sync and compile completed\")\n\n if orchestrator.generate_switch_config_file() == False:\n logging.error(\"Failed to generate switch configuration file\")\n sys.exit(-1)\n\n num_repeats = orchestrator.get_num_repeats()\n\n for i in range(num_repeats):\n logging.info(\"=\" * 100)\n nb_retry = 0\n iter_result = False\n\n while nb_retry < MAX_NB_EXP_RETRIES:\n if orchestrator.run_experiment() == False:\n logging.error(\"Iteration %d: Failed to complete experiment\" % i)\n logging.error(\"Iteration %d: Rerun experiment (retry: %d)\" % i, nb_retry)\n nb_retry += 1\n orchestrator.clean_up()\n time.sleep(5)\n continue\n\n logging.info(\"Iteration %d: Completed experiment\" % i)\n try:\n orchestrator.clean_up()\n orchestrator.fetch_results(i)\n logging.info(\"Iteration %d: Fetch experiment results\" % i)\n orchestrator.merge_traces(i)\n logging.info(\"Iteration %d: Merge the pcap files\" % i)\n\n except:\n logging.error(\"Iteration %d: Result collection failed\" % (i))\n logging.error(\"Iteration %d: Rerun experiment (retry: %d)\" % (i, nb_retry))\n nb_retry += 1\n time.sleep(5)\n continue\n\n if orchestrator.check_integrity(i) == False:\n logging.error(\"Iteration %d: Integrity check failed\" % (i))\n logging.error(\"Iteration %d: Rerun experiment (retry: %d)\" % (i, nb_retry))\n nb_retry += 1\n time.sleep(5)\n continue\n\n iter_result = True\n break\n\n if iter_result is False:\n logging.error(\"Iteration %d: Still failed after %d retries\" % (i, nb_retry))\n return False\n\n return True\n\ndef analyze_retrans_latency(pkt, latency_measurement, is_read, logger):\n \"\"\" Analyze the retransmission latency breakdown for an undelivered packet\n\n Args:\n pkt (Packet object): The undelivered packet\n latency_measurement (LatencyMeasure object): A LatencyMeasure object that can compute latency breakdown\n is_read (bool): If we use RDMA READ in this experiment\n logger (logging.Logger): A logger object\n\n Returns:\n N/A\n \"\"\"\n # All the undelivered packets should be retransmitted in our test cases\n if latency_measurement.get_retransmit_pkt(pkt) == None:\n logger.error(\"\\t\\t No retransmit packet found for this packet\")\n logger.error(\"\\t\\t It is possible that this undelivered packet is a redundant transmission\")\n return\n\n retrans_latency = latency_measurement.get_retransmit_latency(pkt)\n if is_read == True:\n # For RDMA READ, we should always find a NACK READ request that triggers retransmission\n nack = latency_measurement.get_nack(pkt)\n if nack is not None:\n trigger = nack.get_trigger()\n if trigger == TRIGGER_OOS:\n next_delivered_pkt_delay = latency_measurement.get_qp_next_delivered_pkt_latency(pkt)\n nack_gen_latency = latency_measurement.get_nack_gen_latency(pkt)\n nack_resp_latency = latency_measurement.get_nack_resp_latency(pkt)\n logger.info(\"\\t\\t Out of sequence (OOS) triggered retransmission\")\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n logger.info('\\t\\t Next delivered packet delay: %fus' % (next_delivered_pkt_delay * 1e6))\n logger.info(\"\\t\\t NACK READ request generation latency: %fus\" % (nack_gen_latency * 1e6))\n logger.info('\\t\\t NACK READ request response latency: %fus' % (nack_resp_latency * 1e6))\n\n elif trigger == TRIGGER_TIMEOUT:\n nack_resp_latency = latency_measurement.get_nack_resp_latency(pkt)\n logger.info(\"\\t\\t Timeout triggered retransmission\")\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n logger.info('\\t\\t NACK READ request response latency: %fus' % (nack_resp_latency * 1e6))\n\n else:\n logger.error(\"\\t\\t NACK READ request should be triggered by either OOS or timeout\")\n\n else:\n nack = latency_measurement.get_qp_first_nack_before_retrans(pkt)\n if nack is None:\n logger.error(\"\\t\\t Cannot find the NACK READ request to recover this lost packet\")\n return\n\n trigger = nack.get_trigger()\n if trigger == TRIGGER_OOS:\n logger.info(\"\\t\\t Out of sequence (OOS) triggered retransmission\")\n logger.info(\"\\t\\t But the NACK READ request indicates a loss (%d) before this packet (%d)\" %\\\n (nack.get_roce_pkt_seq(), pkt.get_roce_pkt_seq()))\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n\n elif trigger == TRIGGER_TIMEOUT:\n logger.info(\"\\t\\t Timeout triggered retransmission\")\n logger.info(\"\\t\\t But the NACK READ request indicates a loss (%d) before this packet (%d)\" %\\\n (nack.get_roce_pkt_seq(), pkt.get_roce_pkt_seq()))\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n\n else:\n logger.error(\"\\t\\t NACK READ request should be triggered by either OOS or timeout\")\n\n else:\n # For other verbs, we can only find a NACK in case of out of sequence arriving packets\n if latency_measurement.get_nack(pkt) != None:\n # Out of sequence/NACK triggered retransmission\n next_delivered_pkt_delay = latency_measurement.get_qp_next_delivered_pkt_latency(pkt)\n nack_gen_latency = latency_measurement.get_nack_gen_latency(pkt)\n nack_resp_latency = latency_measurement.get_nack_resp_latency(pkt)\n\n logger.info(\"\\t\\t Out of sequence (OOS) triggered retransmission\")\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n logger.info('\\t\\t Next delivered packet delay: %fus' % (next_delivered_pkt_delay * 1e6))\n logger.info(\"\\t\\t NACK generation latency: %fus\" % (nack_gen_latency * 1e6))\n logger.info('\\t\\t NACK response latency: %fus' % (nack_resp_latency * 1e6))\n\n elif latency_measurement.get_qp_first_nack_before_retrans(pkt) != None:\n logger.info(\"\\t\\t Out of sequence (OOS) triggered retransmission\")\n logger.info(\"\\t\\t But the NACK indicates a loss (%d) before this packet (%d)\")\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n\n else:\n logger.info(\"\\t\\t Timeout triggered retransmission\")\n logger.info(\"\\t\\t Retransmission latency: %fus\" % (retrans_latency * 1e6))\n\ndef verify_results(orchestrator):\n \"\"\" Verify the experiment results\n\n Args:\n orchestrator (Orchestrator object): Orchestrator object that contains all the configurations\n\n Returns:\n N/A\n \"\"\"\n result_dir = orchestrator.result_path\n num_repeats = orchestrator.num_repeats\n mtu = orchestrator.traffic_conf['mtu']\n msg_size = orchestrator.traffic_conf['message-size']\n num_msgs_per_qp = orchestrator.traffic_conf['num-msgs-per-qp']\n aggregate_pcap_filename = orchestrator.aggregate_pcap_filename\n port_map = {'requester': orchestrator.requester.conf['nic']['switch-port'],\n 'responder': orchestrator.responder.conf['nic']['switch-port'],\n 'requester-mirror': orchestrator.requester_mirror.conf['nic']['switch-port'],\n 'responder-mirror': orchestrator.responder_mirror.conf['nic']['switch-port']}\n\n requester_ip_list = orchestrator.get_requester_ip_list()\n responder_ip_list = orchestrator.get_responder_ip_list()\n\n for iter in range(num_repeats):\n iter = str(iter)\n result_logger = logging.getLogger('Analysis iter %s' % (iter))\n result_logger.handlers.clear()\n config_file_handler(logger=result_logger,\n log_file=os.path.join(result_dir, iter, RESULT_FILENAME),\n no_format=True)\n result_logger.info(\"=\" * 100)\n result_logger.info(\"Iteration %s\" % iter)\n\n switch_msg_snapshot = os.path.join(result_dir,\n iter,\n switch.SWITCH_RESULT_DIR,\n switch.SWITCH_MESSAGE_SNAPSHOT)\n switch_state_snapshot = os.path.join(result_dir,\n iter,\n switch.SWITCH_RESULT_DIR,\n switch.SWITCH_STATE_SNAPSHOT)\n pcap_filename = os.path.join(result_dir,\n iter,\n host.PCAP_RESULT_DIR,\n aggregate_pcap_filename)\n requester_counter_start = os.path.join(result_dir,\n iter,\n host.RDMA_RESULT_DIR,\n host.REQ_START_COUNTER_FILE_NAME)\n requester_counter_finish = os.path.join(result_dir,\n iter,\n host.RDMA_RESULT_DIR,\n host.REQ_FINISH_COUNTER_FILE_NAME)\n responder_counter_start = os.path.join(result_dir,\n iter,\n host.RDMA_RESULT_DIR,\n host.RSP_START_COUNTER_FILE_NAME)\n responder_counter_finish = os.path.join(result_dir,\n iter,\n host.RDMA_RESULT_DIR,\n host.RSP_FINISH_COUNTER_FILE_NAME)\n\n switch_counter = SwitchCounter(switch_state_snapshot, port_map)\n\n if orchestrator.requester.is_mlnx_nic():\n requester_counter = MLNXHostCounter(requester_counter_start, requester_counter_finish)\n elif orchestrator.requester.is_intel_nic():\n requester_counter = IntelHostCounter(requester_counter_start, requester_counter_finish)\n else:\n logging.error(\"Unkown NIC Vendor for rdma requester.\")\n requester_counter = None\n\n if orchestrator.responder.is_mlnx_nic():\n responder_counter = MLNXHostCounter(responder_counter_start, responder_counter_finish)\n elif orchestrator.responder.is_intel_nic():\n responder_counter = IntelHostCounter(responder_counter_start, responder_counter_finish)\n else:\n logging.error(\"Unkown NIC Vendor for rdma responder.\")\n responder_counter = None\n"},"next_line":{"kind":"string","value":" qp_info_list = get_qp_info_list(switch_msg_snapshot)"},"gold_snippet_index":{"kind":"number","value":0,"string":"0"},"created_at":{"kind":"string","value":"2023-12-09 08:21:14+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5981,"cells":{"repo_name":{"kind":"string","value":"ebb-earl-co/tidal-wave"},"file_path":{"kind":"string","value":"tidal_wave/main.py"},"context":{"kind":"list like","value":[{"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 Android-/Windows-/MacOS-\n gleaned API token; the latter to be able to access HiRes fLaC audio.\n Returns a tuple of a requests.Session object, if no error, and the\n AudioFormat instance passed in; or (None, \"\") in the event of error.\n \"\"\"\n android_formats: Set[AudioFormat] = {\n AudioFormat.sony_360_reality_audio,\n AudioFormat.hi_res,\n }\n fire_tv_formats: Set[AudioFormat] = {\n AudioFormat.dolby_atmos,\n AudioFormat.mqa,\n AudioFormat.lossless,\n AudioFormat.high,\n AudioFormat.low,\n }\n if audio_format in fire_tv_formats:\n return (login_fire_tv(), audio_format)\n elif audio_format in android_formats:\n options: set = {\"android\", \"a\", \"windows\", \"w\"}\n _input: str = \"\"\n while _input not in options:\n _input = typer.prompt(\n \"For which of Android [a] or Windows [w] would you like to provide an API token?\"\n ).lower()\n else:\n if _input in {\"android\", \"a\"}:\n return (login_android(), audio_format)\n elif _input in {\"windows\", \"w\"}:\n return (login_windows(), audio_format)\n else:\n logger.critical(\n \"Please provide one of the following: \"\n f\"{', '.join(e.value for e in AudioFormat)}\"\n )\n return (None, \"\")"},{"identifier":"AudioFormat","path":"tidal_wave/login.py","snippet":"class AudioFormat(str, Enum):\n sony_360_reality_audio = \"360\"\n dolby_atmos = \"Atmos\"\n hi_res = \"HiRes\"\n mqa = \"MQA\"\n lossless = \"Lossless\"\n high = \"High\"\n low = \"Low\""},{"identifier":"LogLevel","path":"tidal_wave/login.py","snippet":"class LogLevel(str, Enum):\n debug = \"DEBUG\" # 10\n info = \"INFO\" # 20\n warning = \"WARNING\" # 30\n error = \"ERROR\" # 40\n critical = \"CRITICAL\" # 50"},{"identifier":"Album","path":"tidal_wave/album.py","snippet":"class Album:\n album_id: int\n\n def __post_init__(self):\n self.album_dir: Optional[Path] = None\n self.album_cover_saved: bool = False\n\n def get_items(self, session: Session):\n \"\"\"This method populates self.tracks by requesting from\n TIDAL albums/items endpoint.\"\"\"\n album_items: AlbumsItemsResponseJSON = request_album_items(\n session=session, identifier=self.album_id\n )\n _items = album_items.items if album_items is not None else ()\n self.tracks = tuple(_item.item for _item in _items)\n\n def get_metadata(self, session: Session):\n \"\"\"This method populates self.metadata by requesting from\n TIDAL /albums endpoint\"\"\"\n self.metadata: AlbumsEndpointResponseJSON = request_albums(\n session=session, identifier=self.album_id\n )\n\n def get_review(self, session: Session):\n \"\"\"This method requests the review corresponding to self.album_id\n in TIDAL. If it exists, it is written to disk as AlbumReview.json\n in self.album_dir\"\"\"\n self.album_review: Optional[AlbumsReviewResponseJSON] = request_album_review(\n session=session, identifier=self.album_id\n )\n if self.album_review is not None:\n (self.album_dir / \"AlbumReview.json\").write_text(\n self.album_review.to_json()\n )\n\n def set_dir(self, out_dir: Path):\n \"\"\"This method populates self.album_dir as a sub-subdirectory of\n out_dir: its parent directory is the name of the (main) artist of\n the album\"\"\"\n artist_substring: str = self.metadata.artist.name.replace(\"..\", \"\")\n album_substring: str = (\n f\"{self.metadata.name.replace('..', '')} \"\n f\"[{self.metadata.id}] [{self.metadata.release_date.year}]\"\n )\n self.album_dir = out_dir / artist_substring / album_substring\n self.album_dir.mkdir(parents=True, exist_ok=True)\n\n if self.metadata.number_of_volumes > 1:\n for v in range(1, self.metadata.number_of_volumes + 1):\n volume_substring: str = f\"Volume {v}\"\n (out_dir / artist_substring / album_substring / volume_substring).mkdir(\n parents=True, exist_ok=True\n )\n\n def save_cover_image(self, session: Session, out_dir: Path):\n \"\"\"This method writes cover.jpg in self.album_dir via the\n utils.download_cover_image() function. If successful,\n then self.album_cover_saved takes the value True\"\"\"\n if self.album_dir is None:\n self.set_dir(out_dir=out_dir)\n self.cover_path: Path = self.album_dir / \"cover.jpg\"\n if not self.cover_path.exists():\n download_cover_image(\n session=session,\n cover_uuid=self.metadata.cover,\n output_dir=self.album_dir,\n )\n else:\n self.album_cover_saved = True\n\n def get_tracks(\n self, session: Session, audio_format: AudioFormat, out_dir: Path\n ) -> List[Optional[str]]:\n \"\"\"This method uses self.tracks to call track.Track.get() for each\n track in self.tracks. It uses the result of each of these calls to\n populate self.track_files\"\"\"\n track_files: List[str] = [None] * self.metadata.number_of_tracks\n for i, t in enumerate(self.tracks): # type(t) is TracksEndpointResponseJSON\n track: Track = Track(track_id=t.id)\n\n track_files_value: Optional[str] = track.get(\n session=session,\n audio_format=audio_format,\n out_dir=out_dir,\n metadata=t,\n album=self.metadata,\n )\n track_files[i] = {track.metadata.track_number: track_files_value}\n else:\n self.track_files = track_files\n\n def dumps(self):\n \"\"\"This method returns a JSON-like string of self.track_files\"\"\"\n return json.dumps(self.track_files)\n\n def dump(self, fp=sys.stdout):\n \"\"\"This method writes to (by default) STDOUT a\n JSON-like string of self.track_files\"\"\"\n json.dump(self.track_files, fp)\n\n def get(\n self,\n session: Session,\n audio_format: AudioFormat,\n out_dir: Path,\n metadata: Optional[AlbumsEndpointResponseJSON] = None,\n ):\n \"\"\"This method is the driver method of the class. It calls the\n other methods in order:\n 1. get_metadata()\n 2. get_items()\n 3. save_cover_image()\n 4. get_review()\n 5. get_tracks()\n \"\"\"\n if metadata is None:\n self.get_metadata(session)\n else:\n self.metadata = metadata\n \n if self.metadata is None:\n self.track_files = {}\n return\n\n self.get_items(session)\n self.save_cover_image(session, out_dir)\n self.get_review(session)\n self.get_tracks(session, audio_format, out_dir)"},{"identifier":"Artist","path":"tidal_wave/artist.py","snippet":"class Artist:\n artist_id: int\n\n def set_metadata(self, session: Session):\n \"\"\"This function requests from TIDAL API endpoint /artists and\n stores the results in self.metadata\"\"\"\n self.metadata: Optional[ArtistsEndpointResponseJSON] = request_artists(\n session, self.artist_id\n )\n\n def save_artist_image(self, session: Session):\n \"\"\"This method writes the bytes of self.metadata.picture to\n the file cover.jpg in self.artist_dir\"\"\"\n artist_image: Path = self.artist_dir / \"cover.jpg\"\n if not artist_image.exists():\n download_cover_image(\n session, self.metadata.picture, self.artist_dir, dimension=750\n )\n\n def set_albums(self, session: Session):\n \"\"\"This method requests from TIDAL API endpoint /artists/albums and\n stores the results in self.albums\"\"\"\n self.albums: Optional[ArtistsAlbumsResponseJSON] = request_artists_albums(\n session, self.artist_id\n )\n\n def set_audio_works(self, session: Session):\n \"\"\"This method requests from TIDAL API endpoint\n /artists/albums?filter=EPSANDSINGLES and stores the results in self.albums\"\"\"\n self.albums: Optional[ArtistsAlbumsResponseJSON] = request_artists_audio_works(\n session, self.artist_id\n )\n\n def set_videos(self, session: Session):\n \"\"\"This method requests from TIDAL API endpoint /artists/videos and\n stores the results in self.albums\"\"\"\n self.videos: Optional[ArtistsVideosResponseJSON] = request_artists_videos(\n session, self.artist_id\n )\n\n def set_dir(self, out_dir: Path):\n \"\"\"This method sets self.artist_dir and creates the directory on the file system\n if it does not exist\"\"\"\n self.name: str = self.metadata.name.replace(\"..\", \"\")\n self.artist_dir = out_dir / self.name\n self.artist_dir.mkdir(parents=True, exist_ok=True)\n\n def get_albums(\n self,\n session: Session,\n audio_format: AudioFormat,\n out_dir: Path,\n include_eps_singles: bool = False,\n ) -> List[Optional[str]]:\n \"\"\"This method first fetches the total albums on TIDAL's service\n corresponding to the artist with ID self.artist_id. Then, each of\n the albums (and, optionally, EPs and singles) is requested and\n written to subdirectories of out_dir\"\"\"\n if include_eps_singles:\n self.set_audio_works(session)\n logger.info(\n f\"Starting attempt to get {self.albums.total_number_of_items} \"\n \"albums, EPs, and singles for artist with ID \"\n f\"{self.metadata.id}, '{self.name}'\"\n )\n else:\n self.set_albums(session)\n logger.info(\n f\"Starting attempt to get {self.albums.total_number_of_items} albums \"\n f\"for artist with ID {self.metadata.id}, '{self.name}'\"\n )\n\n for i, a in enumerate(self.albums.items):\n album: Album = Album(album_id=a.id)\n album.get(\n session=session,\n audio_format=audio_format,\n out_dir=out_dir,\n metadata=a,\n )\n\n def get_videos(\n self,\n session: Session,\n out_dir: Path,\n ) -> List[Optional[str]]:\n \"\"\"This method sets self.videos by calling self.set_videos()\n then, for each video, instantiates a Video object and executes\n video.get()\"\"\"\n self.set_videos(session)\n logger.info(\n f\"Starting attempt to get {self.videos.total_number_of_items} videos \"\n f\"for artist with ID {self.metadata.id}, '{self.name}'\"\n )\n for i, v in enumerate(self.videos.items):\n video: Video = Video(video_id=v.id)\n video.get(\n session=session,\n out_dir=out_dir,\n metadata=v,\n )\n\n def get(\n self,\n session: Session,\n audio_format: AudioFormat,\n out_dir: Path,\n include_eps_singles: bool,\n ):\n \"\"\"This is the driver method of the class. It executes the other\n methods in order:\n 1. set_metadata\n 2. set_dir\n 3. save_artist_image\n 4. get_videos\n 5. get_albums\n \"\"\"\n self.set_metadata(session)\n \n if self.metadata is None:\n return\n \n self.set_dir(out_dir)\n self.save_artist_image(session)\n self.get_videos(session, out_dir)\n if include_eps_singles:\n self.get_albums(session, audio_format, out_dir, include_eps_singles=True)\n self.get_albums(session, audio_format, out_dir, include_eps_singles=False)"},{"identifier":"Mix","path":"tidal_wave/mix.py","snippet":"class Mix:\n mix_id: str\n\n def __post_init__(self):\n self.mix_dir: Optional[Path] = None\n self.mix_cover_saved: bool = False\n\n def get_metadata(self, session: Session):\n \"\"\"Request from TIDAL API /playlists endpoint\"\"\"\n self.metadata: Optional[PlaylistsEndpointResponseJSON] = request_mixes(\n session=session, mix_id=self.mix_id\n )\n \n if self.metadata is None:\n return\n \n self.name = (\n self.metadata.title.replace(\"/\", \"_\")\n .replace(\"|\", \"_\")\n .replace(\":\", \" -\")\n .replace('\"', \"\")\n .replace(\"..\", \"\")\n )\n\n def set_items(self, session: Session):\n \"\"\"Uses data from TIDAL API /mixes/items endpoint to\n populate self.items\"\"\"\n mix_items: Optional[MixesItemsResponseJSON] = get_mix(\n session=session, mix_id=self.mix_id\n )\n if mix_items is None:\n self.items = tuple()\n else:\n self.items: Tuple[Optional[MixItem]] = tuple(mix_items.items)\n\n def set_dir(self, out_dir: Path):\n \"\"\"Populates self.mix_dir based on self.name, self.mix_id\"\"\"\n mix_substring: str = f\"{self.name} [{self.mix_id}]\"\n self.mix_dir: Path = out_dir / \"Mixes\" / mix_substring\n self.mix_dir.mkdir(parents=True, exist_ok=True)\n\n def save_cover_image(self, session: Session, out_dir: Path):\n \"\"\"Requests self.metadata.image and attempts to write it to disk\"\"\"\n if self.mix_dir is None:\n self.set_dir(out_dir=out_dir)\n self.cover_path: Path = self.mix_dir / \"cover.jpg\"\n if not self.cover_path.exists():\n with session.get(\n url=self.metadata.image, params={k: None for k in session.params}\n ) as r:\n (self.mix_dir / \"cover.jpg\").write_bytes(r.content)\n\n self.mix_cover_saved = True\n else:\n self.mix_cover_saved = True\n\n def get_items(self, session: Session, audio_format: AudioFormat):\n \"\"\"Using either Track.get() or Video.get(), attempt to request\n the data for each track or video in self.items\"\"\"\n if len(self.items) == 0:\n return\n tracks_videos: list = [None] * len(self.items)\n for i, item in enumerate(self.items):\n if item is None:\n tracks_videos[i] = None\n continue\n elif isinstance(item, TracksEndpointResponseJSON):\n track: Track = Track(track_id=item.id)\n track.get(\n session=session,\n audio_format=audio_format,\n out_dir=self.mix_dir,\n metadata=item,\n )\n tracks_videos[i] = track\n elif isinstance(item, VideosEndpointResponseJSON):\n video: Video = Video(video_id=item.id)\n video.get(\n session=session,\n out_dir=self.mix_dir,\n metadata=item,\n )\n tracks_videos[i] = video\n else:\n tracks_videos[i] = None\n continue\n else:\n self.tracks_videos: Tuple[\n Tuple[int, Optional[Union[Track, Video]]]\n ] = tuple(tracks_videos)\n return tracks_videos\n\n def flatten_mix_dir(self):\n \"\"\"When self.get_items() is called, the tracks and/or videos in\n self.items are downloaded using their self-contained .get() logic;\n this means that they will be downloaded to albums. This function\n \"flattens\" self.mix_dir, meaning that it moves all downloaded\n audio and video files to self.mix_dir, and removes the various\n subdirectories created\"\"\"\n files: List[Dict[int, Optional[str]]] = [None] * len(self.tracks_videos)\n if len(self.tracks_videos) == 0:\n return\n subdirs: Set[Path] = set()\n\n for i, tv in enumerate(self.tracks_videos, 1):\n if getattr(tv, \"outfile\") is None:\n try:\n getattr(tv, \"album_dir\")\n except AttributeError:\n pass\n else:\n subdirs.add(tv.album_dir)\n subdirs.add(tv.album_dir.parent)\n files[i - 1] = {i: None}\n continue\n\n _path: Optional[Path] = Path(tv.outfile) if tv is not None else None\n # if the item never got turned into a track or video\n if _path is None:\n files[i - 1] = {i: None}\n continue\n\n # if the track or video didn't download\n if _path.exists():\n if _path.stat().st_size == 0:\n files[i - 1] = {i: None}\n continue\n else:\n files[i - 1] = {i: None}\n continue\n\n # otherwise, move files and clean up\n if isinstance(tv, Track):\n new_path: Path = self.mix_dir / f\"{i:03d} - {tv.trackname}\"\n new_path.write_bytes(_path.read_bytes())\n _path.unlink()\n files[i - 1] = {i: str(new_path.absolute())}\n elif isinstance(tv, Video):\n new_path: Path = self.mix_dir / f\"{i:03d} - {_path.name}\"\n new_path.write_bytes(_path.read_bytes())\n _path.unlink()\n files[i - 1] = {i: str(new_path.absolute())}\n else:\n self.files: List[Dict[int, Optional[str]]] = files\n\n # Find all subdirectories written to\n subdirs: Set[Path] = set()\n for tv in self.tracks_videos:\n if isinstance(tv, Track):\n try:\n getattr(tv, \"album_dir\")\n except AttributeError:\n pass\n else:\n subdirs.add(tv.album_dir)\n subdirs.add(tv.album_dir.parent)\n elif isinstance(tv, Video):\n subdirs.add(tv.artist_dir)\n\n # Copy all artist images, artist bio JSON files out\n # of subdirs\n artist_images: Set[Path] = set()\n for subdir in subdirs:\n for p in subdir.glob(\"*.jpg\"):\n if p.name == \"cover.jpg\":\n continue\n artist_images.add(p)\n else:\n for artist_image_path in artist_images:\n if artist_image_path.exists():\n shutil.copyfile(\n artist_image_path.absolute(),\n self.mix_dir / artist_image_path.name,\n )\n\n artist_bios: Set[Path] = set()\n for subdir in subdirs:\n for p in subdir.glob(\"*bio.json\"):\n artist_bios.add(p)\n else:\n for artist_bio_path in artist_bios:\n if artist_bio_path.exists():\n shutil.copyfile(\n artist_bio_path.absolute(),\n self.mix_dir / artist_bio_path.name,\n )\n\n # Remove all subdirs\n for subdir in subdirs:\n if subdir.exists():\n shutil.rmtree(subdir)\n else:\n return self.mix_dir\n\n def dumps(self):\n return json.dumps(self.files)\n\n def dump(self, fp=sys.stdout):\n json.dump(self.files, fp)\n\n def get(self, session: Session, audio_format: AudioFormat, out_dir: Path):\n \"\"\"The main method of this class, executing a number of other methods\n in a row:\n - self.get_metadata()\n - self.set_items()\n - self.set_dir()\n - self.save_cover_image()\n - self.get_items()\n - self.flatten_playlist_dir()\n \"\"\"\n self.get_metadata(session)\n \n if self.metadata is None:\n self.files = {}\n return\n \n self.set_items(session)\n self.set_dir(out_dir)\n self.save_cover_image(session, out_dir)\n try:\n self.save_description()\n except Exception:\n pass\n\n _get_items = self.get_items(session, audio_format)\n if _get_items is None:\n logger.critical(f\"Could not retrieve mix with ID '{self.mix_id}'\")\n return\n self.flatten_mix_dir()\n logger.info(f\"Mix files written to '{self.mix_dir}'\")"},{"identifier":"Playlist","path":"tidal_wave/playlist.py","snippet":"class Playlist:\n playlist_id: str # UUID4\n\n def __post_init__(self):\n self.playlist_dir: Optional[Path] = None\n self.playlist_cover_saved: bool = False\n\n def get_metadata(self, session: Session):\n \"\"\"Request from TIDAL API /playlists endpoint\"\"\"\n self.metadata: Optional[PlaylistsEndpointResponseJSON] = request_playlists(\n session=session, identifier=self.playlist_id\n )\n \n if self.metadata is None:\n return\n \n self.name = (\n self.metadata.title.replace(\"/\", \"_\")\n .replace(\"|\", \"_\")\n .replace(\":\", \" -\")\n .replace('\"', \"\")\n .replace(\"..\", \"\")\n )\n\n def set_items(self, session: Session):\n \"\"\"Uses data from TIDAL API /playlists/items endpoint to\n populate self.items\"\"\"\n playlist_items: Optional[PlaylistsItemsResponseJSON] = get_playlist(\n session=session, playlist_id=self.playlist_id\n )\n if playlist_items is None:\n self.items = tuple()\n else:\n self.items: Tuple[Optional[PlaylistItem]] = tuple(playlist_items.items)\n\n def set_dir(self, out_dir: Path):\n \"\"\"Populates self.playlist_dir based on self.name, self.playlist_id\"\"\"\n playlist_substring: str = f\"{self.name} [{self.playlist_id}]\"\n self.playlist_dir: Path = out_dir / \"Playlists\" / playlist_substring\n self.playlist_dir.mkdir(parents=True, exist_ok=True)\n\n def save_cover_image(self, session: Session, out_dir: Path):\n \"\"\"Requests self.metadata.image and attempts to write it to disk\"\"\"\n if self.playlist_dir is None:\n self.set_dir(out_dir=out_dir)\n self.cover_path: Path = self.playlist_dir / \"cover.jpg\"\n if not self.cover_path.exists():\n download_cover_image(\n session=session,\n cover_uuid=self.metadata.square_image,\n output_dir=self.playlist_dir,\n dimension=1080,\n )\n else:\n self.playlist_cover_saved = True\n\n def save_description(self):\n \"\"\"Requests self.metadata.description and attempts to write it to disk\"\"\"\n description_path: Path = self.playlist_dir / \"PlaylistDescription.txt\"\n if self.metadata.description is not None and len(self.metadata.description) > 0:\n if not description_path.exists():\n description_path.write_text(f\"{self.metadata.description}\\n\")\n\n def get_items(self, session: Session, audio_format: AudioFormat):\n \"\"\"Using either Track.get() or Video.get(), attempt to request\n the data for each track or video in self.items\"\"\"\n if len(self.items) == 0:\n return\n tracks_videos: list = [None] * len(self.items)\n for i, item in enumerate(self.items):\n if item is None:\n tracks_videos[i] = None\n continue\n elif isinstance(item, TracksEndpointResponseJSON):\n track: Track = Track(track_id=item.id)\n track.get(\n session=session,\n audio_format=audio_format,\n out_dir=self.playlist_dir,\n metadata=item,\n )\n tracks_videos[i] = track\n elif isinstance(item, VideosEndpointResponseJSON):\n video: Video = Video(video_id=item.id)\n video.get(\n session=session,\n out_dir=self.playlist_dir,\n metadata=item,\n )\n tracks_videos[i] = video\n else:\n tracks_videos[i] = None\n continue\n else:\n self.tracks_videos: Tuple[\n Tuple[int, Optional[Union[Track, Video]]]\n ] = tuple(tracks_videos)\n return tracks_videos\n\n def flatten_playlist_dir(self):\n \"\"\"When self.get_items() is called, the tracks and/or videos in\n self.items are downloaded using their self-contained .get() logic;\n this means that they will be downloaded to albums. This function\n \"flattens\" self.playlist_dir, meaning that it moves all downloaded\n audio and video files to self.playlist_dir, and removes the various\n subdirectories created\"\"\"\n files: List[Dict[int, Optional[str]]] = [None] * len(self.tracks_videos)\n if len(self.tracks_videos) == 0:\n return\n subdirs: Set[Path] = set()\n\n for i, tv in enumerate(self.tracks_videos, 1):\n if getattr(tv, \"outfile\") is None:\n try:\n getattr(tv, \"album_dir\")\n except AttributeError:\n pass\n else:\n subdirs.add(tv.album_dir)\n subdirs.add(tv.album_dir.parent)\n files[i - 1] = {i: None}\n continue\n\n _path: Optional[Path] = Path(tv.outfile) if tv is not None else None\n # if the item never got turned into a track or video\n if _path is None:\n files[i - 1] = {i: None}\n continue\n\n # if the track or video didn't download\n if _path.exists():\n if _path.stat().st_size == 0:\n files[i - 1] = {i: None}\n continue\n else:\n files[i - 1] = {i: None}\n continue\n\n # otherwise, move files and clean up\n if isinstance(tv, Track):\n new_path: Path = self.playlist_dir / f\"{i:03d} - {tv.trackname}\"\n new_path.write_bytes(_path.read_bytes())\n _path.unlink()\n files[i - 1] = {i: str(new_path.absolute())}\n elif isinstance(tv, Video):\n new_path: Path = self.playlist_dir / f\"{i:03d} - {_path.name}\"\n new_path.write_bytes(_path.read_bytes())\n _path.unlink()\n files[i - 1] = {i: str(new_path.absolute())}\n else:\n self.files: List[Dict[int, Optional[str]]] = files\n\n # Find all subdirectories written to\n subdirs: Set[Path] = set()\n for tv in self.tracks_videos:\n if isinstance(tv, Track):\n try:\n getattr(tv, \"album_dir\")\n except AttributeError:\n pass\n else:\n subdirs.add(tv.album_dir)\n subdirs.add(tv.album_dir.parent)\n elif isinstance(tv, Video):\n subdirs.add(tv.artist_dir)\n\n # Copy all artist images, artist bio JSON files out\n # of subdirs\n artist_images: Set[Path] = set()\n for subdir in subdirs:\n for p in subdir.glob(\"*.jpg\"):\n if p.name == \"cover.jpg\":\n continue\n artist_images.add(p)\n else:\n for artist_image_path in artist_images:\n if artist_image_path.exists():\n shutil.copyfile(\n artist_image_path.absolute(),\n self.playlist_dir / artist_image_path.name,\n )\n\n artist_bios: Set[Path] = set()\n for subdir in subdirs:\n for p in subdir.glob(\"*bio.json\"):\n artist_bios.add(p)\n else:\n for artist_bio_path in artist_bios:\n if artist_bio_path.exists():\n shutil.copyfile(\n artist_bio_path.absolute(),\n self.playlist_dir / artist_bio_path.name,\n )\n\n # Remove all subdirs\n for subdir in subdirs:\n if subdir.exists():\n shutil.rmtree(subdir)\n else:\n return self.playlist_dir\n\n def craft_m3u8_text(self):\n \"\"\"This method creates a file called playlist.m3u8 in self.playlist_dir\n that is a standard M3U. Needs to be called after self.flatten_playlist_dir\n in order to be able to access self.files\n N.b. the already-written file is temporarily copied to a .mp4 version in a\n temporary directory because .m4a files cannot be read with mutagen.\"\"\"\n m3u_text: str = f\"#EXTM3U\\n#EXTENC:UTF-8\\n#EXTIMG:{str(self.cover_path.absolute())}\\n#PLAYLIST:{self.name}\\n\"\n\n logger.info(\n f\"Creating .m3u8 playlist file for Playlist with ID '{self.playlist_id}'\"\n )\n for d in self.files:\n file: str = next(iter(d.values()))\n if file is None:\n continue\n elif file.endswith(\".flac\"):\n m = mutagen.File(file)\n artist: str = m.get(\"artist\", [\"\"])[0]\n title: str = m.get(\"title\", [\"\"])[0]\n extinf: str = (\n f\"#EXTINF:{math.ceil(m.info.length)},\"\n f\"{artist} - {title}\\n{file}\\n\"\n )\n m3u_text += extinf\n elif file.endswith(\".mka\"):\n m = mutagen.File(file)\n artist: str = m.get(\"ARTI\", [\"\"])[0]\n title: str = m.get(\"TITL\", [\"\"])[0]\n extinf: str = (\n f\"#EXTINF:{math.ceil(m.info.length)},\"\n f\"{artist} - {title}\\n{file}\\n\"\n )\n m3u_text += extinf\n elif file.endswith(\".m4a\"):\n # Mutagen cannot read .m4a files, so make a copy with all\n # of the metadata tags as a .mp4 in a temporary directory\n with temporary_file(suffix=\".mp4\") as tf:\n ffmpeg.input(file, hide_banner=None, y=None).output(\n tf.name,\n acodec=\"copy\",\n vcodec=\"copy\",\n loglevel=\"quiet\",\n ).run()\n\n m = mutagen.File(tf.name)\n artist: str = m.get(\"\\xa9ART\", [\"\"])[0]\n title: str = m.get(\"\\xa9nam\", [\"\"])[0]\n extinf: str = (\n f\"#EXTINF:{math.ceil(m.info.length)},\"\n f\"{artist} - {title}\\n{file}\\n\"\n )\n m3u_text += extinf\n else:\n return m3u_text\n\n def dumps(self):\n return json.dumps(self.files)\n\n def dump(self, fp=sys.stdout):\n json.dump(self.files, fp)\n\n def get(self, session: Session, audio_format: AudioFormat, out_dir: Path):\n \"\"\"The main method of this class, executing a number of other methods\n in a row:\n - self.get_metadata()\n - self.set_items()\n - self.set_dir()\n - self.save_cover_image()\n - self.save_description()\n - self.get_items()\n - self.flatten_playlist_dir()\n \"\"\"\n self.get_metadata(session)\n \n if self.metadata is None:\n self.files = {}\n return\n \n self.set_items(session)\n self.set_dir(out_dir)\n self.save_cover_image(session, out_dir)\n try:\n self.save_description()\n except Exception:\n pass\n\n _get_items = self.get_items(session, audio_format)\n if _get_items is None:\n logger.critical(f\"Could not retrieve playlist with ID '{self.playlist_id}'\")\n return\n\n self.flatten_playlist_dir()\n\n try:\n m3u8_text: str = self.craft_m3u8_text()\n except Exception as e:\n logger.warning(\n \"Unable to create playlist.m3u8 file for \"\n f\"playlist with ID '{self.playlist_id}'\"\n )\n logger.debug(e)\n else:\n with open(self.playlist_dir / \"playlist.m3u8\", \"w\") as f:\n f.write(m3u8_text)\n\n logger.info(f\"Playlist files written to '{self.playlist_dir}'\")"},{"identifier":"Track","path":"tidal_wave/track.py","snippet":"class Track:\n track_id: int\n\n def __post_init__(self):\n self._has_lyrics: Optional[bool] = None\n self.tags: dict = {}\n self.album_cover_saved: bool = False\n\n def get_metadata(self, session: Session):\n self.metadata: Optional[TracksEndpointResponseJSON] = request_tracks(\n session, self.track_id\n )\n\n def get_album(self, session: Session):\n self.album: Optional[AlbumsEndpointResponseJSON] = request_albums(\n session, self.metadata.album.id\n )\n\n def get_credits(self, session: Session):\n self.credits: Optional[TracksCreditsResponseJSON] = request_credits(\n session, self.track_id\n )\n\n def get_lyrics(self, session: Session):\n if self._has_lyrics is None:\n self.lyrics: Optional[TracksLyricsResponseJSON] = request_lyrics(\n session, self.track_id\n )\n if self.lyrics is None:\n self._has_lyrics = False\n else:\n self._has_lyrics = True\n else:\n return self.lyrics\n\n def get_stream(self, session: Session, audio_format: AudioFormat):\n \"\"\"Populates self.stream, self.manifest\"\"\"\n aq: Optional[str] = af_aq.get(audio_format)\n self.stream: Optional[TracksEndpointStreamResponseJSON] = request_stream(\n session, self.track_id, aq\n )\n\n def set_manifest(self):\n \"\"\"This method sets self.manifest and self.codec\"\"\"\n self.manifest: Manifest = manifester(self.stream)\n # https://dashif.org/codecs/audio/\n if self.manifest.codecs == \"flac\":\n self.codec = \"flac\"\n elif self.manifest.codecs == \"mqa\":\n self.codec = \"flac\"\n elif self.manifest.codecs == \"mha1\": # Sony 360 Reality Audio\n self.codec = \"mka\"\n elif self.manifest.codecs == \"mp4a.40.5\": # HE-AAC\n self.codec = \"m4a\"\n elif self.manifest.codecs == \"mp4a.40.29\": # HE-AAC v2\n self.codec = \"m4a\"\n elif self.manifest.codecs == \"mp4a.40.2\": # AAC-LC\n self.codec = \"m4a\"\n elif self.manifest.codecs == \"eac3\": # Enhanced AC-3\n self.codec = \"m4a\"\n elif self.manifest.codecs == \"mp4a.40.34\": # MP3\n self.codec = \"mp3\"\n\n def set_album_dir(self, out_dir: Path):\n \"\"\"This method sets self.album_dir, based on self.album and\n out_dir. In particular, self.album_dir is a subdirectory of out_dir\n based on the name of the album's artist\"\"\"\n artist_substring: str = self.album.artist.name.replace(\"..\", \"\")\n album_substring: str = (\n f\"{self.album.name} \" f\"[{self.album.id}] [{self.album.release_date.year}]\"\n )\n self.album_dir: Path = out_dir / artist_substring / album_substring\n self.album_dir.mkdir(parents=True, exist_ok=True)\n\n if self.album.number_of_volumes > 1:\n volume_substring: str = f\"Volume {self.metadata.volume_number}\"\n (self.album_dir / volume_substring).mkdir(parents=True, exist_ok=True)\n\n def set_filename(self, audio_format: AudioFormat):\n \"\"\"This method sets self.filename. It's based on self.metadata\n as well as audio_format. Additionally, if the available codecs in\n self.manifest don't match audio_format, warnings are logged\"\"\"\n _track_part: str = f\"{self.metadata.track_number:02d} - {self.metadata.name}\"\n if audio_format == AudioFormat.low:\n track_substring: str = f\"{_track_part} [L]\"\n elif audio_format == AudioFormat.high:\n track_substring: str = f\"{_track_part} [H]\"\n elif audio_format == AudioFormat.lossless:\n track_substring: str = f\"{_track_part} [CD]\"\n elif audio_format == AudioFormat.mqa:\n track_substring: str = f\"{_track_part} [Q]\"\n elif audio_format == AudioFormat.hi_res:\n track_substring: str = f\"{_track_part} [HiRes]\"\n elif audio_format == AudioFormat.dolby_atmos:\n track_substring: str = f\"{_track_part} [A]\"\n elif audio_format == AudioFormat.sony_360_reality_audio:\n track_substring: str = f\"{_track_part} [360]\"\n else:\n track_substring: str = _track_part\n\n # Check for MQA masquerading as HiRes here\n if audio_format == AudioFormat.hi_res:\n if self.manifest.codecs == \"mqa\":\n logger.warning(\n \"Even though HiRes audio format was requested, this track is only \"\n \"available in MQA format. TIDAL regards this as 'HiRes' even though \"\n \"it is probably only lossless; i.e. 16-bit 44.1 kHz quality. \"\n \"Downloading of track will continue, but it will be marked as MQA.\"\n )\n self.filename: Optional[str] = f\"{_track_part} [Q].{self.codec}\"\n elif (self.stream.bit_depth == 16) and (self.stream.sample_rate == 44100):\n logger.warning(\n \"Even though HiRes audio format was requested, and TIDAL responded to \"\n \"that request without error, this track is only available in lossless \"\n \"format; i.e. 16-bit 44.1 kHz quality. Downloading of track will \"\n \"continue, but it will be marked as Lossless ([CD]).\"\n )\n self.filename: Optional[str] = f\"{_track_part} [CD].{self.codec}\"\n else:\n self.filename: Optional[str] = f\"{track_substring}.{self.codec}\"\n else:\n self.filename: Optional[str] = f\"{track_substring}.{self.codec}\"\n\n # for use in playlist file ordering\n self.trackname: str = re.match(r\"(?:\\d{2,3} - )(.+?$)\", self.filename).groups()[\n 0\n ]\n\n def set_outfile(self):\n \"\"\"Uses self.album_dir and self.metadata and self.filename\n to craft the pathlib.Path object, self.outfile, that is a\n reference to where the track will be written on disk.\"\"\"\n if self.album.number_of_volumes > 1:\n self.outfile: Path = (\n self.album_dir / f\"Volume {self.metadata.volume_number}\" / self.filename\n )\n self.absolute_outfile = str(self.outfile.absolute())\n else:\n self.outfile: Path = self.album_dir / self.filename\n self.absolute_outfile = str(self.outfile.absolute())\n\n if (self.outfile.exists()) and (self.outfile.stat().st_size > 0):\n logger.info(\n f\"Track {self.absolute_outfile} already exists \"\n \"and therefore will not be overwritten\"\n )\n return\n else:\n return self.outfile\n\n def save_artist_image(self, session: Session):\n \"\"\"This method writes a JPEG file with the name of each of\n self.metadata.artists to self.album_dir\"\"\"\n for a in self.metadata.artists:\n track_artist_image: Path = (\n self.album_dir / f\"{a.name.replace('..', '')}.jpg\"\n )\n if not track_artist_image.exists():\n download_artist_image(session, a, self.album_dir)\n\n def save_artist_bio(self, session: Session):\n \"\"\"This method writes a JSON file with the name of each of\n self.metadata.artists to self.album_dir\"\"\"\n for a in self.metadata.artists:\n track_artist_bio_json: Path = self.album_dir / f\"{a.name}-bio.json\"\n if not track_artist_bio_json.exists():\n artist_bio: Optional[ArtistsBioResponseJSON] = request_artist_bio(\n session, a.id\n )\n if artist_bio is not None:\n logger.info(\n f\"Writing artist bio for artist {a.id} to \"\n f\"'{str(track_artist_bio_json.absolute())}\"\n )\n track_artist_bio_json.write_text(artist_bio.to_json())\n\n def save_album_cover(self, session: Session):\n \"\"\"This method saves cover.jpg to self.album_dir; the bytes for cover.jpg\n come from self.album.cover\"\"\"\n self.cover_path: Path = self.album_dir / \"cover.jpg\"\n if (not self.cover_path.exists()) or (not self.album_cover_saved):\n download_cover_image(\n session=session, cover_uuid=self.album.cover, output_dir=self.album_dir\n )\n else:\n self.album_cover_saved = True\n\n def set_urls(self, session: Session):\n \"\"\"This method sets self.urls based on self.manifest\"\"\"\n if isinstance(self.manifest, JSONDASHManifest):\n self.urls: List[str] = self.manifest.urls\n elif isinstance(self.manifest, XMLDASHManifest):\n self.urls: List[str] = self.manifest.build_urls(session=session)\n self.download_headers: Dict[str, str] = {\"Accept\": self.manifest.mime_type}\n if session.session_id is not None:\n self.download_headers[\"sessionId\"] = session.session_id\n self.download_params = {k: None for k in session.params}\n\n def download_url(self, session: Session, out_dir: Path) -> Optional[Path]:\n \"\"\"This method downloads self.urls[0], for use in situations when\n the manifest returned by TIDAL API contains one URL. It relies on\n byte range headers to incrementally get all content from a URL\"\"\"\n logger.info(f\"Writing track {self.track_id} to '{self.absolute_outfile}'\")\n\n with temporary_file() as ntf:\n # Implement HTTP range requests here to mimic official clients\n range_size: int = 1024 * 1024 # 1 MiB\n content_length: int = fetch_content_length(\n session=session, url=self.urls[0]\n )\n if content_length == 0:\n return\n\n range_headers: Iterable[str] = http_request_range_headers(\n content_length=content_length,\n range_size=range_size,\n return_tuple=False,\n )\n for rh in range_headers:\n with session.get(\n self.urls[0], params=self.download_params, headers={\"Range\": rh}\n ) as rr:\n if not rr.ok:\n logger.warning(f\"Could not download {self}\")\n return\n else:\n ntf.write(rr.content)\n else:\n ntf.seek(0)\n\n if self.codec == \"flac\":\n # Have to use FFMPEG to re-mux the audio bytes, otherwise\n # mutagen chokes on NoFlacHeaderError\n ffmpeg.input(ntf.name, hide_banner=None, y=None).output(\n self.absolute_outfile,\n acodec=\"copy\",\n loglevel=\"quiet\",\n ).run()\n elif self.codec == \"m4a\":\n shutil.copyfile(ntf.name, self.outfile)\n elif self.codec == \"mka\":\n shutil.copyfile(ntf.name, self.outfile)\n\n logger.info(\n f\"Track {self.track_id} written to '{str(self.outfile.absolute())}'\"\n )\n return self.outfile\n\n def download_urls(self, session: Session, out_dir: Path) -> Optional[Path]:\n \"\"\"This method writes the contents from self.urls to a temporary\n directory, then uses FFmpeg to re-mux the data to self.outfile\"\"\"\n logger.info(f\"Writing track {self.track_id} to '{self.absolute_outfile}'\")\n\n with temporary_file() as ntf:\n for u in self.urls:\n with session.get(\n url=u, headers=self.download_headers, params=self.download_params\n ) as resp:\n if not resp.ok:\n logger.warning(f\"Could not download {self}\")\n return\n else:\n ntf.write(resp.content)\n else:\n ntf.seek(0)\n\n if self.codec == \"flac\":\n # Have to use FFmpeg to re-mux the audio bytes, otherwise\n # mutagen chokes on NoFlacHeaderError\n ffmpeg.input(ntf.name, hide_banner=None, y=None).output(\n self.absolute_outfile, acodec=\"copy\", loglevel=\"quiet\"\n ).run()\n elif self.codec == \"m4a\":\n shutil.copyfile(ntf.name, self.outfile)\n elif self.codec == \"mka\":\n shutil.copyfile(ntf.name, self.outfile)\n\n logger.info(f\"Track {self.track_id} written to '{self.absolute_outfile}'\")\n return self.outfile\n\n def download(self, session: Session, out_dir: Path) -> Optional[Path]:\n \"\"\"This method GETs the data from self.urls and writes it\n to self.outfile.\"\"\"\n if len(self.urls) == 1:\n outfile: Optional[Path] = self.download_url(\n session=session, out_dir=out_dir\n )\n else:\n outfile: Optional[Path] = self.download_urls(\n session=session, out_dir=out_dir\n )\n\n return outfile\n\n def craft_tags(self):\n \"\"\"Using the TAG_MAPPING dictionary,\n write the correct values of various metadata tags to the file.\n E.g. for .flac files, the album's artist is 'ALBUMARTIST',\n but for .m4a files, the album's artist is 'aART'.\"\"\"\n tags = dict()\n if (self.codec == \"flac\") or (self.codec == \"mka\"):\n tag_map = {k: v[\"flac\"] for k, v in TAG_MAPPING.items()}\n elif self.codec == \"m4a\":\n tag_map = {k: v[\"m4a\"] for k, v in TAG_MAPPING.items()}\n\n tags[tag_map[\"album\"]] = self.album.title\n tags[tag_map[\"album_artist\"]] = \";\".join((a.name for a in self.album.artists))\n tags[tag_map[\"album_peak_amplitude\"]] = f\"{self.stream.album_peak_amplitude}\"\n tags[tag_map[\"album_replay_gain\"]] = f\"{self.stream.album_replay_gain}\"\n tags[tag_map[\"artist\"]] = \";\".join((a.name for a in self.metadata.artists))\n tags[tag_map[\"artists\"]] = [a.name for a in self.metadata.artists]\n tags[tag_map[\"barcode\"]] = self.album.upc\n tags[tag_map[\"comment\"]] = self.metadata.url\n tags[tag_map[\"copyright\"]] = self.metadata.copyright\n tags[tag_map[\"date\"]] = str(self.album.release_date)\n tags[tag_map[\"isrc\"]] = self.metadata.isrc\n tags[tag_map[\"title\"]] = self.metadata.name\n tags[tag_map[\"track_peak_amplitude\"]] = f\"{self.metadata.peak}\"\n tags[tag_map[\"track_replay_gain\"]] = f\"{self.metadata.replay_gain}\"\n # credits\n for tag in {\"composer\", \"engineer\", \"lyricist\", \"mixer\", \"producer\", \"remixer\"}:\n try:\n _credits_tag = \";\".join(getattr(self.credits, tag))\n except (TypeError, AttributeError): # NoneType problems\n continue\n else:\n tags[tag_map[tag]] = _credits_tag\n # lyrics\n try:\n _lyrics = self.lyrics.subtitles\n except (TypeError, AttributeError): # NoneType problems\n pass\n else:\n tags[tag_map[\"lyrics\"]] = _lyrics\n\n if self.codec == \"flac\":\n # track and disk\n tags[\"DISCTOTAL\"] = f\"{self.album.number_of_volumes}\"\n tags[\"DISC\"] = f\"{self.metadata.volume_number}\"\n tags[\"TRACKTOTAL\"] = f\"{self.album.number_of_tracks}\"\n tags[\"TRACKNUMBER\"] = f\"{self.metadata.track_number}\"\n # instrument-specific\n # piano\n try:\n piano_credits: List[str] = [\n f\"{pc} (piano)\" for pc in self.credits.piano\n ]\n except (TypeError, AttributeError): # NoneType problems\n pass\n else:\n tags[\"PERFORMER\"] = piano_credits\n\n elif self.codec == \"m4a\":\n # Have to convert to bytes the values of the tags starting with '----'\n for k, v in tags.copy().items():\n if k.startswith(\"----\"):\n if isinstance(v, str):\n tags[k]: bytes = v.encode(\"UTF-8\")\n elif isinstance(v, list):\n tags[k]: List[bytes] = [s.encode(\"UTF-8\") for s in v]\n\n tags[\"trkn\"] = [(self.metadata.track_number, self.album.number_of_tracks)]\n tags[\"disk\"] = [(self.metadata.volume_number, self.album.number_of_volumes)]\n\n self.tags: dict = {k: v for k, v in tags.items() if v is not None}\n\n def set_tags(self):\n \"\"\"Instantiate a mutagen.File instance, add self.tags to it, and\n save it to disk\"\"\"\n self.mutagen = mutagen.File(self.outfile)\n self.mutagen.clear()\n self.mutagen.update(**self.tags)\n # add album cover\n if self.codec == \"flac\":\n p = mutagen.flac.Picture()\n p.type = mutagen.id3.PictureType.COVER_FRONT\n p.desc = \"Album Cover\"\n p.width = p.height = 1280\n p.mime = \"image/jpeg\"\n p.data = self.cover_path.read_bytes()\n self.mutagen.add_picture(p)\n elif self.codec == \"m4a\":\n self.mutagen[\"covr\"] = [\n MP4Cover(self.cover_path.read_bytes(), imageformat=MP4Cover.FORMAT_JPEG)\n ]\n\n self.mutagen.save()\n # Make sure audio track comes first because of\n # less-sophisticated audio players that only\n # recognize the first stream\n if self.codec == \"flac\":\n with temporary_file(suffix=\".mka\") as tf:\n shutil.move(str(self.outfile.absolute()), tf.name)\n cmd: List[str] = shlex.split(\n f\"\"\"ffmpeg -hide_banner -loglevel quiet -y -i \"{tf.name}\"\n -map 0:a:0 -map 0:v:0 -c:a copy -c:v copy\n -metadata:s:v title='Album cover' -metadata:s:v comment='Cover (front)'\n -disposition:v attached_pic \"{self.absolute_outfile}\" \"\"\"\n )\n subprocess.run(cmd)\n elif self.codec == \"m4a\":\n with temporary_file(suffix=\".mka\") as tf:\n cmd: List[str] = shlex.split(\n f\"\"\"ffmpeg -hide_banner -loglevel quiet -y -i \"{self.absolute_outfile}\"\n -map 0:a:0 -map 0:v:0 -c:a copy -c:v copy \"{tf.name}\" \"\"\"\n )\n subprocess.run(cmd)\n shutil.copyfile(tf.name, self.absolute_outfile)\n\n def get(\n self,\n session: Session,\n audio_format: AudioFormat,\n out_dir: Path,\n metadata: Optional[TracksEndpointResponseJSON] = None,\n album: Optional[AlbumsEndpointResponseJSON] = None,\n ) -> Optional[str]:\n if metadata is None:\n self.get_metadata(session)\n else:\n self.metadata = metadata\n\n if self.metadata is None:\n self.outfile = None\n return\n\n if \"DOLBY_ATMOS\" in self.metadata.media_metadata.tags:\n if audio_format != AudioFormat.dolby_atmos:\n logger.warning(\n f\"Track {self.track_id} is only available in Dolby Atmos \"\n \"format. Downloading of track will not continue.\"\n )\n self.outfile = None\n return\n\n if audio_format == AudioFormat.dolby_atmos:\n if \"DOLBY_ATMOS\" not in self.metadata.media_metadata.tags:\n logger.warning(\n \"Dolby Atmos audio format was requested, but track \"\n f\"{self.track_id} is not available in Dolby Atmos \"\n \"format. Downloading of track will not continue.\"\n )\n self.outfile = None\n return\n elif audio_format == AudioFormat.sony_360_reality_audio:\n if \"SONY_360RA\" not in self.metadata.media_metadata.tags:\n logger.warning(\n \"Sony 360 Reality Audio audio format was requested, but track \"\n f\"{self.track_id} is not available in Sony 360 Reality Audio \"\n \"format. Downloading of track will not continue.\"\n )\n self.outfile = None\n return\n elif audio_format == AudioFormat.mqa:\n if \"MQA\" not in self.metadata.media_metadata.tags:\n logger.warning(\n \"MQA audio format was requested, but track \"\n f\"{self.track_id} is not available in MQA audio \"\n \"format. Downloading of track will not continue.\"\n )\n self.outfile = None\n return\n\n if album is None:\n self.get_album(session)\n else:\n self.album = album\n\n if self.album is None:\n self.outfile = None\n return\n\n self.get_credits(session)\n self.get_stream(session, audio_format)\n if self.stream is None:\n return\n self.set_manifest()\n self.set_album_dir(out_dir)\n self.set_filename(audio_format)\n outfile: Optional[Path] = self.set_outfile()\n if outfile is None:\n return\n\n try:\n self.get_lyrics(session)\n except Exception:\n pass\n\n self.save_album_cover(session)\n\n try:\n self.save_artist_image(session)\n except Exception:\n pass\n\n try:\n self.save_artist_bio(session)\n except Exception:\n pass\n\n self.set_urls(session)\n\n if self.download(session, out_dir) is None:\n return\n\n self.craft_tags()\n self.set_tags()\n\n return str(self.outfile.absolute())\n\n def dump(self, fp=sys.stdout):\n k: int = int(self.metadata.track_number)\n if self.outfile is None:\n v: Optional[str] = None\n elif not isinstance(self.outfile, Path):\n v: Optional[str] = None\n else:\n v: Optional[str] = str(self.outfile.absolute())\n json.dump({k: v}, fp)\n return None\n\n def dumps(self) -> str:\n k: int = int(self.metadata.track_number)\n if self.outfile is None:\n v: Optional[str] = None\n elif not isinstance(self.outfile, Path):\n v: Optional[str] = None\n else:\n v: Optional[str] = str(self.outfile.absolute())\n json.dumps({k: v})\n return None"},{"identifier":"Video","path":"tidal_wave/video.py","snippet":"class Video:\n video_id: int\n\n def __post_init__(self):\n self.tags: dict = {}\n self.codec: str = \"mp4\"\n\n def get_metadata(self, session: Session):\n \"\"\"Request from TIDAL API /videos endpoint\"\"\"\n self.metadata: Optional[VideosEndpointResponseJSON] = request_videos(\n session, self.video_id\n )\n\n def get_contributors(self, session: Session):\n \"\"\"Request from TIDAL API /videos/contributors endpoint\"\"\"\n self.contributors: Optional[\n VideosContributorsResponseJSON\n ] = request_video_contributors(session, self.video_id)\n\n def get_stream(self, session: Session, video_format=VideoFormat.high):\n \"\"\"Populates self.stream by requesting from TIDAL API\n /videos/playbackinfopostpaywall endpoint\"\"\"\n self.stream: Optional[VideosEndpointStreamResponseJSON] = request_video_stream(\n session, self.video_id, video_format.value\n )\n\n def get_m3u8(self, session: Session):\n \"\"\"This method sets self.m3u8, an m3u8.M3U8 object\n following the HTTP Live Streaming specification; parsed from\n self.stream. I.e., self.get_stream() needs to have been executed\n before calling this method. N.b. self.m3u8 almost certainly will\n be a multivariant playlist, meaning further processing of its\n contents will be necessary.\"\"\"\n self.m3u8: m3u8.Playlist = playlister(session=session, vesrj=self.stream)\n\n def set_urls(self):\n \"\"\"This method uses self.m3u8, an m3u8.M3U8 object that is variant:\n (https://developer.apple.com/documentation/http-live-streaming/creating-a-multivariant-playlist)\n It retrieves the highest-quality .m3u8 in its .playlists attribute,\n and sets self.urls as the list of strings from that m3u8.Playlist\"\"\"\n # for now, just get the highest-bandwidth playlist\n playlist: m3u8.Playlist = variant_streams(self.m3u8)\n self.M3U8 = m3u8.load(playlist.uri)\n if self.M3U8 is None or len(self.M3U8.files) == 0:\n raise TidalM3U8Exception(\n f\"HLS media segments are not available for video {self.video_id}\"\n )\n self.urls: List[str] = self.M3U8.files\n\n def set_artist_dir(self, out_dir: Path):\n \"\"\"Set self.artist_dir, which is the subdirectory of `out_dir`\n with name `self.metadata.artist.name`\"\"\"\n self.artist_dir: Path = out_dir / self.metadata.artist.name\n self.artist_dir.mkdir(parents=True, exist_ok=True)\n\n def set_filename(self, out_dir: Path):\n \"\"\"Set self.filename, which is constructed from self.metadata.name\n and self.stream.video_quality\"\"\"\n self.filename: str = (\n f\"{self.metadata.name} [{self.stream.video_quality}].{self.codec}\"\n )\n\n def set_outfile(self):\n \"\"\"Uses self.artist_dir and self.metadata and self.filename\n to craft the pathlib.Path object, self.outfile, that is a\n reference to where the track will be written on disk.\"\"\"\n self.outfile: Path = self.artist_dir / self.filename\n\n if (self.outfile.exists()) and (self.outfile.stat().st_size > 0):\n logger.info(\n f\"Video {str(self.outfile.absolute())} already exists \"\n \"and therefore will not be overwritten\"\n )\n return\n else:\n return self.outfile\n\n def download(self, session: Session, out_dir: Path) -> Optional[Path]:\n \"\"\"Requests the HLS video files that constitute self.video_id.\n Writes HLS bytes to a temporary file, then uses FFmpeg to write the\n video data to self.outfile\"\"\"\n if session.session_id is not None:\n download_headers: Dict[str, str] = {\"sessionId\": session.session_id}\n else:\n download_headers: dict = dict()\n download_params: Dict[str, None] = {k: None for k in session.params}\n # self.outfile should already have been set by self.set_outfile()\n logger.info(\n f\"Writing video {self.video_id} to '{str(self.outfile.absolute())}'\"\n )\n\n with temporary_file() as ntf:\n for u in self.urls:\n with session.get(\n url=u, headers=download_headers, params=download_params\n ) as download_response:\n if not download_response.ok:\n logger.warning(f\"Could not download {self}\")\n else:\n ntf.write(download_response.content)\n else:\n ntf.seek(0)\n\n # will always be .mp4 because HLS\n ffmpeg.input(ntf.name, hide_banner=None, y=None).output(\n str(self.outfile.absolute()),\n vcodec=\"copy\",\n acodec=\"copy\",\n loglevel=\"quiet\",\n ).run()\n\n logger.info(\n f\"Video {self.video_id} written to '{str(self.outfile.absolute())}'\"\n )\n return self.outfile\n\n def craft_tags(self):\n \"\"\"Using the TAG_MAPPING dictionary, write the correct values of\n various metadata tags to the file. Videos are .mp4\"\"\"\n tags = dict()\n tag_map = {k: v[\"m4a\"] for k, v in TAG_MAPPING.items()}\n\n tags[tag_map[\"artist\"]] = \";\".join((a.name for a in self.metadata.artists))\n tags[tag_map[\"artists\"]] = [a.name for a in self.metadata.artists]\n tags[tag_map[\"comment\"]] = f\"https://tidal.com/browse/video/{self.video_id}\"\n tags[tag_map[\"date\"]] = str(self.metadata.release_date.date())\n tags[tag_map[\"title\"]] = self.metadata.title\n\n for tag in {\"composer\", \"director\", \"lyricist\", \"producer\"}:\n try:\n _credits_tag = \";\".join(getattr(self.contributors, tag))\n except (TypeError, AttributeError): # NoneType problems\n continue\n else:\n tags[tag_map[tag]] = _credits_tag\n\n # Have to convert to bytes the values of the tags starting with '----'\n for k, v in tags.copy().items():\n if k.startswith(\"----\"):\n if isinstance(v, str):\n tags[k]: bytes = v.encode(\"UTF-8\")\n elif isinstance(v, list):\n tags[k]: List[bytes] = [s.encode(\"UTF-8\") for s in v]\n\n self.tags: dict = {k: v for k, v in tags.items() if v is not None}\n\n def set_tags(self):\n \"\"\"Instantiate a mutagen.File instance, add self.tags to it, and\n save it to disk\"\"\"\n self.mutagen = mutagen.File(self.outfile)\n self.mutagen.clear()\n self.mutagen.update(**self.tags)\n self.mutagen.save()\n\n def get(\n self,\n session: Session,\n out_dir: Path,\n metadata: Optional[\"VideosEndpointResponseJSON\"] = None,\n ) -> Optional[str]:\n \"\"\"The main method of this class. Executes a number of other methods\n in a row:\n - self.get_metadata()\n - self.get_contributors()\n - self.get_stream()\n - self.get_m3u8()\n - self.set_urls()\n - self.set_artist_dir()\n - self.set_filename()\n - self.set_outfile()\n - self.download()\n - self.craft_tags()\n - self.set_tags()\n \"\"\"\n if metadata is None:\n self.get_metadata(session)\n else:\n self.metadata = metadata\n\n if self.metadata is None:\n return None\n\n self.get_contributors(session)\n self.get_stream(session)\n if self.stream is None:\n return None\n self.get_m3u8(session)\n self.set_urls()\n self.set_artist_dir(out_dir)\n self.set_filename(out_dir)\n outfile: Optional[Path] = self.set_outfile()\n if outfile is None:\n return None\n\n if self.download(session, out_dir) is None:\n return None\n\n self.craft_tags()\n self.set_tags()\n return str(self.outfile.absolute())\n\n def dump(self, fp=sys.stdout):\n json.dump({self.metadata.title: str(self.outfile.absolute())}, fp)\n\n def dumps(self) -> str:\n return json.dumps({self.metadata.title: str(self.outfile.absolute())})"},{"identifier":"match_tidal_url","path":"tidal_wave/models.py","snippet":"def match_tidal_url(input_str: str) -> Optional[TidalResource]:\n \"\"\"Attempt to match the `input_str` to either the URL of a track or an\n album in the Tidal API service. Returns None if `input_str` matches\n neither, otherwise a subclass of TidalResource corresponding to the\n parsed input_str type\n \"\"\"\n resource_match: Optional[TidalResource] = None\n tidal_resources: Tuple[TidalResource] = (\n TidalTrack,\n TidalAlbum,\n TidalVideo,\n TidalPlaylist,\n TidalMix,\n TidalArtist,\n )\n for T in tidal_resources:\n try:\n resource_match = T(input_str)\n except ValueError as v:\n logger.debug(v)\n continue\n else:\n return resource_match"},{"identifier":"TidalAlbum","path":"tidal_wave/models.py","snippet":"class TidalAlbum(TidalResource):\n \"\"\"Class representing a TIDAL album. Its main purpose is the\n __post_init__ checking process\"\"\"\n\n url: str\n\n def __post_init__(self):\n self.pattern: str = (\n r\"http(?:s)?://(?:listen\\.)?tidal\\.com/(?:browse/)?album/(\\d{5,9})(?:.*?)?\"\n )\n _id = self.match_url()\n\n if _id is None:\n raise ValueError(f\"'{self.url}' is not a valid TIDAL album URL\")\n else:\n self.tidal_id = int(_id)\n logger.info(f\"TIDAL album ID parsed from input: {self.tidal_id}\")"},{"identifier":"TidalArtist","path":"tidal_wave/models.py","snippet":"class TidalArtist(TidalResource):\n \"\"\"Class representing a TIDAL artist. Its main purpose is the\n __post_init__ checking process\"\"\"\n\n url: str\n\n def __post_init__(self):\n self.pattern: str = (\n r\"http(?:s)?://(?:listen\\.)?tidal\\.com/(?:browse/)?artist/(\\d{7,9})(?:.*?)?\"\n )\n _id = self.match_url()\n\n if _id is None:\n raise ValueError(f\"'{self.url}' is not a valid TIDAL album URL\")\n else:\n self.tidal_id = int(_id)\n logger.info(f\"TIDAL album ID parsed from input: {self.tidal_id}\")"},{"identifier":"TidalMix","path":"tidal_wave/models.py","snippet":"class TidalMix(TidalResource):\n url: str\n\n def __post_init__(self):\n self.pattern: str = (\n r\"http(?:s)?://(?:listen\\.)?tidal\\.com/(?:browse/)?mix/(\\w{30})(?:.*?)?\"\n )\n _id = self.match_url()\n\n if _id is None:\n raise ValueError(f\"'{self.url}' is not a valid TIDAL mix URL\")\n else:\n self.tidal_id = _id\n logger.info(f\"TIDAL mix ID parsed from input: {self.tidal_id}\")"},{"identifier":"TidalPlaylist","path":"tidal_wave/models.py","snippet":"class TidalPlaylist(TidalResource):\n \"\"\"Class representing a TIDAL playlist. Its main purpose is the\n __post_init__ checking process\"\"\"\n\n url: str\n\n def __post_init__(self):\n self.pattern: str = (\n r\"http(?:s)?://(?:listen\\.)?tidal\\.com/(?:browse/)?playlist/\"\n r\"([0-9a-f]{8}\\-[0-9a-f]{4}\\-4[0-9a-f]{3}\\-[89ab][0-9a-f]{3}\\-[0-9a-f]{12})(?:.*?)?\"\n )\n\n _id = self.match_url()\n\n if _id is None:\n raise ValueError(f\"'{self.url}' is not a valid TIDAL playlist URL\")\n else:\n self.tidal_id = _id\n logger.info(f\"TIDAL playlist ID parsed from input: {self.tidal_id}\")"},{"identifier":"TidalTrack","path":"tidal_wave/models.py","snippet":"class TidalTrack(TidalResource):\n \"\"\"Class representing a TIDAL track. Its main purpose is the\n __post_init__ checking process\"\"\"\n\n url: str\n\n def __post_init__(self):\n self.pattern: str = r\"http(?:s)?://(?:listen\\.)?tidal\\.com/(?:browse/)?(?:album/\\d{5,9}/)?track/(\\d{5,9})(?:.*?)?\"\n _id = self.match_url()\n\n if _id is None:\n raise ValueError(f\"'{self.url}' is not a valid TIDAL track URL\")\n else:\n self.tidal_id = int(_id)\n logger.info(f\"TIDAL track ID parsed from input: {self.tidal_id}\")"},{"identifier":"TidalVideo","path":"tidal_wave/models.py","snippet":"class TidalVideo(TidalResource):\n \"\"\"Class representing a TIDAL video. Its main purpose is the\n __post_init__ checking process\"\"\"\n\n url: str\n\n def __post_init__(self):\n self.pattern: str = (\n r\"http(?:s)?://(?:listen\\.)?tidal\\.com/(?:browse/)?video/(\\d{7,9})(?:.*?)?\"\n )\n _id = self.match_url()\n\n if _id is None:\n raise ValueError(f\"'{self.url}' is not a valid TIDAL video URL\")\n else:\n self.tidal_id = int(_id)\n logger.info(f\"TIDAL video ID parsed from input: {self.tidal_id}\")"}],"string":"[\n {\n \"identifier\": \"login\",\n \"path\": \"tidal_wave/login.py\",\n \"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 Android-/Windows-/MacOS-\\n gleaned API token; the latter to be able to access HiRes fLaC audio.\\n Returns a tuple of a requests.Session object, if no error, and the\\n AudioFormat instance passed in; or (None, \\\"\\\") in the event of error.\\n \\\"\\\"\\\"\\n android_formats: Set[AudioFormat] = {\\n AudioFormat.sony_360_reality_audio,\\n AudioFormat.hi_res,\\n }\\n fire_tv_formats: Set[AudioFormat] = {\\n AudioFormat.dolby_atmos,\\n AudioFormat.mqa,\\n AudioFormat.lossless,\\n AudioFormat.high,\\n AudioFormat.low,\\n }\\n if audio_format in fire_tv_formats:\\n return (login_fire_tv(), audio_format)\\n elif audio_format in android_formats:\\n options: set = {\\\"android\\\", \\\"a\\\", \\\"windows\\\", \\\"w\\\"}\\n _input: str = \\\"\\\"\\n while _input not in options:\\n _input = typer.prompt(\\n \\\"For which of Android [a] or Windows [w] would you like to provide an API token?\\\"\\n ).lower()\\n else:\\n if _input in {\\\"android\\\", \\\"a\\\"}:\\n return (login_android(), audio_format)\\n elif _input in {\\\"windows\\\", \\\"w\\\"}:\\n return (login_windows(), audio_format)\\n else:\\n logger.critical(\\n \\\"Please provide one of the following: \\\"\\n f\\\"{', '.join(e.value for e in AudioFormat)}\\\"\\n )\\n return (None, \\\"\\\")\"\n },\n {\n \"identifier\": \"AudioFormat\",\n \"path\": \"tidal_wave/login.py\",\n \"snippet\": \"class AudioFormat(str, Enum):\\n sony_360_reality_audio = \\\"360\\\"\\n dolby_atmos = \\\"Atmos\\\"\\n hi_res = \\\"HiRes\\\"\\n mqa = \\\"MQA\\\"\\n lossless = \\\"Lossless\\\"\\n high = \\\"High\\\"\\n low = \\\"Low\\\"\"\n },\n {\n \"identifier\": \"LogLevel\",\n \"path\": \"tidal_wave/login.py\",\n \"snippet\": \"class LogLevel(str, Enum):\\n debug = \\\"DEBUG\\\" # 10\\n info = \\\"INFO\\\" # 20\\n warning = \\\"WARNING\\\" # 30\\n error = \\\"ERROR\\\" # 40\\n critical = \\\"CRITICAL\\\" # 50\"\n },\n {\n \"identifier\": \"Album\",\n \"path\": \"tidal_wave/album.py\",\n \"snippet\": \"class Album:\\n album_id: int\\n\\n def __post_init__(self):\\n self.album_dir: Optional[Path] = None\\n self.album_cover_saved: bool = False\\n\\n def get_items(self, session: Session):\\n \\\"\\\"\\\"This method populates self.tracks by requesting from\\n TIDAL albums/items endpoint.\\\"\\\"\\\"\\n album_items: AlbumsItemsResponseJSON = request_album_items(\\n session=session, identifier=self.album_id\\n )\\n _items = album_items.items if album_items is not None else ()\\n self.tracks = tuple(_item.item for _item in _items)\\n\\n def get_metadata(self, session: Session):\\n \\\"\\\"\\\"This method populates self.metadata by requesting from\\n TIDAL /albums endpoint\\\"\\\"\\\"\\n self.metadata: AlbumsEndpointResponseJSON = request_albums(\\n session=session, identifier=self.album_id\\n )\\n\\n def get_review(self, session: Session):\\n \\\"\\\"\\\"This method requests the review corresponding to self.album_id\\n in TIDAL. If it exists, it is written to disk as AlbumReview.json\\n in self.album_dir\\\"\\\"\\\"\\n self.album_review: Optional[AlbumsReviewResponseJSON] = request_album_review(\\n session=session, identifier=self.album_id\\n )\\n if self.album_review is not None:\\n (self.album_dir / \\\"AlbumReview.json\\\").write_text(\\n self.album_review.to_json()\\n )\\n\\n def set_dir(self, out_dir: Path):\\n \\\"\\\"\\\"This method populates self.album_dir as a sub-subdirectory of\\n out_dir: its parent directory is the name of the (main) artist of\\n the album\\\"\\\"\\\"\\n artist_substring: str = self.metadata.artist.name.replace(\\\"..\\\", \\\"\\\")\\n album_substring: str = (\\n f\\\"{self.metadata.name.replace('..', '')} \\\"\\n f\\\"[{self.metadata.id}] [{self.metadata.release_date.year}]\\\"\\n )\\n self.album_dir = out_dir / artist_substring / album_substring\\n self.album_dir.mkdir(parents=True, exist_ok=True)\\n\\n if self.metadata.number_of_volumes > 1:\\n for v in range(1, self.metadata.number_of_volumes + 1):\\n volume_substring: str = f\\\"Volume {v}\\\"\\n (out_dir / artist_substring / album_substring / volume_substring).mkdir(\\n parents=True, exist_ok=True\\n )\\n\\n def save_cover_image(self, session: Session, out_dir: Path):\\n \\\"\\\"\\\"This method writes cover.jpg in self.album_dir via the\\n utils.download_cover_image() function. If successful,\\n then self.album_cover_saved takes the value True\\\"\\\"\\\"\\n if self.album_dir is None:\\n self.set_dir(out_dir=out_dir)\\n self.cover_path: Path = self.album_dir / \\\"cover.jpg\\\"\\n if not self.cover_path.exists():\\n download_cover_image(\\n session=session,\\n cover_uuid=self.metadata.cover,\\n output_dir=self.album_dir,\\n )\\n else:\\n self.album_cover_saved = True\\n\\n def get_tracks(\\n self, session: Session, audio_format: AudioFormat, out_dir: Path\\n ) -> List[Optional[str]]:\\n \\\"\\\"\\\"This method uses self.tracks to call track.Track.get() for each\\n track in self.tracks. It uses the result of each of these calls to\\n populate self.track_files\\\"\\\"\\\"\\n track_files: List[str] = [None] * self.metadata.number_of_tracks\\n for i, t in enumerate(self.tracks): # type(t) is TracksEndpointResponseJSON\\n track: Track = Track(track_id=t.id)\\n\\n track_files_value: Optional[str] = track.get(\\n session=session,\\n audio_format=audio_format,\\n out_dir=out_dir,\\n metadata=t,\\n album=self.metadata,\\n )\\n track_files[i] = {track.metadata.track_number: track_files_value}\\n else:\\n self.track_files = track_files\\n\\n def dumps(self):\\n \\\"\\\"\\\"This method returns a JSON-like string of self.track_files\\\"\\\"\\\"\\n return json.dumps(self.track_files)\\n\\n def dump(self, fp=sys.stdout):\\n \\\"\\\"\\\"This method writes to (by default) STDOUT a\\n JSON-like string of self.track_files\\\"\\\"\\\"\\n json.dump(self.track_files, fp)\\n\\n def get(\\n self,\\n session: Session,\\n audio_format: AudioFormat,\\n out_dir: Path,\\n metadata: Optional[AlbumsEndpointResponseJSON] = None,\\n ):\\n \\\"\\\"\\\"This method is the driver method of the class. It calls the\\n other methods in order:\\n 1. get_metadata()\\n 2. get_items()\\n 3. save_cover_image()\\n 4. get_review()\\n 5. get_tracks()\\n \\\"\\\"\\\"\\n if metadata is None:\\n self.get_metadata(session)\\n else:\\n self.metadata = metadata\\n \\n if self.metadata is None:\\n self.track_files = {}\\n return\\n\\n self.get_items(session)\\n self.save_cover_image(session, out_dir)\\n self.get_review(session)\\n self.get_tracks(session, audio_format, out_dir)\"\n },\n {\n \"identifier\": \"Artist\",\n \"path\": \"tidal_wave/artist.py\",\n \"snippet\": \"class Artist:\\n artist_id: int\\n\\n def set_metadata(self, session: Session):\\n \\\"\\\"\\\"This function requests from TIDAL API endpoint /artists and\\n stores the results in self.metadata\\\"\\\"\\\"\\n self.metadata: Optional[ArtistsEndpointResponseJSON] = request_artists(\\n session, self.artist_id\\n )\\n\\n def save_artist_image(self, session: Session):\\n \\\"\\\"\\\"This method writes the bytes of self.metadata.picture to\\n the file cover.jpg in self.artist_dir\\\"\\\"\\\"\\n artist_image: Path = self.artist_dir / \\\"cover.jpg\\\"\\n if not artist_image.exists():\\n download_cover_image(\\n session, self.metadata.picture, self.artist_dir, dimension=750\\n )\\n\\n def set_albums(self, session: Session):\\n \\\"\\\"\\\"This method requests from TIDAL API endpoint /artists/albums and\\n stores the results in self.albums\\\"\\\"\\\"\\n self.albums: Optional[ArtistsAlbumsResponseJSON] = request_artists_albums(\\n session, self.artist_id\\n )\\n\\n def set_audio_works(self, session: Session):\\n \\\"\\\"\\\"This method requests from TIDAL API endpoint\\n /artists/albums?filter=EPSANDSINGLES and stores the results in self.albums\\\"\\\"\\\"\\n self.albums: Optional[ArtistsAlbumsResponseJSON] = request_artists_audio_works(\\n session, self.artist_id\\n )\\n\\n def set_videos(self, session: Session):\\n \\\"\\\"\\\"This method requests from TIDAL API endpoint /artists/videos and\\n stores the results in self.albums\\\"\\\"\\\"\\n self.videos: Optional[ArtistsVideosResponseJSON] = request_artists_videos(\\n session, self.artist_id\\n )\\n\\n def set_dir(self, out_dir: Path):\\n \\\"\\\"\\\"This method sets self.artist_dir and creates the directory on the file system\\n if it does not exist\\\"\\\"\\\"\\n self.name: str = self.metadata.name.replace(\\\"..\\\", \\\"\\\")\\n self.artist_dir = out_dir / self.name\\n self.artist_dir.mkdir(parents=True, exist_ok=True)\\n\\n def get_albums(\\n self,\\n session: Session,\\n audio_format: AudioFormat,\\n out_dir: Path,\\n include_eps_singles: bool = False,\\n ) -> List[Optional[str]]:\\n \\\"\\\"\\\"This method first fetches the total albums on TIDAL's service\\n corresponding to the artist with ID self.artist_id. Then, each of\\n the albums (and, optionally, EPs and singles) is requested and\\n written to subdirectories of out_dir\\\"\\\"\\\"\\n if include_eps_singles:\\n self.set_audio_works(session)\\n logger.info(\\n f\\\"Starting attempt to get {self.albums.total_number_of_items} \\\"\\n \\\"albums, EPs, and singles for artist with ID \\\"\\n f\\\"{self.metadata.id}, '{self.name}'\\\"\\n )\\n else:\\n self.set_albums(session)\\n logger.info(\\n f\\\"Starting attempt to get {self.albums.total_number_of_items} albums \\\"\\n f\\\"for artist with ID {self.metadata.id}, '{self.name}'\\\"\\n )\\n\\n for i, a in enumerate(self.albums.items):\\n album: Album = Album(album_id=a.id)\\n album.get(\\n session=session,\\n audio_format=audio_format,\\n out_dir=out_dir,\\n metadata=a,\\n )\\n\\n def get_videos(\\n self,\\n session: Session,\\n out_dir: Path,\\n ) -> List[Optional[str]]:\\n \\\"\\\"\\\"This method sets self.videos by calling self.set_videos()\\n then, for each video, instantiates a Video object and executes\\n video.get()\\\"\\\"\\\"\\n self.set_videos(session)\\n logger.info(\\n f\\\"Starting attempt to get {self.videos.total_number_of_items} videos \\\"\\n f\\\"for artist with ID {self.metadata.id}, '{self.name}'\\\"\\n )\\n for i, v in enumerate(self.videos.items):\\n video: Video = Video(video_id=v.id)\\n video.get(\\n session=session,\\n out_dir=out_dir,\\n metadata=v,\\n )\\n\\n def get(\\n self,\\n session: Session,\\n audio_format: AudioFormat,\\n out_dir: Path,\\n include_eps_singles: bool,\\n ):\\n \\\"\\\"\\\"This is the driver method of the class. It executes the other\\n methods in order:\\n 1. set_metadata\\n 2. set_dir\\n 3. save_artist_image\\n 4. get_videos\\n 5. get_albums\\n \\\"\\\"\\\"\\n self.set_metadata(session)\\n \\n if self.metadata is None:\\n return\\n \\n self.set_dir(out_dir)\\n self.save_artist_image(session)\\n self.get_videos(session, out_dir)\\n if include_eps_singles:\\n self.get_albums(session, audio_format, out_dir, include_eps_singles=True)\\n self.get_albums(session, audio_format, out_dir, include_eps_singles=False)\"\n },\n {\n \"identifier\": \"Mix\",\n \"path\": \"tidal_wave/mix.py\",\n \"snippet\": \"class Mix:\\n mix_id: str\\n\\n def __post_init__(self):\\n self.mix_dir: Optional[Path] = None\\n self.mix_cover_saved: bool = False\\n\\n def get_metadata(self, session: Session):\\n \\\"\\\"\\\"Request from TIDAL API /playlists endpoint\\\"\\\"\\\"\\n self.metadata: Optional[PlaylistsEndpointResponseJSON] = request_mixes(\\n session=session, mix_id=self.mix_id\\n )\\n \\n if self.metadata is None:\\n return\\n \\n self.name = (\\n self.metadata.title.replace(\\\"/\\\", \\\"_\\\")\\n .replace(\\\"|\\\", \\\"_\\\")\\n .replace(\\\":\\\", \\\" -\\\")\\n .replace('\\\"', \\\"\\\")\\n .replace(\\\"..\\\", \\\"\\\")\\n )\\n\\n def set_items(self, session: Session):\\n \\\"\\\"\\\"Uses data from TIDAL API /mixes/items endpoint to\\n populate self.items\\\"\\\"\\\"\\n mix_items: Optional[MixesItemsResponseJSON] = get_mix(\\n session=session, mix_id=self.mix_id\\n )\\n if mix_items is None:\\n self.items = tuple()\\n else:\\n self.items: Tuple[Optional[MixItem]] = tuple(mix_items.items)\\n\\n def set_dir(self, out_dir: Path):\\n \\\"\\\"\\\"Populates self.mix_dir based on self.name, self.mix_id\\\"\\\"\\\"\\n mix_substring: str = f\\\"{self.name} [{self.mix_id}]\\\"\\n self.mix_dir: Path = out_dir / \\\"Mixes\\\" / mix_substring\\n self.mix_dir.mkdir(parents=True, exist_ok=True)\\n\\n def save_cover_image(self, session: Session, out_dir: Path):\\n \\\"\\\"\\\"Requests self.metadata.image and attempts to write it to disk\\\"\\\"\\\"\\n if self.mix_dir is None:\\n self.set_dir(out_dir=out_dir)\\n self.cover_path: Path = self.mix_dir / \\\"cover.jpg\\\"\\n if not self.cover_path.exists():\\n with session.get(\\n url=self.metadata.image, params={k: None for k in session.params}\\n ) as r:\\n (self.mix_dir / \\\"cover.jpg\\\").write_bytes(r.content)\\n\\n self.mix_cover_saved = True\\n else:\\n self.mix_cover_saved = True\\n\\n def get_items(self, session: Session, audio_format: AudioFormat):\\n \\\"\\\"\\\"Using either Track.get() or Video.get(), attempt to request\\n the data for each track or video in self.items\\\"\\\"\\\"\\n if len(self.items) == 0:\\n return\\n tracks_videos: list = [None] * len(self.items)\\n for i, item in enumerate(self.items):\\n if item is None:\\n tracks_videos[i] = None\\n continue\\n elif isinstance(item, TracksEndpointResponseJSON):\\n track: Track = Track(track_id=item.id)\\n track.get(\\n session=session,\\n audio_format=audio_format,\\n out_dir=self.mix_dir,\\n metadata=item,\\n )\\n tracks_videos[i] = track\\n elif isinstance(item, VideosEndpointResponseJSON):\\n video: Video = Video(video_id=item.id)\\n video.get(\\n session=session,\\n out_dir=self.mix_dir,\\n metadata=item,\\n )\\n tracks_videos[i] = video\\n else:\\n tracks_videos[i] = None\\n continue\\n else:\\n self.tracks_videos: Tuple[\\n Tuple[int, Optional[Union[Track, Video]]]\\n ] = tuple(tracks_videos)\\n return tracks_videos\\n\\n def flatten_mix_dir(self):\\n \\\"\\\"\\\"When self.get_items() is called, the tracks and/or videos in\\n self.items are downloaded using their self-contained .get() logic;\\n this means that they will be downloaded to albums. This function\\n \\\"flattens\\\" self.mix_dir, meaning that it moves all downloaded\\n audio and video files to self.mix_dir, and removes the various\\n subdirectories created\\\"\\\"\\\"\\n files: List[Dict[int, Optional[str]]] = [None] * len(self.tracks_videos)\\n if len(self.tracks_videos) == 0:\\n return\\n subdirs: Set[Path] = set()\\n\\n for i, tv in enumerate(self.tracks_videos, 1):\\n if getattr(tv, \\\"outfile\\\") is None:\\n try:\\n getattr(tv, \\\"album_dir\\\")\\n except AttributeError:\\n pass\\n else:\\n subdirs.add(tv.album_dir)\\n subdirs.add(tv.album_dir.parent)\\n files[i - 1] = {i: None}\\n continue\\n\\n _path: Optional[Path] = Path(tv.outfile) if tv is not None else None\\n # if the item never got turned into a track or video\\n if _path is None:\\n files[i - 1] = {i: None}\\n continue\\n\\n # if the track or video didn't download\\n if _path.exists():\\n if _path.stat().st_size == 0:\\n files[i - 1] = {i: None}\\n continue\\n else:\\n files[i - 1] = {i: None}\\n continue\\n\\n # otherwise, move files and clean up\\n if isinstance(tv, Track):\\n new_path: Path = self.mix_dir / f\\\"{i:03d} - {tv.trackname}\\\"\\n new_path.write_bytes(_path.read_bytes())\\n _path.unlink()\\n files[i - 1] = {i: str(new_path.absolute())}\\n elif isinstance(tv, Video):\\n new_path: Path = self.mix_dir / f\\\"{i:03d} - {_path.name}\\\"\\n new_path.write_bytes(_path.read_bytes())\\n _path.unlink()\\n files[i - 1] = {i: str(new_path.absolute())}\\n else:\\n self.files: List[Dict[int, Optional[str]]] = files\\n\\n # Find all subdirectories written to\\n subdirs: Set[Path] = set()\\n for tv in self.tracks_videos:\\n if isinstance(tv, Track):\\n try:\\n getattr(tv, \\\"album_dir\\\")\\n except AttributeError:\\n pass\\n else:\\n subdirs.add(tv.album_dir)\\n subdirs.add(tv.album_dir.parent)\\n elif isinstance(tv, Video):\\n subdirs.add(tv.artist_dir)\\n\\n # Copy all artist images, artist bio JSON files out\\n # of subdirs\\n artist_images: Set[Path] = set()\\n for subdir in subdirs:\\n for p in subdir.glob(\\\"*.jpg\\\"):\\n if p.name == \\\"cover.jpg\\\":\\n continue\\n artist_images.add(p)\\n else:\\n for artist_image_path in artist_images:\\n if artist_image_path.exists():\\n shutil.copyfile(\\n artist_image_path.absolute(),\\n self.mix_dir / artist_image_path.name,\\n )\\n\\n artist_bios: Set[Path] = set()\\n for subdir in subdirs:\\n for p in subdir.glob(\\\"*bio.json\\\"):\\n artist_bios.add(p)\\n else:\\n for artist_bio_path in artist_bios:\\n if artist_bio_path.exists():\\n shutil.copyfile(\\n artist_bio_path.absolute(),\\n self.mix_dir / artist_bio_path.name,\\n )\\n\\n # Remove all subdirs\\n for subdir in subdirs:\\n if subdir.exists():\\n shutil.rmtree(subdir)\\n else:\\n return self.mix_dir\\n\\n def dumps(self):\\n return json.dumps(self.files)\\n\\n def dump(self, fp=sys.stdout):\\n json.dump(self.files, fp)\\n\\n def get(self, session: Session, audio_format: AudioFormat, out_dir: Path):\\n \\\"\\\"\\\"The main method of this class, executing a number of other methods\\n in a row:\\n - self.get_metadata()\\n - self.set_items()\\n - self.set_dir()\\n - self.save_cover_image()\\n - self.get_items()\\n - self.flatten_playlist_dir()\\n \\\"\\\"\\\"\\n self.get_metadata(session)\\n \\n if self.metadata is None:\\n self.files = {}\\n return\\n \\n self.set_items(session)\\n self.set_dir(out_dir)\\n self.save_cover_image(session, out_dir)\\n try:\\n self.save_description()\\n except Exception:\\n pass\\n\\n _get_items = self.get_items(session, audio_format)\\n if _get_items is None:\\n logger.critical(f\\\"Could not retrieve mix with ID '{self.mix_id}'\\\")\\n return\\n self.flatten_mix_dir()\\n logger.info(f\\\"Mix files written to '{self.mix_dir}'\\\")\"\n },\n {\n \"identifier\": \"Playlist\",\n \"path\": \"tidal_wave/playlist.py\",\n \"snippet\": \"class Playlist:\\n playlist_id: str # UUID4\\n\\n def __post_init__(self):\\n self.playlist_dir: Optional[Path] = None\\n self.playlist_cover_saved: bool = False\\n\\n def get_metadata(self, session: Session):\\n \\\"\\\"\\\"Request from TIDAL API /playlists endpoint\\\"\\\"\\\"\\n self.metadata: Optional[PlaylistsEndpointResponseJSON] = request_playlists(\\n session=session, identifier=self.playlist_id\\n )\\n \\n if self.metadata is None:\\n return\\n \\n self.name = (\\n self.metadata.title.replace(\\\"/\\\", \\\"_\\\")\\n .replace(\\\"|\\\", \\\"_\\\")\\n .replace(\\\":\\\", \\\" -\\\")\\n .replace('\\\"', \\\"\\\")\\n .replace(\\\"..\\\", \\\"\\\")\\n )\\n\\n def set_items(self, session: Session):\\n \\\"\\\"\\\"Uses data from TIDAL API /playlists/items endpoint to\\n populate self.items\\\"\\\"\\\"\\n playlist_items: Optional[PlaylistsItemsResponseJSON] = get_playlist(\\n session=session, playlist_id=self.playlist_id\\n )\\n if playlist_items is None:\\n self.items = tuple()\\n else:\\n self.items: Tuple[Optional[PlaylistItem]] = tuple(playlist_items.items)\\n\\n def set_dir(self, out_dir: Path):\\n \\\"\\\"\\\"Populates self.playlist_dir based on self.name, self.playlist_id\\\"\\\"\\\"\\n playlist_substring: str = f\\\"{self.name} [{self.playlist_id}]\\\"\\n self.playlist_dir: Path = out_dir / \\\"Playlists\\\" / playlist_substring\\n self.playlist_dir.mkdir(parents=True, exist_ok=True)\\n\\n def save_cover_image(self, session: Session, out_dir: Path):\\n \\\"\\\"\\\"Requests self.metadata.image and attempts to write it to disk\\\"\\\"\\\"\\n if self.playlist_dir is None:\\n self.set_dir(out_dir=out_dir)\\n self.cover_path: Path = self.playlist_dir / \\\"cover.jpg\\\"\\n if not self.cover_path.exists():\\n download_cover_image(\\n session=session,\\n cover_uuid=self.metadata.square_image,\\n output_dir=self.playlist_dir,\\n dimension=1080,\\n )\\n else:\\n self.playlist_cover_saved = True\\n\\n def save_description(self):\\n \\\"\\\"\\\"Requests self.metadata.description and attempts to write it to disk\\\"\\\"\\\"\\n description_path: Path = self.playlist_dir / \\\"PlaylistDescription.txt\\\"\\n if self.metadata.description is not None and len(self.metadata.description) > 0:\\n if not description_path.exists():\\n description_path.write_text(f\\\"{self.metadata.description}\\\\n\\\")\\n\\n def get_items(self, session: Session, audio_format: AudioFormat):\\n \\\"\\\"\\\"Using either Track.get() or Video.get(), attempt to request\\n the data for each track or video in self.items\\\"\\\"\\\"\\n if len(self.items) == 0:\\n return\\n tracks_videos: list = [None] * len(self.items)\\n for i, item in enumerate(self.items):\\n if item is None:\\n tracks_videos[i] = None\\n continue\\n elif isinstance(item, TracksEndpointResponseJSON):\\n track: Track = Track(track_id=item.id)\\n track.get(\\n session=session,\\n audio_format=audio_format,\\n out_dir=self.playlist_dir,\\n metadata=item,\\n )\\n tracks_videos[i] = track\\n elif isinstance(item, VideosEndpointResponseJSON):\\n video: Video = Video(video_id=item.id)\\n video.get(\\n session=session,\\n out_dir=self.playlist_dir,\\n metadata=item,\\n )\\n tracks_videos[i] = video\\n else:\\n tracks_videos[i] = None\\n continue\\n else:\\n self.tracks_videos: Tuple[\\n Tuple[int, Optional[Union[Track, Video]]]\\n ] = tuple(tracks_videos)\\n return tracks_videos\\n\\n def flatten_playlist_dir(self):\\n \\\"\\\"\\\"When self.get_items() is called, the tracks and/or videos in\\n self.items are downloaded using their self-contained .get() logic;\\n this means that they will be downloaded to albums. This function\\n \\\"flattens\\\" self.playlist_dir, meaning that it moves all downloaded\\n audio and video files to self.playlist_dir, and removes the various\\n subdirectories created\\\"\\\"\\\"\\n files: List[Dict[int, Optional[str]]] = [None] * len(self.tracks_videos)\\n if len(self.tracks_videos) == 0:\\n return\\n subdirs: Set[Path] = set()\\n\\n for i, tv in enumerate(self.tracks_videos, 1):\\n if getattr(tv, \\\"outfile\\\") is None:\\n try:\\n getattr(tv, \\\"album_dir\\\")\\n except AttributeError:\\n pass\\n else:\\n subdirs.add(tv.album_dir)\\n subdirs.add(tv.album_dir.parent)\\n files[i - 1] = {i: None}\\n continue\\n\\n _path: Optional[Path] = Path(tv.outfile) if tv is not None else None\\n # if the item never got turned into a track or video\\n if _path is None:\\n files[i - 1] = {i: None}\\n continue\\n\\n # if the track or video didn't download\\n if _path.exists():\\n if _path.stat().st_size == 0:\\n files[i - 1] = {i: None}\\n continue\\n else:\\n files[i - 1] = {i: None}\\n continue\\n\\n # otherwise, move files and clean up\\n if isinstance(tv, Track):\\n new_path: Path = self.playlist_dir / f\\\"{i:03d} - {tv.trackname}\\\"\\n new_path.write_bytes(_path.read_bytes())\\n _path.unlink()\\n files[i - 1] = {i: str(new_path.absolute())}\\n elif isinstance(tv, Video):\\n new_path: Path = self.playlist_dir / f\\\"{i:03d} - {_path.name}\\\"\\n new_path.write_bytes(_path.read_bytes())\\n _path.unlink()\\n files[i - 1] = {i: str(new_path.absolute())}\\n else:\\n self.files: List[Dict[int, Optional[str]]] = files\\n\\n # Find all subdirectories written to\\n subdirs: Set[Path] = set()\\n for tv in self.tracks_videos:\\n if isinstance(tv, Track):\\n try:\\n getattr(tv, \\\"album_dir\\\")\\n except AttributeError:\\n pass\\n else:\\n subdirs.add(tv.album_dir)\\n subdirs.add(tv.album_dir.parent)\\n elif isinstance(tv, Video):\\n subdirs.add(tv.artist_dir)\\n\\n # Copy all artist images, artist bio JSON files out\\n # of subdirs\\n artist_images: Set[Path] = set()\\n for subdir in subdirs:\\n for p in subdir.glob(\\\"*.jpg\\\"):\\n if p.name == \\\"cover.jpg\\\":\\n continue\\n artist_images.add(p)\\n else:\\n for artist_image_path in artist_images:\\n if artist_image_path.exists():\\n shutil.copyfile(\\n artist_image_path.absolute(),\\n self.playlist_dir / artist_image_path.name,\\n )\\n\\n artist_bios: Set[Path] = set()\\n for subdir in subdirs:\\n for p in subdir.glob(\\\"*bio.json\\\"):\\n artist_bios.add(p)\\n else:\\n for artist_bio_path in artist_bios:\\n if artist_bio_path.exists():\\n shutil.copyfile(\\n artist_bio_path.absolute(),\\n self.playlist_dir / artist_bio_path.name,\\n )\\n\\n # Remove all subdirs\\n for subdir in subdirs:\\n if subdir.exists():\\n shutil.rmtree(subdir)\\n else:\\n return self.playlist_dir\\n\\n def craft_m3u8_text(self):\\n \\\"\\\"\\\"This method creates a file called playlist.m3u8 in self.playlist_dir\\n that is a standard M3U. Needs to be called after self.flatten_playlist_dir\\n in order to be able to access self.files\\n N.b. the already-written file is temporarily copied to a .mp4 version in a\\n temporary directory because .m4a files cannot be read with mutagen.\\\"\\\"\\\"\\n m3u_text: str = f\\\"#EXTM3U\\\\n#EXTENC:UTF-8\\\\n#EXTIMG:{str(self.cover_path.absolute())}\\\\n#PLAYLIST:{self.name}\\\\n\\\"\\n\\n logger.info(\\n f\\\"Creating .m3u8 playlist file for Playlist with ID '{self.playlist_id}'\\\"\\n )\\n for d in self.files:\\n file: str = next(iter(d.values()))\\n if file is None:\\n continue\\n elif file.endswith(\\\".flac\\\"):\\n m = mutagen.File(file)\\n artist: str = m.get(\\\"artist\\\", [\\\"\\\"])[0]\\n title: str = m.get(\\\"title\\\", [\\\"\\\"])[0]\\n extinf: str = (\\n f\\\"#EXTINF:{math.ceil(m.info.length)},\\\"\\n f\\\"{artist} - {title}\\\\n{file}\\\\n\\\"\\n )\\n m3u_text += extinf\\n elif file.endswith(\\\".mka\\\"):\\n m = mutagen.File(file)\\n artist: str = m.get(\\\"ARTI\\\", [\\\"\\\"])[0]\\n title: str = m.get(\\\"TITL\\\", [\\\"\\\"])[0]\\n extinf: str = (\\n f\\\"#EXTINF:{math.ceil(m.info.length)},\\\"\\n f\\\"{artist} - {title}\\\\n{file}\\\\n\\\"\\n )\\n m3u_text += extinf\\n elif file.endswith(\\\".m4a\\\"):\\n # Mutagen cannot read .m4a files, so make a copy with all\\n # of the metadata tags as a .mp4 in a temporary directory\\n with temporary_file(suffix=\\\".mp4\\\") as tf:\\n ffmpeg.input(file, hide_banner=None, y=None).output(\\n tf.name,\\n acodec=\\\"copy\\\",\\n vcodec=\\\"copy\\\",\\n loglevel=\\\"quiet\\\",\\n ).run()\\n\\n m = mutagen.File(tf.name)\\n artist: str = m.get(\\\"\\\\xa9ART\\\", [\\\"\\\"])[0]\\n title: str = m.get(\\\"\\\\xa9nam\\\", [\\\"\\\"])[0]\\n extinf: str = (\\n f\\\"#EXTINF:{math.ceil(m.info.length)},\\\"\\n f\\\"{artist} - {title}\\\\n{file}\\\\n\\\"\\n )\\n m3u_text += extinf\\n else:\\n return m3u_text\\n\\n def dumps(self):\\n return json.dumps(self.files)\\n\\n def dump(self, fp=sys.stdout):\\n json.dump(self.files, fp)\\n\\n def get(self, session: Session, audio_format: AudioFormat, out_dir: Path):\\n \\\"\\\"\\\"The main method of this class, executing a number of other methods\\n in a row:\\n - self.get_metadata()\\n - self.set_items()\\n - self.set_dir()\\n - self.save_cover_image()\\n - self.save_description()\\n - self.get_items()\\n - self.flatten_playlist_dir()\\n \\\"\\\"\\\"\\n self.get_metadata(session)\\n \\n if self.metadata is None:\\n self.files = {}\\n return\\n \\n self.set_items(session)\\n self.set_dir(out_dir)\\n self.save_cover_image(session, out_dir)\\n try:\\n self.save_description()\\n except Exception:\\n pass\\n\\n _get_items = self.get_items(session, audio_format)\\n if _get_items is None:\\n logger.critical(f\\\"Could not retrieve playlist with ID '{self.playlist_id}'\\\")\\n return\\n\\n self.flatten_playlist_dir()\\n\\n try:\\n m3u8_text: str = self.craft_m3u8_text()\\n except Exception as e:\\n logger.warning(\\n \\\"Unable to create playlist.m3u8 file for \\\"\\n f\\\"playlist with ID '{self.playlist_id}'\\\"\\n )\\n logger.debug(e)\\n else:\\n with open(self.playlist_dir / \\\"playlist.m3u8\\\", \\\"w\\\") as f:\\n f.write(m3u8_text)\\n\\n logger.info(f\\\"Playlist files written to '{self.playlist_dir}'\\\")\"\n },\n {\n \"identifier\": \"Track\",\n \"path\": \"tidal_wave/track.py\",\n \"snippet\": \"class Track:\\n track_id: int\\n\\n def __post_init__(self):\\n self._has_lyrics: Optional[bool] = None\\n self.tags: dict = {}\\n self.album_cover_saved: bool = False\\n\\n def get_metadata(self, session: Session):\\n self.metadata: Optional[TracksEndpointResponseJSON] = request_tracks(\\n session, self.track_id\\n )\\n\\n def get_album(self, session: Session):\\n self.album: Optional[AlbumsEndpointResponseJSON] = request_albums(\\n session, self.metadata.album.id\\n )\\n\\n def get_credits(self, session: Session):\\n self.credits: Optional[TracksCreditsResponseJSON] = request_credits(\\n session, self.track_id\\n )\\n\\n def get_lyrics(self, session: Session):\\n if self._has_lyrics is None:\\n self.lyrics: Optional[TracksLyricsResponseJSON] = request_lyrics(\\n session, self.track_id\\n )\\n if self.lyrics is None:\\n self._has_lyrics = False\\n else:\\n self._has_lyrics = True\\n else:\\n return self.lyrics\\n\\n def get_stream(self, session: Session, audio_format: AudioFormat):\\n \\\"\\\"\\\"Populates self.stream, self.manifest\\\"\\\"\\\"\\n aq: Optional[str] = af_aq.get(audio_format)\\n self.stream: Optional[TracksEndpointStreamResponseJSON] = request_stream(\\n session, self.track_id, aq\\n )\\n\\n def set_manifest(self):\\n \\\"\\\"\\\"This method sets self.manifest and self.codec\\\"\\\"\\\"\\n self.manifest: Manifest = manifester(self.stream)\\n # https://dashif.org/codecs/audio/\\n if self.manifest.codecs == \\\"flac\\\":\\n self.codec = \\\"flac\\\"\\n elif self.manifest.codecs == \\\"mqa\\\":\\n self.codec = \\\"flac\\\"\\n elif self.manifest.codecs == \\\"mha1\\\": # Sony 360 Reality Audio\\n self.codec = \\\"mka\\\"\\n elif self.manifest.codecs == \\\"mp4a.40.5\\\": # HE-AAC\\n self.codec = \\\"m4a\\\"\\n elif self.manifest.codecs == \\\"mp4a.40.29\\\": # HE-AAC v2\\n self.codec = \\\"m4a\\\"\\n elif self.manifest.codecs == \\\"mp4a.40.2\\\": # AAC-LC\\n self.codec = \\\"m4a\\\"\\n elif self.manifest.codecs == \\\"eac3\\\": # Enhanced AC-3\\n self.codec = \\\"m4a\\\"\\n elif self.manifest.codecs == \\\"mp4a.40.34\\\": # MP3\\n self.codec = \\\"mp3\\\"\\n\\n def set_album_dir(self, out_dir: Path):\\n \\\"\\\"\\\"This method sets self.album_dir, based on self.album and\\n out_dir. In particular, self.album_dir is a subdirectory of out_dir\\n based on the name of the album's artist\\\"\\\"\\\"\\n artist_substring: str = self.album.artist.name.replace(\\\"..\\\", \\\"\\\")\\n album_substring: str = (\\n f\\\"{self.album.name} \\\" f\\\"[{self.album.id}] [{self.album.release_date.year}]\\\"\\n )\\n self.album_dir: Path = out_dir / artist_substring / album_substring\\n self.album_dir.mkdir(parents=True, exist_ok=True)\\n\\n if self.album.number_of_volumes > 1:\\n volume_substring: str = f\\\"Volume {self.metadata.volume_number}\\\"\\n (self.album_dir / volume_substring).mkdir(parents=True, exist_ok=True)\\n\\n def set_filename(self, audio_format: AudioFormat):\\n \\\"\\\"\\\"This method sets self.filename. It's based on self.metadata\\n as well as audio_format. Additionally, if the available codecs in\\n self.manifest don't match audio_format, warnings are logged\\\"\\\"\\\"\\n _track_part: str = f\\\"{self.metadata.track_number:02d} - {self.metadata.name}\\\"\\n if audio_format == AudioFormat.low:\\n track_substring: str = f\\\"{_track_part} [L]\\\"\\n elif audio_format == AudioFormat.high:\\n track_substring: str = f\\\"{_track_part} [H]\\\"\\n elif audio_format == AudioFormat.lossless:\\n track_substring: str = f\\\"{_track_part} [CD]\\\"\\n elif audio_format == AudioFormat.mqa:\\n track_substring: str = f\\\"{_track_part} [Q]\\\"\\n elif audio_format == AudioFormat.hi_res:\\n track_substring: str = f\\\"{_track_part} [HiRes]\\\"\\n elif audio_format == AudioFormat.dolby_atmos:\\n track_substring: str = f\\\"{_track_part} [A]\\\"\\n elif audio_format == AudioFormat.sony_360_reality_audio:\\n track_substring: str = f\\\"{_track_part} [360]\\\"\\n else:\\n track_substring: str = _track_part\\n\\n # Check for MQA masquerading as HiRes here\\n if audio_format == AudioFormat.hi_res:\\n if self.manifest.codecs == \\\"mqa\\\":\\n logger.warning(\\n \\\"Even though HiRes audio format was requested, this track is only \\\"\\n \\\"available in MQA format. TIDAL regards this as 'HiRes' even though \\\"\\n \\\"it is probably only lossless; i.e. 16-bit 44.1 kHz quality. \\\"\\n \\\"Downloading of track will continue, but it will be marked as MQA.\\\"\\n )\\n self.filename: Optional[str] = f\\\"{_track_part} [Q].{self.codec}\\\"\\n elif (self.stream.bit_depth == 16) and (self.stream.sample_rate == 44100):\\n logger.warning(\\n \\\"Even though HiRes audio format was requested, and TIDAL responded to \\\"\\n \\\"that request without error, this track is only available in lossless \\\"\\n \\\"format; i.e. 16-bit 44.1 kHz quality. Downloading of track will \\\"\\n \\\"continue, but it will be marked as Lossless ([CD]).\\\"\\n )\\n self.filename: Optional[str] = f\\\"{_track_part} [CD].{self.codec}\\\"\\n else:\\n self.filename: Optional[str] = f\\\"{track_substring}.{self.codec}\\\"\\n else:\\n self.filename: Optional[str] = f\\\"{track_substring}.{self.codec}\\\"\\n\\n # for use in playlist file ordering\\n self.trackname: str = re.match(r\\\"(?:\\\\d{2,3} - )(.+?$)\\\", self.filename).groups()[\\n 0\\n ]\\n\\n def set_outfile(self):\\n \\\"\\\"\\\"Uses self.album_dir and self.metadata and self.filename\\n to craft the pathlib.Path object, self.outfile, that is a\\n reference to where the track will be written on disk.\\\"\\\"\\\"\\n if self.album.number_of_volumes > 1:\\n self.outfile: Path = (\\n self.album_dir / f\\\"Volume {self.metadata.volume_number}\\\" / self.filename\\n )\\n self.absolute_outfile = str(self.outfile.absolute())\\n else:\\n self.outfile: Path = self.album_dir / self.filename\\n self.absolute_outfile = str(self.outfile.absolute())\\n\\n if (self.outfile.exists()) and (self.outfile.stat().st_size > 0):\\n logger.info(\\n f\\\"Track {self.absolute_outfile} already exists \\\"\\n \\\"and therefore will not be overwritten\\\"\\n )\\n return\\n else:\\n return self.outfile\\n\\n def save_artist_image(self, session: Session):\\n \\\"\\\"\\\"This method writes a JPEG file with the name of each of\\n self.metadata.artists to self.album_dir\\\"\\\"\\\"\\n for a in self.metadata.artists:\\n track_artist_image: Path = (\\n self.album_dir / f\\\"{a.name.replace('..', '')}.jpg\\\"\\n )\\n if not track_artist_image.exists():\\n download_artist_image(session, a, self.album_dir)\\n\\n def save_artist_bio(self, session: Session):\\n \\\"\\\"\\\"This method writes a JSON file with the name of each of\\n self.metadata.artists to self.album_dir\\\"\\\"\\\"\\n for a in self.metadata.artists:\\n track_artist_bio_json: Path = self.album_dir / f\\\"{a.name}-bio.json\\\"\\n if not track_artist_bio_json.exists():\\n artist_bio: Optional[ArtistsBioResponseJSON] = request_artist_bio(\\n session, a.id\\n )\\n if artist_bio is not None:\\n logger.info(\\n f\\\"Writing artist bio for artist {a.id} to \\\"\\n f\\\"'{str(track_artist_bio_json.absolute())}\\\"\\n )\\n track_artist_bio_json.write_text(artist_bio.to_json())\\n\\n def save_album_cover(self, session: Session):\\n \\\"\\\"\\\"This method saves cover.jpg to self.album_dir; the bytes for cover.jpg\\n come from self.album.cover\\\"\\\"\\\"\\n self.cover_path: Path = self.album_dir / \\\"cover.jpg\\\"\\n if (not self.cover_path.exists()) or (not self.album_cover_saved):\\n download_cover_image(\\n session=session, cover_uuid=self.album.cover, output_dir=self.album_dir\\n )\\n else:\\n self.album_cover_saved = True\\n\\n def set_urls(self, session: Session):\\n \\\"\\\"\\\"This method sets self.urls based on self.manifest\\\"\\\"\\\"\\n if isinstance(self.manifest, JSONDASHManifest):\\n self.urls: List[str] = self.manifest.urls\\n elif isinstance(self.manifest, XMLDASHManifest):\\n self.urls: List[str] = self.manifest.build_urls(session=session)\\n self.download_headers: Dict[str, str] = {\\\"Accept\\\": self.manifest.mime_type}\\n if session.session_id is not None:\\n self.download_headers[\\\"sessionId\\\"] = session.session_id\\n self.download_params = {k: None for k in session.params}\\n\\n def download_url(self, session: Session, out_dir: Path) -> Optional[Path]:\\n \\\"\\\"\\\"This method downloads self.urls[0], for use in situations when\\n the manifest returned by TIDAL API contains one URL. It relies on\\n byte range headers to incrementally get all content from a URL\\\"\\\"\\\"\\n logger.info(f\\\"Writing track {self.track_id} to '{self.absolute_outfile}'\\\")\\n\\n with temporary_file() as ntf:\\n # Implement HTTP range requests here to mimic official clients\\n range_size: int = 1024 * 1024 # 1 MiB\\n content_length: int = fetch_content_length(\\n session=session, url=self.urls[0]\\n )\\n if content_length == 0:\\n return\\n\\n range_headers: Iterable[str] = http_request_range_headers(\\n content_length=content_length,\\n range_size=range_size,\\n return_tuple=False,\\n )\\n for rh in range_headers:\\n with session.get(\\n self.urls[0], params=self.download_params, headers={\\\"Range\\\": rh}\\n ) as rr:\\n if not rr.ok:\\n logger.warning(f\\\"Could not download {self}\\\")\\n return\\n else:\\n ntf.write(rr.content)\\n else:\\n ntf.seek(0)\\n\\n if self.codec == \\\"flac\\\":\\n # Have to use FFMPEG to re-mux the audio bytes, otherwise\\n # mutagen chokes on NoFlacHeaderError\\n ffmpeg.input(ntf.name, hide_banner=None, y=None).output(\\n self.absolute_outfile,\\n acodec=\\\"copy\\\",\\n loglevel=\\\"quiet\\\",\\n ).run()\\n elif self.codec == \\\"m4a\\\":\\n shutil.copyfile(ntf.name, self.outfile)\\n elif self.codec == \\\"mka\\\":\\n shutil.copyfile(ntf.name, self.outfile)\\n\\n logger.info(\\n f\\\"Track {self.track_id} written to '{str(self.outfile.absolute())}'\\\"\\n )\\n return self.outfile\\n\\n def download_urls(self, session: Session, out_dir: Path) -> Optional[Path]:\\n \\\"\\\"\\\"This method writes the contents from self.urls to a temporary\\n directory, then uses FFmpeg to re-mux the data to self.outfile\\\"\\\"\\\"\\n logger.info(f\\\"Writing track {self.track_id} to '{self.absolute_outfile}'\\\")\\n\\n with temporary_file() as ntf:\\n for u in self.urls:\\n with session.get(\\n url=u, headers=self.download_headers, params=self.download_params\\n ) as resp:\\n if not resp.ok:\\n logger.warning(f\\\"Could not download {self}\\\")\\n return\\n else:\\n ntf.write(resp.content)\\n else:\\n ntf.seek(0)\\n\\n if self.codec == \\\"flac\\\":\\n # Have to use FFmpeg to re-mux the audio bytes, otherwise\\n # mutagen chokes on NoFlacHeaderError\\n ffmpeg.input(ntf.name, hide_banner=None, y=None).output(\\n self.absolute_outfile, acodec=\\\"copy\\\", loglevel=\\\"quiet\\\"\\n ).run()\\n elif self.codec == \\\"m4a\\\":\\n shutil.copyfile(ntf.name, self.outfile)\\n elif self.codec == \\\"mka\\\":\\n shutil.copyfile(ntf.name, self.outfile)\\n\\n logger.info(f\\\"Track {self.track_id} written to '{self.absolute_outfile}'\\\")\\n return self.outfile\\n\\n def download(self, session: Session, out_dir: Path) -> Optional[Path]:\\n \\\"\\\"\\\"This method GETs the data from self.urls and writes it\\n to self.outfile.\\\"\\\"\\\"\\n if len(self.urls) == 1:\\n outfile: Optional[Path] = self.download_url(\\n session=session, out_dir=out_dir\\n )\\n else:\\n outfile: Optional[Path] = self.download_urls(\\n session=session, out_dir=out_dir\\n )\\n\\n return outfile\\n\\n def craft_tags(self):\\n \\\"\\\"\\\"Using the TAG_MAPPING dictionary,\\n write the correct values of various metadata tags to the file.\\n E.g. for .flac files, the album's artist is 'ALBUMARTIST',\\n but for .m4a files, the album's artist is 'aART'.\\\"\\\"\\\"\\n tags = dict()\\n if (self.codec == \\\"flac\\\") or (self.codec == \\\"mka\\\"):\\n tag_map = {k: v[\\\"flac\\\"] for k, v in TAG_MAPPING.items()}\\n elif self.codec == \\\"m4a\\\":\\n tag_map = {k: v[\\\"m4a\\\"] for k, v in TAG_MAPPING.items()}\\n\\n tags[tag_map[\\\"album\\\"]] = self.album.title\\n tags[tag_map[\\\"album_artist\\\"]] = \\\";\\\".join((a.name for a in self.album.artists))\\n tags[tag_map[\\\"album_peak_amplitude\\\"]] = f\\\"{self.stream.album_peak_amplitude}\\\"\\n tags[tag_map[\\\"album_replay_gain\\\"]] = f\\\"{self.stream.album_replay_gain}\\\"\\n tags[tag_map[\\\"artist\\\"]] = \\\";\\\".join((a.name for a in self.metadata.artists))\\n tags[tag_map[\\\"artists\\\"]] = [a.name for a in self.metadata.artists]\\n tags[tag_map[\\\"barcode\\\"]] = self.album.upc\\n tags[tag_map[\\\"comment\\\"]] = self.metadata.url\\n tags[tag_map[\\\"copyright\\\"]] = self.metadata.copyright\\n tags[tag_map[\\\"date\\\"]] = str(self.album.release_date)\\n tags[tag_map[\\\"isrc\\\"]] = self.metadata.isrc\\n tags[tag_map[\\\"title\\\"]] = self.metadata.name\\n tags[tag_map[\\\"track_peak_amplitude\\\"]] = f\\\"{self.metadata.peak}\\\"\\n tags[tag_map[\\\"track_replay_gain\\\"]] = f\\\"{self.metadata.replay_gain}\\\"\\n # credits\\n for tag in {\\\"composer\\\", \\\"engineer\\\", \\\"lyricist\\\", \\\"mixer\\\", \\\"producer\\\", \\\"remixer\\\"}:\\n try:\\n _credits_tag = \\\";\\\".join(getattr(self.credits, tag))\\n except (TypeError, AttributeError): # NoneType problems\\n continue\\n else:\\n tags[tag_map[tag]] = _credits_tag\\n # lyrics\\n try:\\n _lyrics = self.lyrics.subtitles\\n except (TypeError, AttributeError): # NoneType problems\\n pass\\n else:\\n tags[tag_map[\\\"lyrics\\\"]] = _lyrics\\n\\n if self.codec == \\\"flac\\\":\\n # track and disk\\n tags[\\\"DISCTOTAL\\\"] = f\\\"{self.album.number_of_volumes}\\\"\\n tags[\\\"DISC\\\"] = f\\\"{self.metadata.volume_number}\\\"\\n tags[\\\"TRACKTOTAL\\\"] = f\\\"{self.album.number_of_tracks}\\\"\\n tags[\\\"TRACKNUMBER\\\"] = f\\\"{self.metadata.track_number}\\\"\\n # instrument-specific\\n # piano\\n try:\\n piano_credits: List[str] = [\\n f\\\"{pc} (piano)\\\" for pc in self.credits.piano\\n ]\\n except (TypeError, AttributeError): # NoneType problems\\n pass\\n else:\\n tags[\\\"PERFORMER\\\"] = piano_credits\\n\\n elif self.codec == \\\"m4a\\\":\\n # Have to convert to bytes the values of the tags starting with '----'\\n for k, v in tags.copy().items():\\n if k.startswith(\\\"----\\\"):\\n if isinstance(v, str):\\n tags[k]: bytes = v.encode(\\\"UTF-8\\\")\\n elif isinstance(v, list):\\n tags[k]: List[bytes] = [s.encode(\\\"UTF-8\\\") for s in v]\\n\\n tags[\\\"trkn\\\"] = [(self.metadata.track_number, self.album.number_of_tracks)]\\n tags[\\\"disk\\\"] = [(self.metadata.volume_number, self.album.number_of_volumes)]\\n\\n self.tags: dict = {k: v for k, v in tags.items() if v is not None}\\n\\n def set_tags(self):\\n \\\"\\\"\\\"Instantiate a mutagen.File instance, add self.tags to it, and\\n save it to disk\\\"\\\"\\\"\\n self.mutagen = mutagen.File(self.outfile)\\n self.mutagen.clear()\\n self.mutagen.update(**self.tags)\\n # add album cover\\n if self.codec == \\\"flac\\\":\\n p = mutagen.flac.Picture()\\n p.type = mutagen.id3.PictureType.COVER_FRONT\\n p.desc = \\\"Album Cover\\\"\\n p.width = p.height = 1280\\n p.mime = \\\"image/jpeg\\\"\\n p.data = self.cover_path.read_bytes()\\n self.mutagen.add_picture(p)\\n elif self.codec == \\\"m4a\\\":\\n self.mutagen[\\\"covr\\\"] = [\\n MP4Cover(self.cover_path.read_bytes(), imageformat=MP4Cover.FORMAT_JPEG)\\n ]\\n\\n self.mutagen.save()\\n # Make sure audio track comes first because of\\n # less-sophisticated audio players that only\\n # recognize the first stream\\n if self.codec == \\\"flac\\\":\\n with temporary_file(suffix=\\\".mka\\\") as tf:\\n shutil.move(str(self.outfile.absolute()), tf.name)\\n cmd: List[str] = shlex.split(\\n f\\\"\\\"\\\"ffmpeg -hide_banner -loglevel quiet -y -i \\\"{tf.name}\\\"\\n -map 0:a:0 -map 0:v:0 -c:a copy -c:v copy\\n -metadata:s:v title='Album cover' -metadata:s:v comment='Cover (front)'\\n -disposition:v attached_pic \\\"{self.absolute_outfile}\\\" \\\"\\\"\\\"\\n )\\n subprocess.run(cmd)\\n elif self.codec == \\\"m4a\\\":\\n with temporary_file(suffix=\\\".mka\\\") as tf:\\n cmd: List[str] = shlex.split(\\n f\\\"\\\"\\\"ffmpeg -hide_banner -loglevel quiet -y -i \\\"{self.absolute_outfile}\\\"\\n -map 0:a:0 -map 0:v:0 -c:a copy -c:v copy \\\"{tf.name}\\\" \\\"\\\"\\\"\\n )\\n subprocess.run(cmd)\\n shutil.copyfile(tf.name, self.absolute_outfile)\\n\\n def get(\\n self,\\n session: Session,\\n audio_format: AudioFormat,\\n out_dir: Path,\\n metadata: Optional[TracksEndpointResponseJSON] = None,\\n album: Optional[AlbumsEndpointResponseJSON] = None,\\n ) -> Optional[str]:\\n if metadata is None:\\n self.get_metadata(session)\\n else:\\n self.metadata = metadata\\n\\n if self.metadata is None:\\n self.outfile = None\\n return\\n\\n if \\\"DOLBY_ATMOS\\\" in self.metadata.media_metadata.tags:\\n if audio_format != AudioFormat.dolby_atmos:\\n logger.warning(\\n f\\\"Track {self.track_id} is only available in Dolby Atmos \\\"\\n \\\"format. Downloading of track will not continue.\\\"\\n )\\n self.outfile = None\\n return\\n\\n if audio_format == AudioFormat.dolby_atmos:\\n if \\\"DOLBY_ATMOS\\\" not in self.metadata.media_metadata.tags:\\n logger.warning(\\n \\\"Dolby Atmos audio format was requested, but track \\\"\\n f\\\"{self.track_id} is not available in Dolby Atmos \\\"\\n \\\"format. Downloading of track will not continue.\\\"\\n )\\n self.outfile = None\\n return\\n elif audio_format == AudioFormat.sony_360_reality_audio:\\n if \\\"SONY_360RA\\\" not in self.metadata.media_metadata.tags:\\n logger.warning(\\n \\\"Sony 360 Reality Audio audio format was requested, but track \\\"\\n f\\\"{self.track_id} is not available in Sony 360 Reality Audio \\\"\\n \\\"format. Downloading of track will not continue.\\\"\\n )\\n self.outfile = None\\n return\\n elif audio_format == AudioFormat.mqa:\\n if \\\"MQA\\\" not in self.metadata.media_metadata.tags:\\n logger.warning(\\n \\\"MQA audio format was requested, but track \\\"\\n f\\\"{self.track_id} is not available in MQA audio \\\"\\n \\\"format. Downloading of track will not continue.\\\"\\n )\\n self.outfile = None\\n return\\n\\n if album is None:\\n self.get_album(session)\\n else:\\n self.album = album\\n\\n if self.album is None:\\n self.outfile = None\\n return\\n\\n self.get_credits(session)\\n self.get_stream(session, audio_format)\\n if self.stream is None:\\n return\\n self.set_manifest()\\n self.set_album_dir(out_dir)\\n self.set_filename(audio_format)\\n outfile: Optional[Path] = self.set_outfile()\\n if outfile is None:\\n return\\n\\n try:\\n self.get_lyrics(session)\\n except Exception:\\n pass\\n\\n self.save_album_cover(session)\\n\\n try:\\n self.save_artist_image(session)\\n except Exception:\\n pass\\n\\n try:\\n self.save_artist_bio(session)\\n except Exception:\\n pass\\n\\n self.set_urls(session)\\n\\n if self.download(session, out_dir) is None:\\n return\\n\\n self.craft_tags()\\n self.set_tags()\\n\\n return str(self.outfile.absolute())\\n\\n def dump(self, fp=sys.stdout):\\n k: int = int(self.metadata.track_number)\\n if self.outfile is None:\\n v: Optional[str] = None\\n elif not isinstance(self.outfile, Path):\\n v: Optional[str] = None\\n else:\\n v: Optional[str] = str(self.outfile.absolute())\\n json.dump({k: v}, fp)\\n return None\\n\\n def dumps(self) -> str:\\n k: int = int(self.metadata.track_number)\\n if self.outfile is None:\\n v: Optional[str] = None\\n elif not isinstance(self.outfile, Path):\\n v: Optional[str] = None\\n else:\\n v: Optional[str] = str(self.outfile.absolute())\\n json.dumps({k: v})\\n return None\"\n },\n {\n \"identifier\": \"Video\",\n \"path\": \"tidal_wave/video.py\",\n \"snippet\": \"class Video:\\n video_id: int\\n\\n def __post_init__(self):\\n self.tags: dict = {}\\n self.codec: str = \\\"mp4\\\"\\n\\n def get_metadata(self, session: Session):\\n \\\"\\\"\\\"Request from TIDAL API /videos endpoint\\\"\\\"\\\"\\n self.metadata: Optional[VideosEndpointResponseJSON] = request_videos(\\n session, self.video_id\\n )\\n\\n def get_contributors(self, session: Session):\\n \\\"\\\"\\\"Request from TIDAL API /videos/contributors endpoint\\\"\\\"\\\"\\n self.contributors: Optional[\\n VideosContributorsResponseJSON\\n ] = request_video_contributors(session, self.video_id)\\n\\n def get_stream(self, session: Session, video_format=VideoFormat.high):\\n \\\"\\\"\\\"Populates self.stream by requesting from TIDAL API\\n /videos/playbackinfopostpaywall endpoint\\\"\\\"\\\"\\n self.stream: Optional[VideosEndpointStreamResponseJSON] = request_video_stream(\\n session, self.video_id, video_format.value\\n )\\n\\n def get_m3u8(self, session: Session):\\n \\\"\\\"\\\"This method sets self.m3u8, an m3u8.M3U8 object\\n following the HTTP Live Streaming specification; parsed from\\n self.stream. I.e., self.get_stream() needs to have been executed\\n before calling this method. N.b. self.m3u8 almost certainly will\\n be a multivariant playlist, meaning further processing of its\\n contents will be necessary.\\\"\\\"\\\"\\n self.m3u8: m3u8.Playlist = playlister(session=session, vesrj=self.stream)\\n\\n def set_urls(self):\\n \\\"\\\"\\\"This method uses self.m3u8, an m3u8.M3U8 object that is variant:\\n (https://developer.apple.com/documentation/http-live-streaming/creating-a-multivariant-playlist)\\n It retrieves the highest-quality .m3u8 in its .playlists attribute,\\n and sets self.urls as the list of strings from that m3u8.Playlist\\\"\\\"\\\"\\n # for now, just get the highest-bandwidth playlist\\n playlist: m3u8.Playlist = variant_streams(self.m3u8)\\n self.M3U8 = m3u8.load(playlist.uri)\\n if self.M3U8 is None or len(self.M3U8.files) == 0:\\n raise TidalM3U8Exception(\\n f\\\"HLS media segments are not available for video {self.video_id}\\\"\\n )\\n self.urls: List[str] = self.M3U8.files\\n\\n def set_artist_dir(self, out_dir: Path):\\n \\\"\\\"\\\"Set self.artist_dir, which is the subdirectory of `out_dir`\\n with name `self.metadata.artist.name`\\\"\\\"\\\"\\n self.artist_dir: Path = out_dir / self.metadata.artist.name\\n self.artist_dir.mkdir(parents=True, exist_ok=True)\\n\\n def set_filename(self, out_dir: Path):\\n \\\"\\\"\\\"Set self.filename, which is constructed from self.metadata.name\\n and self.stream.video_quality\\\"\\\"\\\"\\n self.filename: str = (\\n f\\\"{self.metadata.name} [{self.stream.video_quality}].{self.codec}\\\"\\n )\\n\\n def set_outfile(self):\\n \\\"\\\"\\\"Uses self.artist_dir and self.metadata and self.filename\\n to craft the pathlib.Path object, self.outfile, that is a\\n reference to where the track will be written on disk.\\\"\\\"\\\"\\n self.outfile: Path = self.artist_dir / self.filename\\n\\n if (self.outfile.exists()) and (self.outfile.stat().st_size > 0):\\n logger.info(\\n f\\\"Video {str(self.outfile.absolute())} already exists \\\"\\n \\\"and therefore will not be overwritten\\\"\\n )\\n return\\n else:\\n return self.outfile\\n\\n def download(self, session: Session, out_dir: Path) -> Optional[Path]:\\n \\\"\\\"\\\"Requests the HLS video files that constitute self.video_id.\\n Writes HLS bytes to a temporary file, then uses FFmpeg to write the\\n video data to self.outfile\\\"\\\"\\\"\\n if session.session_id is not None:\\n download_headers: Dict[str, str] = {\\\"sessionId\\\": session.session_id}\\n else:\\n download_headers: dict = dict()\\n download_params: Dict[str, None] = {k: None for k in session.params}\\n # self.outfile should already have been set by self.set_outfile()\\n logger.info(\\n f\\\"Writing video {self.video_id} to '{str(self.outfile.absolute())}'\\\"\\n )\\n\\n with temporary_file() as ntf:\\n for u in self.urls:\\n with session.get(\\n url=u, headers=download_headers, params=download_params\\n ) as download_response:\\n if not download_response.ok:\\n logger.warning(f\\\"Could not download {self}\\\")\\n else:\\n ntf.write(download_response.content)\\n else:\\n ntf.seek(0)\\n\\n # will always be .mp4 because HLS\\n ffmpeg.input(ntf.name, hide_banner=None, y=None).output(\\n str(self.outfile.absolute()),\\n vcodec=\\\"copy\\\",\\n acodec=\\\"copy\\\",\\n loglevel=\\\"quiet\\\",\\n ).run()\\n\\n logger.info(\\n f\\\"Video {self.video_id} written to '{str(self.outfile.absolute())}'\\\"\\n )\\n return self.outfile\\n\\n def craft_tags(self):\\n \\\"\\\"\\\"Using the TAG_MAPPING dictionary, write the correct values of\\n various metadata tags to the file. Videos are .mp4\\\"\\\"\\\"\\n tags = dict()\\n tag_map = {k: v[\\\"m4a\\\"] for k, v in TAG_MAPPING.items()}\\n\\n tags[tag_map[\\\"artist\\\"]] = \\\";\\\".join((a.name for a in self.metadata.artists))\\n tags[tag_map[\\\"artists\\\"]] = [a.name for a in self.metadata.artists]\\n tags[tag_map[\\\"comment\\\"]] = f\\\"https://tidal.com/browse/video/{self.video_id}\\\"\\n tags[tag_map[\\\"date\\\"]] = str(self.metadata.release_date.date())\\n tags[tag_map[\\\"title\\\"]] = self.metadata.title\\n\\n for tag in {\\\"composer\\\", \\\"director\\\", \\\"lyricist\\\", \\\"producer\\\"}:\\n try:\\n _credits_tag = \\\";\\\".join(getattr(self.contributors, tag))\\n except (TypeError, AttributeError): # NoneType problems\\n continue\\n else:\\n tags[tag_map[tag]] = _credits_tag\\n\\n # Have to convert to bytes the values of the tags starting with '----'\\n for k, v in tags.copy().items():\\n if k.startswith(\\\"----\\\"):\\n if isinstance(v, str):\\n tags[k]: bytes = v.encode(\\\"UTF-8\\\")\\n elif isinstance(v, list):\\n tags[k]: List[bytes] = [s.encode(\\\"UTF-8\\\") for s in v]\\n\\n self.tags: dict = {k: v for k, v in tags.items() if v is not None}\\n\\n def set_tags(self):\\n \\\"\\\"\\\"Instantiate a mutagen.File instance, add self.tags to it, and\\n save it to disk\\\"\\\"\\\"\\n self.mutagen = mutagen.File(self.outfile)\\n self.mutagen.clear()\\n self.mutagen.update(**self.tags)\\n self.mutagen.save()\\n\\n def get(\\n self,\\n session: Session,\\n out_dir: Path,\\n metadata: Optional[\\\"VideosEndpointResponseJSON\\\"] = None,\\n ) -> Optional[str]:\\n \\\"\\\"\\\"The main method of this class. Executes a number of other methods\\n in a row:\\n - self.get_metadata()\\n - self.get_contributors()\\n - self.get_stream()\\n - self.get_m3u8()\\n - self.set_urls()\\n - self.set_artist_dir()\\n - self.set_filename()\\n - self.set_outfile()\\n - self.download()\\n - self.craft_tags()\\n - self.set_tags()\\n \\\"\\\"\\\"\\n if metadata is None:\\n self.get_metadata(session)\\n else:\\n self.metadata = metadata\\n\\n if self.metadata is None:\\n return None\\n\\n self.get_contributors(session)\\n self.get_stream(session)\\n if self.stream is None:\\n return None\\n self.get_m3u8(session)\\n self.set_urls()\\n self.set_artist_dir(out_dir)\\n self.set_filename(out_dir)\\n outfile: Optional[Path] = self.set_outfile()\\n if outfile is None:\\n return None\\n\\n if self.download(session, out_dir) is None:\\n return None\\n\\n self.craft_tags()\\n self.set_tags()\\n return str(self.outfile.absolute())\\n\\n def dump(self, fp=sys.stdout):\\n json.dump({self.metadata.title: str(self.outfile.absolute())}, fp)\\n\\n def dumps(self) -> str:\\n return json.dumps({self.metadata.title: str(self.outfile.absolute())})\"\n },\n {\n \"identifier\": \"match_tidal_url\",\n \"path\": \"tidal_wave/models.py\",\n \"snippet\": \"def match_tidal_url(input_str: str) -> Optional[TidalResource]:\\n \\\"\\\"\\\"Attempt to match the `input_str` to either the URL of a track or an\\n album in the Tidal API service. Returns None if `input_str` matches\\n neither, otherwise a subclass of TidalResource corresponding to the\\n parsed input_str type\\n \\\"\\\"\\\"\\n resource_match: Optional[TidalResource] = None\\n tidal_resources: Tuple[TidalResource] = (\\n TidalTrack,\\n TidalAlbum,\\n TidalVideo,\\n TidalPlaylist,\\n TidalMix,\\n TidalArtist,\\n )\\n for T in tidal_resources:\\n try:\\n resource_match = T(input_str)\\n except ValueError as v:\\n logger.debug(v)\\n continue\\n else:\\n return resource_match\"\n },\n {\n \"identifier\": \"TidalAlbum\",\n \"path\": \"tidal_wave/models.py\",\n \"snippet\": \"class TidalAlbum(TidalResource):\\n \\\"\\\"\\\"Class representing a TIDAL album. Its main purpose is the\\n __post_init__ checking process\\\"\\\"\\\"\\n\\n url: str\\n\\n def __post_init__(self):\\n self.pattern: str = (\\n r\\\"http(?:s)?://(?:listen\\\\.)?tidal\\\\.com/(?:browse/)?album/(\\\\d{5,9})(?:.*?)?\\\"\\n )\\n _id = self.match_url()\\n\\n if _id is None:\\n raise ValueError(f\\\"'{self.url}' is not a valid TIDAL album URL\\\")\\n else:\\n self.tidal_id = int(_id)\\n logger.info(f\\\"TIDAL album ID parsed from input: {self.tidal_id}\\\")\"\n },\n {\n \"identifier\": \"TidalArtist\",\n \"path\": \"tidal_wave/models.py\",\n \"snippet\": \"class TidalArtist(TidalResource):\\n \\\"\\\"\\\"Class representing a TIDAL artist. Its main purpose is the\\n __post_init__ checking process\\\"\\\"\\\"\\n\\n url: str\\n\\n def __post_init__(self):\\n self.pattern: str = (\\n r\\\"http(?:s)?://(?:listen\\\\.)?tidal\\\\.com/(?:browse/)?artist/(\\\\d{7,9})(?:.*?)?\\\"\\n )\\n _id = self.match_url()\\n\\n if _id is None:\\n raise ValueError(f\\\"'{self.url}' is not a valid TIDAL album URL\\\")\\n else:\\n self.tidal_id = int(_id)\\n logger.info(f\\\"TIDAL album ID parsed from input: {self.tidal_id}\\\")\"\n },\n {\n \"identifier\": \"TidalMix\",\n \"path\": \"tidal_wave/models.py\",\n \"snippet\": \"class TidalMix(TidalResource):\\n url: str\\n\\n def __post_init__(self):\\n self.pattern: str = (\\n r\\\"http(?:s)?://(?:listen\\\\.)?tidal\\\\.com/(?:browse/)?mix/(\\\\w{30})(?:.*?)?\\\"\\n )\\n _id = self.match_url()\\n\\n if _id is None:\\n raise ValueError(f\\\"'{self.url}' is not a valid TIDAL mix URL\\\")\\n else:\\n self.tidal_id = _id\\n logger.info(f\\\"TIDAL mix ID parsed from input: {self.tidal_id}\\\")\"\n },\n {\n \"identifier\": \"TidalPlaylist\",\n \"path\": \"tidal_wave/models.py\",\n \"snippet\": \"class TidalPlaylist(TidalResource):\\n \\\"\\\"\\\"Class representing a TIDAL playlist. Its main purpose is the\\n __post_init__ checking process\\\"\\\"\\\"\\n\\n url: str\\n\\n def __post_init__(self):\\n self.pattern: str = (\\n r\\\"http(?:s)?://(?:listen\\\\.)?tidal\\\\.com/(?:browse/)?playlist/\\\"\\n r\\\"([0-9a-f]{8}\\\\-[0-9a-f]{4}\\\\-4[0-9a-f]{3}\\\\-[89ab][0-9a-f]{3}\\\\-[0-9a-f]{12})(?:.*?)?\\\"\\n )\\n\\n _id = self.match_url()\\n\\n if _id is None:\\n raise ValueError(f\\\"'{self.url}' is not a valid TIDAL playlist URL\\\")\\n else:\\n self.tidal_id = _id\\n logger.info(f\\\"TIDAL playlist ID parsed from input: {self.tidal_id}\\\")\"\n },\n {\n \"identifier\": \"TidalTrack\",\n \"path\": \"tidal_wave/models.py\",\n \"snippet\": \"class TidalTrack(TidalResource):\\n \\\"\\\"\\\"Class representing a TIDAL track. Its main purpose is the\\n __post_init__ checking process\\\"\\\"\\\"\\n\\n url: str\\n\\n def __post_init__(self):\\n self.pattern: str = r\\\"http(?:s)?://(?:listen\\\\.)?tidal\\\\.com/(?:browse/)?(?:album/\\\\d{5,9}/)?track/(\\\\d{5,9})(?:.*?)?\\\"\\n _id = self.match_url()\\n\\n if _id is None:\\n raise ValueError(f\\\"'{self.url}' is not a valid TIDAL track URL\\\")\\n else:\\n self.tidal_id = int(_id)\\n logger.info(f\\\"TIDAL track ID parsed from input: {self.tidal_id}\\\")\"\n },\n {\n \"identifier\": \"TidalVideo\",\n \"path\": \"tidal_wave/models.py\",\n \"snippet\": \"class TidalVideo(TidalResource):\\n \\\"\\\"\\\"Class representing a TIDAL video. Its main purpose is the\\n __post_init__ checking process\\\"\\\"\\\"\\n\\n url: str\\n\\n def __post_init__(self):\\n self.pattern: str = (\\n r\\\"http(?:s)?://(?:listen\\\\.)?tidal\\\\.com/(?:browse/)?video/(\\\\d{7,9})(?:.*?)?\\\"\\n )\\n _id = self.match_url()\\n\\n if _id is None:\\n raise ValueError(f\\\"'{self.url}' is not a valid TIDAL video URL\\\")\\n else:\\n self.tidal_id = int(_id)\\n logger.info(f\\\"TIDAL video ID parsed from input: {self.tidal_id}\\\")\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from contextlib import closing\nfrom pathlib import Path\nfrom typing import Optional, Union\nfrom .login import login, AudioFormat, LogLevel\nfrom .album import Album\nfrom .artist import Artist\nfrom .mix import Mix\nfrom .playlist import Playlist\nfrom .track import Track\nfrom .video import Video\nfrom .models import (\n match_tidal_url,\n TidalAlbum,\n TidalArtist,\n TidalMix,\n TidalPlaylist,\n TidalTrack,\n TidalVideo,\n)\nfrom platformdirs import user_music_path\nfrom typing_extensions import Annotated\nimport logging\nimport typer"},"token_num":{"kind":"number","value":17086,"string":"17,086"},"cropped_code":{"kind":"string","value":"\n\n\napp = typer.Typer()\n\n\n@app.command()\ndef main(\n tidal_url: Annotated[\n str,\n typer.Argument(\n help=\"The Tidal album or artist or mix or playlist or track or video to download\"\n ),\n ],\n audio_format: Annotated[\n AudioFormat, typer.Option(case_sensitive=False)\n ] = AudioFormat.lossless.value,\n output_directory: Annotated[\n Path,\n typer.Argument(\n help=\"The parent directory under which directory(ies) of files will be written\"\n ),\n ] = user_music_path(),\n loglevel: Annotated[\n LogLevel, typer.Option(case_sensitive=False)\n ] = LogLevel.info.value,\n include_eps_singles: Annotated[\n bool,\n typer.Option(\n \"--include-eps-singles\",\n help=\"No-op unless passing TIDAL artist. Whether to include artist's EPs and singles with albums\",\n ),\n ] = False,\n):\n logging.basicConfig(\n format=\"%(asctime)s,%(msecs)03d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s\",\n datefmt=\"%Y-%m-%d:%H:%M:%S\",\n level=logging.getLevelName(loglevel.value),\n )\n logger = logging.getLogger(__name__)\n\n tidal_resource: Optional[\n"},"all_code":{"kind":"string","value":"\n\n\napp = typer.Typer()\n\n\n@app.command()\ndef main(\n tidal_url: Annotated[\n str,\n typer.Argument(\n help=\"The Tidal album or artist or mix or playlist or track or video to download\"\n ),\n ],\n audio_format: Annotated[\n AudioFormat, typer.Option(case_sensitive=False)\n ] = AudioFormat.lossless.value,\n output_directory: Annotated[\n Path,\n typer.Argument(\n help=\"The parent directory under which directory(ies) of files will be written\"\n ),\n ] = user_music_path(),\n loglevel: Annotated[\n LogLevel, typer.Option(case_sensitive=False)\n ] = LogLevel.info.value,\n include_eps_singles: Annotated[\n bool,\n typer.Option(\n \"--include-eps-singles\",\n help=\"No-op unless passing TIDAL artist. Whether to include artist's EPs and singles with albums\",\n ),\n ] = False,\n):\n logging.basicConfig(\n format=\"%(asctime)s,%(msecs)03d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s\",\n datefmt=\"%Y-%m-%d:%H:%M:%S\",\n level=logging.getLevelName(loglevel.value),\n )\n logger = logging.getLogger(__name__)\n\n tidal_resource: Optional["},"next_line":{"kind":"string","value":" Union[TidalAlbum, TidalMix, TidalPlaylist, TidalTrack, TidalVideo]"},"gold_snippet_index":{"kind":"number","value":12,"string":"12"},"created_at":{"kind":"string","value":"2023-12-12 21:50:25+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5982,"cells":{"repo_name":{"kind":"string","value":"ZS-YANG/FemtoDet-v3"},"file_path":{"kind":"string","value":"mmdet/datasets/transforms/transforms.py"},"context":{"kind":"list like","value":[{"identifier":"TRANSFORMS","path":"mmdet/registry.py","snippet":"TRANSFORMS = Registry(\n 'transform',\n parent=MMENGINE_TRANSFORMS,\n locations=['mmdet.datasets.transforms'])"},{"identifier":"autocast_box_type","path":"mmdet/structures/bbox/box_type.py","snippet":"def autocast_box_type(dst_box_type='hbox') -> Callable:\n \"\"\"A decorator which automatically casts results['gt_bboxes'] to the\n destination box type.\n\n It commenly used in mmdet.datasets.transforms to make the transforms up-\n compatible with the np.ndarray type of results['gt_bboxes'].\n\n The speed of processing of np.ndarray and BaseBoxes data are the same:\n\n - np.ndarray: 0.0509 img/s\n - BaseBoxes: 0.0551 img/s\n\n Args:\n dst_box_type (str): Destination box type.\n \"\"\"\n _, box_type_cls = get_box_type(dst_box_type)\n\n def decorator(func: Callable) -> Callable:\n\n def wrapper(self, results: dict, *args, **kwargs) -> dict:\n if ('gt_bboxes' not in results\n or isinstance(results['gt_bboxes'], BaseBoxes)):\n return func(self, results)\n elif isinstance(results['gt_bboxes'], np.ndarray):\n results['gt_bboxes'] = box_type_cls(\n results['gt_bboxes'], clone=False)\n if 'mix_results' in results:\n for res in results['mix_results']:\n if isinstance(res['gt_bboxes'], np.ndarray):\n res['gt_bboxes'] = box_type_cls(\n res['gt_bboxes'], clone=False)\n\n _results = func(self, results, *args, **kwargs)\n\n # In some cases, the function will process gt_bboxes in-place\n # Simultaneously convert inputting and outputting gt_bboxes\n # back to np.ndarray\n if isinstance(_results, dict) and 'gt_bboxes' in _results:\n if isinstance(_results['gt_bboxes'], BaseBoxes):\n _results['gt_bboxes'] = _results['gt_bboxes'].numpy()\n if isinstance(results['gt_bboxes'], BaseBoxes):\n results['gt_bboxes'] = results['gt_bboxes'].numpy()\n return _results\n else:\n raise TypeError(\n \"auto_box_type requires results['gt_bboxes'] to \"\n 'be BaseBoxes or np.ndarray, but got '\n f\"{type(results['gt_bboxes'])}\")\n\n return wrapper\n\n return decorator"},{"identifier":"HorizontalBoxes","path":"mmdet/structures/bbox/horizontal_boxes.py","snippet":"class HorizontalBoxes(BaseBoxes):\n \"\"\"The horizontal box class used in MMDetection by default.\n\n The ``box_dim`` of ``HorizontalBoxes`` is 4, which means the length of\n the last dimension of the data should be 4. Two modes of box data are\n supported in ``HorizontalBoxes``:\n\n - 'xyxy': Each row of data indicates (x1, y1, x2, y2), which are the\n coordinates of the left-top and right-bottom points.\n - 'cxcywh': Each row of data indicates (x, y, w, h), where (x, y) are the\n coordinates of the box centers and (w, h) are the width and height.\n\n ``HorizontalBoxes`` only restores 'xyxy' mode of data. If the the data is\n in 'cxcywh' mode, users need to input ``in_mode='cxcywh'`` and The code\n will convert the 'cxcywh' data to 'xyxy' automatically.\n\n Args:\n data (Tensor or np.ndarray or Sequence): The box data with shape of\n (..., 4).\n dtype (torch.dtype, Optional): data type of boxes. Defaults to None.\n device (str or torch.device, Optional): device of boxes.\n Default to None.\n clone (bool): Whether clone ``boxes`` or not. Defaults to True.\n mode (str, Optional): the mode of boxes. If it is 'cxcywh', the\n `data` will be converted to 'xyxy' mode. Defaults to None.\n \"\"\"\n\n box_dim: int = 4\n\n def __init__(self,\n data: Union[Tensor, np.ndarray],\n dtype: torch.dtype = None,\n device: DeviceType = None,\n clone: bool = True,\n in_mode: Optional[str] = None) -> None:\n super().__init__(data=data, dtype=dtype, device=device, clone=clone)\n if isinstance(in_mode, str):\n if in_mode not in ('xyxy', 'cxcywh'):\n raise ValueError(f'Get invalid mode {in_mode}.')\n if in_mode == 'cxcywh':\n self.tensor = self.cxcywh_to_xyxy(self.tensor)\n\n @staticmethod\n def cxcywh_to_xyxy(boxes: Tensor) -> Tensor:\n \"\"\"Convert box coordinates from (cx, cy, w, h) to (x1, y1, x2, y2).\n\n Args:\n boxes (Tensor): cxcywh boxes tensor with shape of (..., 4).\n\n Returns:\n Tensor: xyxy boxes tensor with shape of (..., 4).\n \"\"\"\n ctr, wh = boxes.split((2, 2), dim=-1)\n return torch.cat([(ctr - wh / 2), (ctr + wh / 2)], dim=-1)\n\n @staticmethod\n def xyxy_to_cxcywh(boxes: Tensor) -> Tensor:\n \"\"\"Convert box coordinates from (x1, y1, x2, y2) to (cx, cy, w, h).\n\n Args:\n boxes (Tensor): xyxy boxes tensor with shape of (..., 4).\n\n Returns:\n Tensor: cxcywh boxes tensor with shape of (..., 4).\n \"\"\"\n xy1, xy2 = boxes.split((2, 2), dim=-1)\n return torch.cat([(xy2 + xy1) / 2, (xy2 - xy1)], dim=-1)\n\n @property\n def cxcywh(self) -> Tensor:\n \"\"\"Return a tensor representing the cxcywh boxes.\"\"\"\n return self.xyxy_to_cxcywh(self.tensor)\n\n @property\n def centers(self) -> Tensor:\n \"\"\"Return a tensor representing the centers of boxes.\"\"\"\n boxes = self.tensor\n return (boxes[..., :2] + boxes[..., 2:]) / 2\n\n @property\n def areas(self) -> Tensor:\n \"\"\"Return a tensor representing the areas of boxes.\"\"\"\n boxes = self.tensor\n return (boxes[..., 2] - boxes[..., 0]) * (\n boxes[..., 3] - boxes[..., 1])\n\n @property\n def widths(self) -> Tensor:\n \"\"\"Return a tensor representing the widths of boxes.\"\"\"\n boxes = self.tensor\n return boxes[..., 2] - boxes[..., 0]\n\n @property\n def heights(self) -> Tensor:\n \"\"\"Return a tensor representing the heights of boxes.\"\"\"\n boxes = self.tensor\n return boxes[..., 3] - boxes[..., 1]\n\n def flip_(self,\n img_shape: Tuple[int, int],\n direction: str = 'horizontal') -> None:\n \"\"\"Flip boxes horizontally or vertically in-place.\n\n Args:\n img_shape (Tuple[int, int]): A tuple of image height and width.\n direction (str): Flip direction, options are \"horizontal\",\n \"vertical\" and \"diagonal\". Defaults to \"horizontal\"\n \"\"\"\n assert direction in ['horizontal', 'vertical', 'diagonal']\n flipped = self.tensor\n boxes = flipped.clone()\n if direction == 'horizontal':\n flipped[..., 0] = img_shape[1] - boxes[..., 2]\n flipped[..., 2] = img_shape[1] - boxes[..., 0]\n elif direction == 'vertical':\n flipped[..., 1] = img_shape[0] - boxes[..., 3]\n flipped[..., 3] = img_shape[0] - boxes[..., 1]\n else:\n flipped[..., 0] = img_shape[1] - boxes[..., 2]\n flipped[..., 1] = img_shape[0] - boxes[..., 3]\n flipped[..., 2] = img_shape[1] - boxes[..., 0]\n flipped[..., 3] = img_shape[0] - boxes[..., 1]\n\n def translate_(self, distances: Tuple[float, float]) -> None:\n \"\"\"Translate boxes in-place.\n\n Args:\n distances (Tuple[float, float]): translate distances. The first\n is horizontal distance and the second is vertical distance.\n \"\"\"\n boxes = self.tensor\n assert len(distances) == 2\n self.tensor = boxes + boxes.new_tensor(distances).repeat(2)\n\n def clip_(self, img_shape: Tuple[int, int]) -> None:\n \"\"\"Clip boxes according to the image shape in-place.\n\n Args:\n img_shape (Tuple[int, int]): A tuple of image height and width.\n \"\"\"\n boxes = self.tensor\n boxes[..., 0::2] = boxes[..., 0::2].clamp(0, img_shape[1])\n boxes[..., 1::2] = boxes[..., 1::2].clamp(0, img_shape[0])\n\n def rotate_(self, center: Tuple[float, float], angle: float) -> None:\n \"\"\"Rotate all boxes in-place.\n\n Args:\n center (Tuple[float, float]): Rotation origin.\n angle (float): Rotation angle represented in degrees. Positive\n values mean clockwise rotation.\n \"\"\"\n boxes = self.tensor\n rotation_matrix = boxes.new_tensor(\n cv2.getRotationMatrix2D(center, -angle, 1))\n\n corners = self.hbox2corner(boxes)\n corners = torch.cat(\n [corners, corners.new_ones(*corners.shape[:-1], 1)], dim=-1)\n corners_T = torch.transpose(corners, -1, -2)\n corners_T = torch.matmul(rotation_matrix, corners_T)\n corners = torch.transpose(corners_T, -1, -2)\n self.tensor = self.corner2hbox(corners)\n\n def project_(self, homography_matrix: Union[Tensor, np.ndarray]) -> None:\n \"\"\"Geometric transformat boxes in-place.\n\n Args:\n homography_matrix (Tensor or np.ndarray]):\n Shape (3, 3) for geometric transformation.\n \"\"\"\n boxes = self.tensor\n if isinstance(homography_matrix, np.ndarray):\n homography_matrix = boxes.new_tensor(homography_matrix)\n corners = self.hbox2corner(boxes)\n corners = torch.cat(\n [corners, corners.new_ones(*corners.shape[:-1], 1)], dim=-1)\n corners_T = torch.transpose(corners, -1, -2)\n corners_T = torch.matmul(homography_matrix, corners_T)\n corners = torch.transpose(corners_T, -1, -2)\n # Convert to homogeneous coordinates by normalization\n corners = corners[..., :2] / corners[..., 2:3]\n self.tensor = self.corner2hbox(corners)\n\n @staticmethod\n def hbox2corner(boxes: Tensor) -> Tensor:\n \"\"\"Convert box coordinates from (x1, y1, x2, y2) to corners ((x1, y1),\n (x2, y1), (x1, y2), (x2, y2)).\n\n Args:\n boxes (Tensor): Horizontal box tensor with shape of (..., 4).\n\n Returns:\n Tensor: Corner tensor with shape of (..., 4, 2).\n \"\"\"\n x1, y1, x2, y2 = torch.split(boxes, 1, dim=-1)\n corners = torch.cat([x1, y1, x2, y1, x1, y2, x2, y2], dim=-1)\n return corners.reshape(*corners.shape[:-1], 4, 2)\n\n @staticmethod\n def corner2hbox(corners: Tensor) -> Tensor:\n \"\"\"Convert box coordinates from corners ((x1, y1), (x2, y1), (x1, y2),\n (x2, y2)) to (x1, y1, x2, y2).\n\n Args:\n corners (Tensor): Corner tensor with shape of (..., 4, 2).\n\n Returns:\n Tensor: Horizontal box tensor with shape of (..., 4).\n \"\"\"\n if corners.numel() == 0:\n return corners.new_zeros((0, 4))\n min_xy = corners.min(dim=-2)[0]\n max_xy = corners.max(dim=-2)[0]\n return torch.cat([min_xy, max_xy], dim=-1)\n\n def rescale_(self, scale_factor: Tuple[float, float]) -> None:\n \"\"\"Rescale boxes w.r.t. rescale_factor in-place.\n\n Note:\n Both ``rescale_`` and ``resize_`` will enlarge or shrink boxes\n w.r.t ``scale_facotr``. The difference is that ``resize_`` only\n changes the width and the height of boxes, but ``rescale_`` also\n rescales the box centers simultaneously.\n\n Args:\n scale_factor (Tuple[float, float]): factors for scaling boxes.\n The length should be 2.\n \"\"\"\n boxes = self.tensor\n assert len(scale_factor) == 2\n scale_factor = boxes.new_tensor(scale_factor).repeat(2)\n self.tensor = boxes * scale_factor\n\n def resize_(self, scale_factor: Tuple[float, float]) -> None:\n \"\"\"Resize the box width and height w.r.t scale_factor in-place.\n\n Note:\n Both ``rescale_`` and ``resize_`` will enlarge or shrink boxes\n w.r.t ``scale_facotr``. The difference is that ``resize_`` only\n changes the width and the height of boxes, but ``rescale_`` also\n rescales the box centers simultaneously.\n\n Args:\n scale_factor (Tuple[float, float]): factors for scaling box\n shapes. The length should be 2.\n \"\"\"\n boxes = self.tensor\n assert len(scale_factor) == 2\n ctrs = (boxes[..., 2:] + boxes[..., :2]) / 2\n wh = boxes[..., 2:] - boxes[..., :2]\n scale_factor = boxes.new_tensor(scale_factor)\n wh = wh * scale_factor\n xy1 = ctrs - 0.5 * wh\n xy2 = ctrs + 0.5 * wh\n self.tensor = torch.cat([xy1, xy2], dim=-1)\n\n def is_inside(self,\n img_shape: Tuple[int, int],\n all_inside: bool = False,\n allowed_border: int = 0) -> BoolTensor:\n \"\"\"Find boxes inside the image.\n\n Args:\n img_shape (Tuple[int, int]): A tuple of image height and width.\n all_inside (bool): Whether the boxes are all inside the image or\n part inside the image. Defaults to False.\n allowed_border (int): Boxes that extend beyond the image shape\n boundary by more than ``allowed_border`` are considered\n \"outside\" Defaults to 0.\n Returns:\n BoolTensor: A BoolTensor indicating whether the box is inside\n the image. Assuming the original boxes have shape (m, n, 4),\n the output has shape (m, n).\n \"\"\"\n img_h, img_w = img_shape\n boxes = self.tensor\n if all_inside:\n return (boxes[:, 0] >= -allowed_border) & \\\n (boxes[:, 1] >= -allowed_border) & \\\n (boxes[:, 2] < img_w + allowed_border) & \\\n (boxes[:, 3] < img_h + allowed_border)\n else:\n return (boxes[..., 0] < img_w + allowed_border) & \\\n (boxes[..., 1] < img_h + allowed_border) & \\\n (boxes[..., 2] > -allowed_border) & \\\n (boxes[..., 3] > -allowed_border)\n\n def find_inside_points(self,\n points: Tensor,\n is_aligned: bool = False) -> BoolTensor:\n \"\"\"Find inside box points. Boxes dimension must be 2.\n\n Args:\n points (Tensor): Points coordinates. Has shape of (m, 2).\n is_aligned (bool): Whether ``points`` has been aligned with boxes\n or not. If True, the length of boxes and ``points`` should be\n the same. Defaults to False.\n\n Returns:\n BoolTensor: A BoolTensor indicating whether a point is inside\n boxes. Assuming the boxes has shape of (n, 4), if ``is_aligned``\n is False. The index has shape of (m, n). If ``is_aligned`` is\n True, m should be equal to n and the index has shape of (m, ).\n \"\"\"\n boxes = self.tensor\n assert boxes.dim() == 2, 'boxes dimension must be 2.'\n\n if not is_aligned:\n boxes = boxes[None, :, :]\n points = points[:, None, :]\n else:\n assert boxes.size(0) == points.size(0)\n\n x_min, y_min, x_max, y_max = boxes.unbind(dim=-1)\n return (points[..., 0] >= x_min) & (points[..., 0] <= x_max) & \\\n (points[..., 1] >= y_min) & (points[..., 1] <= y_max)\n\n def create_masks(self, img_shape: Tuple[int, int]) -> BitmapMasks:\n \"\"\"\n Args:\n img_shape (Tuple[int, int]): A tuple of image height and width.\n\n Returns:\n :obj:`BitmapMasks`: Converted masks\n \"\"\"\n img_h, img_w = img_shape\n boxes = self.tensor\n\n xmin, ymin = boxes[:, 0:1], boxes[:, 1:2]\n xmax, ymax = boxes[:, 2:3], boxes[:, 3:4]\n gt_masks = np.zeros((len(boxes), img_h, img_w), dtype=np.uint8)\n for i in range(len(boxes)):\n gt_masks[i,\n int(ymin[i]):int(ymax[i]),\n int(xmin[i]):int(xmax[i])] = 1\n return BitmapMasks(gt_masks, img_h, img_w)\n\n @staticmethod\n def overlaps(boxes1: BaseBoxes,\n boxes2: BaseBoxes,\n mode: str = 'iou',\n is_aligned: bool = False,\n eps: float = 1e-6) -> Tensor:\n \"\"\"Calculate overlap between two set of boxes with their types\n converted to ``HorizontalBoxes``.\n\n Args:\n boxes1 (:obj:`BaseBoxes`): BaseBoxes with shape of (m, box_dim)\n or empty.\n boxes2 (:obj:`BaseBoxes`): BaseBoxes with shape of (n, box_dim)\n or empty.\n mode (str): \"iou\" (intersection over union), \"iof\" (intersection\n over foreground). Defaults to \"iou\".\n is_aligned (bool): If True, then m and n must be equal. Defaults\n to False.\n eps (float): A value added to the denominator for numerical\n stability. Defaults to 1e-6.\n\n Returns:\n Tensor: shape (m, n) if ``is_aligned`` is False else shape (m,)\n \"\"\"\n boxes1 = boxes1.convert_to('hbox')\n boxes2 = boxes2.convert_to('hbox')\n return bbox_overlaps(\n boxes1.tensor,\n boxes2.tensor,\n mode=mode,\n is_aligned=is_aligned,\n eps=eps)\n\n @staticmethod\n def from_instance_masks(masks: MaskType) -> 'HorizontalBoxes':\n \"\"\"Create horizontal boxes from instance masks.\n\n Args:\n masks (:obj:`BitmapMasks` or :obj:`PolygonMasks`): BitmapMasks or\n PolygonMasks instance with length of n.\n\n Returns:\n :obj:`HorizontalBoxes`: Converted boxes with shape of (n, 4).\n \"\"\"\n num_masks = len(masks)\n boxes = np.zeros((num_masks, 4), dtype=np.float32)\n if isinstance(masks, BitmapMasks):\n x_any = masks.masks.any(axis=1)\n y_any = masks.masks.any(axis=2)\n for idx in range(num_masks):\n x = np.where(x_any[idx, :])[0]\n y = np.where(y_any[idx, :])[0]\n if len(x) > 0 and len(y) > 0:\n # use +1 for x_max and y_max so that the right and bottom\n # boundary of instance masks are fully included by the box\n boxes[idx, :] = np.array(\n [x[0], y[0], x[-1] + 1, y[-1] + 1], dtype=np.float32)\n elif isinstance(masks, PolygonMasks):\n for idx, poly_per_obj in enumerate(masks.masks):\n # simply use a number that is big enough for comparison with\n # coordinates\n xy_min = np.array([masks.width * 2, masks.height * 2],\n dtype=np.float32)\n xy_max = np.zeros(2, dtype=np.float32)\n for p in poly_per_obj:\n xy = np.array(p).reshape(-1, 2).astype(np.float32)\n xy_min = np.minimum(xy_min, np.min(xy, axis=0))\n xy_max = np.maximum(xy_max, np.max(xy, axis=0))\n boxes[idx, :2] = xy_min\n boxes[idx, 2:] = xy_max\n else:\n raise TypeError(\n '`masks` must be `BitmapMasks` or `PolygonMasks`, '\n f'but got {type(masks)}.')\n return HorizontalBoxes(boxes)"},{"identifier":"BitmapMasks","path":"mmdet/structures/mask/structures.py","snippet":"class BitmapMasks(BaseInstanceMasks):\n \"\"\"This class represents masks in the form of bitmaps.\n\n Args:\n masks (ndarray): ndarray of masks in shape (N, H, W), where N is\n the number of objects.\n height (int): height of masks\n width (int): width of masks\n\n Example:\n >>> from mmdet.data_elements.mask.structures import * # NOQA\n >>> num_masks, H, W = 3, 32, 32\n >>> rng = np.random.RandomState(0)\n >>> masks = (rng.rand(num_masks, H, W) > 0.1).astype(np.int64)\n >>> self = BitmapMasks(masks, height=H, width=W)\n\n >>> # demo crop_and_resize\n >>> num_boxes = 5\n >>> bboxes = np.array([[0, 0, 30, 10.0]] * num_boxes)\n >>> out_shape = (14, 14)\n >>> inds = torch.randint(0, len(self), size=(num_boxes,))\n >>> device = 'cpu'\n >>> interpolation = 'bilinear'\n >>> new = self.crop_and_resize(\n ... bboxes, out_shape, inds, device, interpolation)\n >>> assert len(new) == num_boxes\n >>> assert new.height, new.width == out_shape\n \"\"\"\n\n def __init__(self, masks, height, width):\n self.height = height\n self.width = width\n if len(masks) == 0:\n self.masks = np.empty((0, self.height, self.width), dtype=np.uint8)\n else:\n assert isinstance(masks, (list, np.ndarray))\n if isinstance(masks, list):\n assert isinstance(masks[0], np.ndarray)\n assert masks[0].ndim == 2 # (H, W)\n else:\n assert masks.ndim == 3 # (N, H, W)\n\n self.masks = np.stack(masks).reshape(-1, height, width)\n assert self.masks.shape[1] == self.height\n assert self.masks.shape[2] == self.width\n\n def __getitem__(self, index):\n \"\"\"Index the BitmapMask.\n\n Args:\n index (int | ndarray): Indices in the format of integer or ndarray.\n\n Returns:\n :obj:`BitmapMasks`: Indexed bitmap masks.\n \"\"\"\n masks = self.masks[index].reshape(-1, self.height, self.width)\n return BitmapMasks(masks, self.height, self.width)\n\n def __iter__(self):\n return iter(self.masks)\n\n def __repr__(self):\n s = self.__class__.__name__ + '('\n s += f'num_masks={len(self.masks)}, '\n s += f'height={self.height}, '\n s += f'width={self.width})'\n return s\n\n def __len__(self):\n \"\"\"Number of masks.\"\"\"\n return len(self.masks)\n\n def rescale(self, scale, interpolation='nearest'):\n \"\"\"See :func:`BaseInstanceMasks.rescale`.\"\"\"\n if len(self.masks) == 0:\n new_w, new_h = mmcv.rescale_size((self.width, self.height), scale)\n rescaled_masks = np.empty((0, new_h, new_w), dtype=np.uint8)\n else:\n rescaled_masks = np.stack([\n mmcv.imrescale(mask, scale, interpolation=interpolation)\n for mask in self.masks\n ])\n height, width = rescaled_masks.shape[1:]\n return BitmapMasks(rescaled_masks, height, width)\n\n def resize(self, out_shape, interpolation='nearest'):\n \"\"\"See :func:`BaseInstanceMasks.resize`.\"\"\"\n if len(self.masks) == 0:\n resized_masks = np.empty((0, *out_shape), dtype=np.uint8)\n else:\n resized_masks = np.stack([\n mmcv.imresize(\n mask, out_shape[::-1], interpolation=interpolation)\n for mask in self.masks\n ])\n return BitmapMasks(resized_masks, *out_shape)\n\n def flip(self, flip_direction='horizontal'):\n \"\"\"See :func:`BaseInstanceMasks.flip`.\"\"\"\n assert flip_direction in ('horizontal', 'vertical', 'diagonal')\n\n if len(self.masks) == 0:\n flipped_masks = self.masks\n else:\n flipped_masks = np.stack([\n mmcv.imflip(mask, direction=flip_direction)\n for mask in self.masks\n ])\n return BitmapMasks(flipped_masks, self.height, self.width)\n\n def pad(self, out_shape, pad_val=0):\n \"\"\"See :func:`BaseInstanceMasks.pad`.\"\"\"\n if len(self.masks) == 0:\n padded_masks = np.empty((0, *out_shape), dtype=np.uint8)\n else:\n padded_masks = np.stack([\n mmcv.impad(mask, shape=out_shape, pad_val=pad_val)\n for mask in self.masks\n ])\n return BitmapMasks(padded_masks, *out_shape)\n\n def crop(self, bbox):\n \"\"\"See :func:`BaseInstanceMasks.crop`.\"\"\"\n assert isinstance(bbox, np.ndarray)\n assert bbox.ndim == 1\n\n # clip the boundary\n bbox = bbox.copy()\n bbox[0::2] = np.clip(bbox[0::2], 0, self.width)\n bbox[1::2] = np.clip(bbox[1::2], 0, self.height)\n x1, y1, x2, y2 = bbox\n w = np.maximum(x2 - x1, 1)\n h = np.maximum(y2 - y1, 1)\n\n if len(self.masks) == 0:\n cropped_masks = np.empty((0, h, w), dtype=np.uint8)\n else:\n cropped_masks = self.masks[:, y1:y1 + h, x1:x1 + w]\n return BitmapMasks(cropped_masks, h, w)\n\n def crop_and_resize(self,\n bboxes,\n out_shape,\n inds,\n device='cpu',\n interpolation='bilinear',\n binarize=True):\n \"\"\"See :func:`BaseInstanceMasks.crop_and_resize`.\"\"\"\n if len(self.masks) == 0:\n empty_masks = np.empty((0, *out_shape), dtype=np.uint8)\n return BitmapMasks(empty_masks, *out_shape)\n\n # convert bboxes to tensor\n if isinstance(bboxes, np.ndarray):\n bboxes = torch.from_numpy(bboxes).to(device=device)\n if isinstance(inds, np.ndarray):\n inds = torch.from_numpy(inds).to(device=device)\n\n num_bbox = bboxes.shape[0]\n fake_inds = torch.arange(\n num_bbox, device=device).to(dtype=bboxes.dtype)[:, None]\n rois = torch.cat([fake_inds, bboxes], dim=1) # Nx5\n rois = rois.to(device=device)\n if num_bbox > 0:\n gt_masks_th = torch.from_numpy(self.masks).to(device).index_select(\n 0, inds).to(dtype=rois.dtype)\n targets = roi_align(gt_masks_th[:, None, :, :], rois, out_shape,\n 1.0, 0, 'avg', True).squeeze(1)\n if binarize:\n resized_masks = (targets >= 0.5).cpu().numpy()\n else:\n resized_masks = targets.cpu().numpy()\n else:\n resized_masks = []\n return BitmapMasks(resized_masks, *out_shape)\n\n def expand(self, expanded_h, expanded_w, top, left):\n \"\"\"See :func:`BaseInstanceMasks.expand`.\"\"\"\n if len(self.masks) == 0:\n expanded_mask = np.empty((0, expanded_h, expanded_w),\n dtype=np.uint8)\n else:\n expanded_mask = np.zeros((len(self), expanded_h, expanded_w),\n dtype=np.uint8)\n expanded_mask[:, top:top + self.height,\n left:left + self.width] = self.masks\n return BitmapMasks(expanded_mask, expanded_h, expanded_w)\n\n def translate(self,\n out_shape,\n offset,\n direction='horizontal',\n border_value=0,\n interpolation='bilinear'):\n \"\"\"Translate the BitmapMasks.\n\n Args:\n out_shape (tuple[int]): Shape for output mask, format (h, w).\n offset (int | float): The offset for translate.\n direction (str): The translate direction, either \"horizontal\"\n or \"vertical\".\n border_value (int | float): Border value. Default 0 for masks.\n interpolation (str): Same as :func:`mmcv.imtranslate`.\n\n Returns:\n BitmapMasks: Translated BitmapMasks.\n\n Example:\n >>> from mmdet.data_elements.mask.structures import BitmapMasks\n >>> self = BitmapMasks.random(dtype=np.uint8)\n >>> out_shape = (32, 32)\n >>> offset = 4\n >>> direction = 'horizontal'\n >>> border_value = 0\n >>> interpolation = 'bilinear'\n >>> # Note, There seem to be issues when:\n >>> # * the mask dtype is not supported by cv2.AffineWarp\n >>> new = self.translate(out_shape, offset, direction,\n >>> border_value, interpolation)\n >>> assert len(new) == len(self)\n >>> assert new.height, new.width == out_shape\n \"\"\"\n if len(self.masks) == 0:\n translated_masks = np.empty((0, *out_shape), dtype=np.uint8)\n else:\n masks = self.masks\n if masks.shape[-2:] != out_shape:\n empty_masks = np.zeros((masks.shape[0], *out_shape),\n dtype=masks.dtype)\n min_h = min(out_shape[0], masks.shape[1])\n min_w = min(out_shape[1], masks.shape[2])\n empty_masks[:, :min_h, :min_w] = masks[:, :min_h, :min_w]\n masks = empty_masks\n translated_masks = mmcv.imtranslate(\n masks.transpose((1, 2, 0)),\n offset,\n direction,\n border_value=border_value,\n interpolation=interpolation)\n if translated_masks.ndim == 2:\n translated_masks = translated_masks[:, :, None]\n translated_masks = translated_masks.transpose(\n (2, 0, 1)).astype(self.masks.dtype)\n return BitmapMasks(translated_masks, *out_shape)\n\n def shear(self,\n out_shape,\n magnitude,\n direction='horizontal',\n border_value=0,\n interpolation='bilinear'):\n \"\"\"Shear the BitmapMasks.\n\n Args:\n out_shape (tuple[int]): Shape for output mask, format (h, w).\n magnitude (int | float): The magnitude used for shear.\n direction (str): The shear direction, either \"horizontal\"\n or \"vertical\".\n border_value (int | tuple[int]): Value used in case of a\n constant border.\n interpolation (str): Same as in :func:`mmcv.imshear`.\n\n Returns:\n BitmapMasks: The sheared masks.\n \"\"\"\n if len(self.masks) == 0:\n sheared_masks = np.empty((0, *out_shape), dtype=np.uint8)\n else:\n sheared_masks = mmcv.imshear(\n self.masks.transpose((1, 2, 0)),\n magnitude,\n direction,\n border_value=border_value,\n interpolation=interpolation)\n if sheared_masks.ndim == 2:\n sheared_masks = sheared_masks[:, :, None]\n sheared_masks = sheared_masks.transpose(\n (2, 0, 1)).astype(self.masks.dtype)\n return BitmapMasks(sheared_masks, *out_shape)\n\n def rotate(self,\n out_shape,\n angle,\n center=None,\n scale=1.0,\n border_value=0,\n interpolation='bilinear'):\n \"\"\"Rotate the BitmapMasks.\n\n Args:\n out_shape (tuple[int]): Shape for output mask, format (h, w).\n angle (int | float): Rotation angle in degrees. Positive values\n mean counter-clockwise rotation.\n center (tuple[float], optional): Center point (w, h) of the\n rotation in source image. If not specified, the center of\n the image will be used.\n scale (int | float): Isotropic scale factor.\n border_value (int | float): Border value. Default 0 for masks.\n interpolation (str): Same as in :func:`mmcv.imrotate`.\n\n Returns:\n BitmapMasks: Rotated BitmapMasks.\n \"\"\"\n if len(self.masks) == 0:\n rotated_masks = np.empty((0, *out_shape), dtype=self.masks.dtype)\n else:\n rotated_masks = mmcv.imrotate(\n self.masks.transpose((1, 2, 0)),\n angle,\n center=center,\n scale=scale,\n border_value=border_value,\n interpolation=interpolation)\n if rotated_masks.ndim == 2:\n # case when only one mask, (h, w)\n rotated_masks = rotated_masks[:, :, None] # (h, w, 1)\n rotated_masks = rotated_masks.transpose(\n (2, 0, 1)).astype(self.masks.dtype)\n return BitmapMasks(rotated_masks, *out_shape)\n\n @property\n def areas(self):\n \"\"\"See :py:attr:`BaseInstanceMasks.areas`.\"\"\"\n return self.masks.sum((1, 2))\n\n def to_ndarray(self):\n \"\"\"See :func:`BaseInstanceMasks.to_ndarray`.\"\"\"\n return self.masks\n\n def to_tensor(self, dtype, device):\n \"\"\"See :func:`BaseInstanceMasks.to_tensor`.\"\"\"\n return torch.tensor(self.masks, dtype=dtype, device=device)\n\n @classmethod\n def random(cls,\n num_masks=3,\n height=32,\n width=32,\n dtype=np.uint8,\n rng=None):\n \"\"\"Generate random bitmap masks for demo / testing purposes.\n\n Example:\n >>> from mmdet.data_elements.mask.structures import BitmapMasks\n >>> self = BitmapMasks.random()\n >>> print('self = {}'.format(self))\n self = BitmapMasks(num_masks=3, height=32, width=32)\n \"\"\"\n from mmdet.utils.util_random import ensure_rng\n rng = ensure_rng(rng)\n masks = (rng.rand(num_masks, height, width) > 0.1).astype(dtype)\n self = cls(masks, height=height, width=width)\n return self\n\n @classmethod\n def cat(cls: Type[T], masks: Sequence[T]) -> T:\n \"\"\"Concatenate a sequence of masks into one single mask instance.\n\n Args:\n masks (Sequence[BitmapMasks]): A sequence of mask instances.\n\n Returns:\n BitmapMasks: Concatenated mask instance.\n \"\"\"\n assert isinstance(masks, Sequence)\n if len(masks) == 0:\n raise ValueError('masks should not be an empty list.')\n assert all(isinstance(m, cls) for m in masks)\n\n mask_array = np.concatenate([m.masks for m in masks], axis=0)\n return cls(mask_array, *mask_array.shape[1:])"},{"identifier":"PolygonMasks","path":"mmdet/structures/mask/structures.py","snippet":"class PolygonMasks(BaseInstanceMasks):\n \"\"\"This class represents masks in the form of polygons.\n\n Polygons is a list of three levels. The first level of the list\n corresponds to objects, the second level to the polys that compose the\n object, the third level to the poly coordinates\n\n Args:\n masks (list[list[ndarray]]): The first level of the list\n corresponds to objects, the second level to the polys that\n compose the object, the third level to the poly coordinates\n height (int): height of masks\n width (int): width of masks\n\n Example:\n >>> from mmdet.data_elements.mask.structures import * # NOQA\n >>> masks = [\n >>> [ np.array([0, 0, 10, 0, 10, 10., 0, 10, 0, 0]) ]\n >>> ]\n >>> height, width = 16, 16\n >>> self = PolygonMasks(masks, height, width)\n\n >>> # demo translate\n >>> new = self.translate((16, 16), 4., direction='horizontal')\n >>> assert np.all(new.masks[0][0][1::2] == masks[0][0][1::2])\n >>> assert np.all(new.masks[0][0][0::2] == masks[0][0][0::2] + 4)\n\n >>> # demo crop_and_resize\n >>> num_boxes = 3\n >>> bboxes = np.array([[0, 0, 30, 10.0]] * num_boxes)\n >>> out_shape = (16, 16)\n >>> inds = torch.randint(0, len(self), size=(num_boxes,))\n >>> device = 'cpu'\n >>> interpolation = 'bilinear'\n >>> new = self.crop_and_resize(\n ... bboxes, out_shape, inds, device, interpolation)\n >>> assert len(new) == num_boxes\n >>> assert new.height, new.width == out_shape\n \"\"\"\n\n def __init__(self, masks, height, width):\n assert isinstance(masks, list)\n if len(masks) > 0:\n assert isinstance(masks[0], list)\n assert isinstance(masks[0][0], np.ndarray)\n\n self.height = height\n self.width = width\n self.masks = masks\n\n def __getitem__(self, index):\n \"\"\"Index the polygon masks.\n\n Args:\n index (ndarray | List): The indices.\n\n Returns:\n :obj:`PolygonMasks`: The indexed polygon masks.\n \"\"\"\n if isinstance(index, np.ndarray):\n if index.dtype == bool:\n index = np.where(index)[0].tolist()\n else:\n index = index.tolist()\n if isinstance(index, list):\n masks = [self.masks[i] for i in index]\n else:\n try:\n masks = self.masks[index]\n except Exception:\n raise ValueError(\n f'Unsupported input of type {type(index)} for indexing!')\n if len(masks) and isinstance(masks[0], np.ndarray):\n masks = [masks] # ensure a list of three levels\n return PolygonMasks(masks, self.height, self.width)\n\n def __iter__(self):\n return iter(self.masks)\n\n def __repr__(self):\n s = self.__class__.__name__ + '('\n s += f'num_masks={len(self.masks)}, '\n s += f'height={self.height}, '\n s += f'width={self.width})'\n return s\n\n def __len__(self):\n \"\"\"Number of masks.\"\"\"\n return len(self.masks)\n\n def rescale(self, scale, interpolation=None):\n \"\"\"see :func:`BaseInstanceMasks.rescale`\"\"\"\n new_w, new_h = mmcv.rescale_size((self.width, self.height), scale)\n if len(self.masks) == 0:\n rescaled_masks = PolygonMasks([], new_h, new_w)\n else:\n rescaled_masks = self.resize((new_h, new_w))\n return rescaled_masks\n\n def resize(self, out_shape, interpolation=None):\n \"\"\"see :func:`BaseInstanceMasks.resize`\"\"\"\n if len(self.masks) == 0:\n resized_masks = PolygonMasks([], *out_shape)\n else:\n h_scale = out_shape[0] / self.height\n w_scale = out_shape[1] / self.width\n resized_masks = []\n for poly_per_obj in self.masks:\n resized_poly = []\n for p in poly_per_obj:\n p = p.copy()\n p[0::2] = p[0::2] * w_scale\n p[1::2] = p[1::2] * h_scale\n resized_poly.append(p)\n resized_masks.append(resized_poly)\n resized_masks = PolygonMasks(resized_masks, *out_shape)\n return resized_masks\n\n def flip(self, flip_direction='horizontal'):\n \"\"\"see :func:`BaseInstanceMasks.flip`\"\"\"\n assert flip_direction in ('horizontal', 'vertical', 'diagonal')\n if len(self.masks) == 0:\n flipped_masks = PolygonMasks([], self.height, self.width)\n else:\n flipped_masks = []\n for poly_per_obj in self.masks:\n flipped_poly_per_obj = []\n for p in poly_per_obj:\n p = p.copy()\n if flip_direction == 'horizontal':\n p[0::2] = self.width - p[0::2]\n elif flip_direction == 'vertical':\n p[1::2] = self.height - p[1::2]\n else:\n p[0::2] = self.width - p[0::2]\n p[1::2] = self.height - p[1::2]\n flipped_poly_per_obj.append(p)\n flipped_masks.append(flipped_poly_per_obj)\n flipped_masks = PolygonMasks(flipped_masks, self.height,\n self.width)\n return flipped_masks\n\n def crop(self, bbox):\n \"\"\"see :func:`BaseInstanceMasks.crop`\"\"\"\n assert isinstance(bbox, np.ndarray)\n assert bbox.ndim == 1\n\n # clip the boundary\n bbox = bbox.copy()\n bbox[0::2] = np.clip(bbox[0::2], 0, self.width)\n bbox[1::2] = np.clip(bbox[1::2], 0, self.height)\n x1, y1, x2, y2 = bbox\n w = np.maximum(x2 - x1, 1)\n h = np.maximum(y2 - y1, 1)\n\n if len(self.masks) == 0:\n cropped_masks = PolygonMasks([], h, w)\n else:\n # reference: https://github.com/facebookresearch/fvcore/blob/main/fvcore/transforms/transform.py # noqa\n crop_box = geometry.box(x1, y1, x2, y2).buffer(0.0)\n cropped_masks = []\n # suppress shapely warnings util it incorporates GEOS>=3.11.2\n # reference: https://github.com/shapely/shapely/issues/1345\n initial_settings = np.seterr()\n np.seterr(invalid='ignore')\n for poly_per_obj in self.masks:\n cropped_poly_per_obj = []\n for p in poly_per_obj:\n p = p.copy()\n p = geometry.Polygon(p.reshape(-1, 2)).buffer(0.0)\n # polygon must be valid to perform intersection.\n if not p.is_valid:\n continue\n cropped = p.intersection(crop_box)\n if cropped.is_empty:\n continue\n if isinstance(cropped,\n geometry.collection.BaseMultipartGeometry):\n cropped = cropped.geoms\n else:\n cropped = [cropped]\n # one polygon may be cropped to multiple ones\n for poly in cropped:\n # ignore lines or points\n if not isinstance(\n poly, geometry.Polygon) or not poly.is_valid:\n continue\n coords = np.asarray(poly.exterior.coords)\n # remove an extra identical vertex at the end\n coords = coords[:-1]\n coords[:, 0] -= x1\n coords[:, 1] -= y1\n cropped_poly_per_obj.append(coords.reshape(-1))\n # a dummy polygon to avoid misalignment between masks and boxes\n if len(cropped_poly_per_obj) == 0:\n cropped_poly_per_obj = [np.array([0, 0, 0, 0, 0, 0])]\n cropped_masks.append(cropped_poly_per_obj)\n np.seterr(**initial_settings)\n cropped_masks = PolygonMasks(cropped_masks, h, w)\n return cropped_masks\n\n def pad(self, out_shape, pad_val=0):\n \"\"\"padding has no effect on polygons`\"\"\"\n return PolygonMasks(self.masks, *out_shape)\n\n def expand(self, *args, **kwargs):\n \"\"\"TODO: Add expand for polygon\"\"\"\n raise NotImplementedError\n\n def crop_and_resize(self,\n bboxes,\n out_shape,\n inds,\n device='cpu',\n interpolation='bilinear',\n binarize=True):\n \"\"\"see :func:`BaseInstanceMasks.crop_and_resize`\"\"\"\n out_h, out_w = out_shape\n if len(self.masks) == 0:\n return PolygonMasks([], out_h, out_w)\n\n if not binarize:\n raise ValueError('Polygons are always binary, '\n 'setting binarize=False is unsupported')\n\n resized_masks = []\n for i in range(len(bboxes)):\n mask = self.masks[inds[i]]\n bbox = bboxes[i, :]\n x1, y1, x2, y2 = bbox\n w = np.maximum(x2 - x1, 1)\n h = np.maximum(y2 - y1, 1)\n h_scale = out_h / max(h, 0.1) # avoid too large scale\n w_scale = out_w / max(w, 0.1)\n\n resized_mask = []\n for p in mask:\n p = p.copy()\n # crop\n # pycocotools will clip the boundary\n p[0::2] = p[0::2] - bbox[0]\n p[1::2] = p[1::2] - bbox[1]\n\n # resize\n p[0::2] = p[0::2] * w_scale\n p[1::2] = p[1::2] * h_scale\n resized_mask.append(p)\n resized_masks.append(resized_mask)\n return PolygonMasks(resized_masks, *out_shape)\n\n def translate(self,\n out_shape,\n offset,\n direction='horizontal',\n border_value=None,\n interpolation=None):\n \"\"\"Translate the PolygonMasks.\n\n Example:\n >>> self = PolygonMasks.random(dtype=np.int64)\n >>> out_shape = (self.height, self.width)\n >>> new = self.translate(out_shape, 4., direction='horizontal')\n >>> assert np.all(new.masks[0][0][1::2] == self.masks[0][0][1::2])\n >>> assert np.all(new.masks[0][0][0::2] == self.masks[0][0][0::2] + 4) # noqa: E501\n \"\"\"\n assert border_value is None or border_value == 0, \\\n 'Here border_value is not '\\\n f'used, and defaultly should be None or 0. got {border_value}.'\n if len(self.masks) == 0:\n translated_masks = PolygonMasks([], *out_shape)\n else:\n translated_masks = []\n for poly_per_obj in self.masks:\n translated_poly_per_obj = []\n for p in poly_per_obj:\n p = p.copy()\n if direction == 'horizontal':\n p[0::2] = np.clip(p[0::2] + offset, 0, out_shape[1])\n elif direction == 'vertical':\n p[1::2] = np.clip(p[1::2] + offset, 0, out_shape[0])\n translated_poly_per_obj.append(p)\n translated_masks.append(translated_poly_per_obj)\n translated_masks = PolygonMasks(translated_masks, *out_shape)\n return translated_masks\n\n def shear(self,\n out_shape,\n magnitude,\n direction='horizontal',\n border_value=0,\n interpolation='bilinear'):\n \"\"\"See :func:`BaseInstanceMasks.shear`.\"\"\"\n if len(self.masks) == 0:\n sheared_masks = PolygonMasks([], *out_shape)\n else:\n sheared_masks = []\n if direction == 'horizontal':\n shear_matrix = np.stack([[1, magnitude],\n [0, 1]]).astype(np.float32)\n elif direction == 'vertical':\n shear_matrix = np.stack([[1, 0], [magnitude,\n 1]]).astype(np.float32)\n for poly_per_obj in self.masks:\n sheared_poly = []\n for p in poly_per_obj:\n p = np.stack([p[0::2], p[1::2]], axis=0) # [2, n]\n new_coords = np.matmul(shear_matrix, p) # [2, n]\n new_coords[0, :] = np.clip(new_coords[0, :], 0,\n out_shape[1])\n new_coords[1, :] = np.clip(new_coords[1, :], 0,\n out_shape[0])\n sheared_poly.append(\n new_coords.transpose((1, 0)).reshape(-1))\n sheared_masks.append(sheared_poly)\n sheared_masks = PolygonMasks(sheared_masks, *out_shape)\n return sheared_masks\n\n def rotate(self,\n out_shape,\n angle,\n center=None,\n scale=1.0,\n border_value=0,\n interpolation='bilinear'):\n \"\"\"See :func:`BaseInstanceMasks.rotate`.\"\"\"\n if len(self.masks) == 0:\n rotated_masks = PolygonMasks([], *out_shape)\n else:\n rotated_masks = []\n rotate_matrix = cv2.getRotationMatrix2D(center, -angle, scale)\n for poly_per_obj in self.masks:\n rotated_poly = []\n for p in poly_per_obj:\n p = p.copy()\n coords = np.stack([p[0::2], p[1::2]], axis=1) # [n, 2]\n # pad 1 to convert from format [x, y] to homogeneous\n # coordinates format [x, y, 1]\n coords = np.concatenate(\n (coords, np.ones((coords.shape[0], 1), coords.dtype)),\n axis=1) # [n, 3]\n rotated_coords = np.matmul(\n rotate_matrix[None, :, :],\n coords[:, :, None])[..., 0] # [n, 2, 1] -> [n, 2]\n rotated_coords[:, 0] = np.clip(rotated_coords[:, 0], 0,\n out_shape[1])\n rotated_coords[:, 1] = np.clip(rotated_coords[:, 1], 0,\n out_shape[0])\n rotated_poly.append(rotated_coords.reshape(-1))\n rotated_masks.append(rotated_poly)\n rotated_masks = PolygonMasks(rotated_masks, *out_shape)\n return rotated_masks\n\n def to_bitmap(self):\n \"\"\"convert polygon masks to bitmap masks.\"\"\"\n bitmap_masks = self.to_ndarray()\n return BitmapMasks(bitmap_masks, self.height, self.width)\n\n @property\n def areas(self):\n \"\"\"Compute areas of masks.\n\n This func is modified from `detectron2\n <https://github.com/facebookresearch/detectron2/blob/ffff8acc35ea88ad1cb1806ab0f00b4c1c5dbfd9/detectron2/structures/masks.py#L387>`_.\n The function only works with Polygons using the shoelace formula.\n\n Return:\n ndarray: areas of each instance\n \"\"\" # noqa: W501\n area = []\n for polygons_per_obj in self.masks:\n area_per_obj = 0\n for p in polygons_per_obj:\n area_per_obj += self._polygon_area(p[0::2], p[1::2])\n area.append(area_per_obj)\n return np.asarray(area)\n\n def _polygon_area(self, x, y):\n \"\"\"Compute the area of a component of a polygon.\n\n Using the shoelace formula:\n https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates\n\n Args:\n x (ndarray): x coordinates of the component\n y (ndarray): y coordinates of the component\n\n Return:\n float: the are of the component\n \"\"\" # noqa: 501\n return 0.5 * np.abs(\n np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))\n\n def to_ndarray(self):\n \"\"\"Convert masks to the format of ndarray.\"\"\"\n if len(self.masks) == 0:\n return np.empty((0, self.height, self.width), dtype=np.uint8)\n bitmap_masks = []\n for poly_per_obj in self.masks:\n bitmap_masks.append(\n polygon_to_bitmap(poly_per_obj, self.height, self.width))\n return np.stack(bitmap_masks)\n\n def to_tensor(self, dtype, device):\n \"\"\"See :func:`BaseInstanceMasks.to_tensor`.\"\"\"\n if len(self.masks) == 0:\n return torch.empty((0, self.height, self.width),\n dtype=dtype,\n device=device)\n ndarray_masks = self.to_ndarray()\n return torch.tensor(ndarray_masks, dtype=dtype, device=device)\n\n @classmethod\n def random(cls,\n num_masks=3,\n height=32,\n width=32,\n n_verts=5,\n dtype=np.float32,\n rng=None):\n \"\"\"Generate random polygon masks for demo / testing purposes.\n\n Adapted from [1]_\n\n References:\n .. [1] https://gitlab.kitware.com/computer-vision/kwimage/-/blob/928cae35ca8/kwimage/structs/polygon.py#L379 # noqa: E501\n\n Example:\n >>> from mmdet.data_elements.mask.structures import PolygonMasks\n >>> self = PolygonMasks.random()\n >>> print('self = {}'.format(self))\n \"\"\"\n from mmdet.utils.util_random import ensure_rng\n rng = ensure_rng(rng)\n\n def _gen_polygon(n, irregularity, spikeyness):\n \"\"\"Creates the polygon by sampling points on a circle around the\n centre. Random noise is added by varying the angular spacing\n between sequential points, and by varying the radial distance of\n each point from the centre.\n\n Based on original code by Mike Ounsworth\n\n Args:\n n (int): number of vertices\n irregularity (float): [0,1] indicating how much variance there\n is in the angular spacing of vertices. [0,1] will map to\n [0, 2pi/numberOfVerts]\n spikeyness (float): [0,1] indicating how much variance there is\n in each vertex from the circle of radius aveRadius. [0,1]\n will map to [0, aveRadius]\n\n Returns:\n a list of vertices, in CCW order.\n \"\"\"\n from scipy.stats import truncnorm\n\n # Generate around the unit circle\n cx, cy = (0.0, 0.0)\n radius = 1\n\n tau = np.pi * 2\n\n irregularity = np.clip(irregularity, 0, 1) * 2 * np.pi / n\n spikeyness = np.clip(spikeyness, 1e-9, 1)\n\n # generate n angle steps\n lower = (tau / n) - irregularity\n upper = (tau / n) + irregularity\n angle_steps = rng.uniform(lower, upper, n)\n\n # normalize the steps so that point 0 and point n+1 are the same\n k = angle_steps.sum() / (2 * np.pi)\n angles = (angle_steps / k).cumsum() + rng.uniform(0, tau)\n\n # Convert high and low values to be wrt the standard normal range\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.truncnorm.html\n low = 0\n high = 2 * radius\n mean = radius\n std = spikeyness\n a = (low - mean) / std\n b = (high - mean) / std\n tnorm = truncnorm(a=a, b=b, loc=mean, scale=std)\n\n # now generate the points\n radii = tnorm.rvs(n, random_state=rng)\n x_pts = cx + radii * np.cos(angles)\n y_pts = cy + radii * np.sin(angles)\n\n points = np.hstack([x_pts[:, None], y_pts[:, None]])\n\n # Scale to 0-1 space\n points = points - points.min(axis=0)\n points = points / points.max(axis=0)\n\n # Randomly place within 0-1 space\n points = points * (rng.rand() * .8 + .2)\n min_pt = points.min(axis=0)\n max_pt = points.max(axis=0)\n\n high = (1 - max_pt)\n low = (0 - min_pt)\n offset = (rng.rand(2) * (high - low)) + low\n points = points + offset\n return points\n\n def _order_vertices(verts):\n \"\"\"\n References:\n https://stackoverflow.com/questions/1709283/how-can-i-sort-a-coordinate-list-for-a-rectangle-counterclockwise\n \"\"\"\n mlat = verts.T[0].sum() / len(verts)\n mlng = verts.T[1].sum() / len(verts)\n\n tau = np.pi * 2\n angle = (np.arctan2(mlat - verts.T[0], verts.T[1] - mlng) +\n tau) % tau\n sortx = angle.argsort()\n verts = verts.take(sortx, axis=0)\n return verts\n\n # Generate a random exterior for each requested mask\n masks = []\n for _ in range(num_masks):\n exterior = _order_vertices(_gen_polygon(n_verts, 0.9, 0.9))\n exterior = (exterior * [(width, height)]).astype(dtype)\n masks.append([exterior.ravel()])\n\n self = cls(masks, height, width)\n return self\n\n @classmethod\n def cat(cls: Type[T], masks: Sequence[T]) -> T:\n \"\"\"Concatenate a sequence of masks into one single mask instance.\n\n Args:\n masks (Sequence[PolygonMasks]): A sequence of mask instances.\n\n Returns:\n PolygonMasks: Concatenated mask instance.\n \"\"\"\n assert isinstance(masks, Sequence)\n if len(masks) == 0:\n raise ValueError('masks should not be an empty list.')\n assert all(isinstance(m, cls) for m in masks)\n\n mask_list = list(itertools.chain(*[m.masks for m in masks]))\n return cls(mask_list, masks[0].height, masks[0].width)"},{"identifier":"log_img_scale","path":"mmdet/utils/logger.py","snippet":"def log_img_scale(img_scale, shape_order='hw', skip_square=False):\n \"\"\"Log image size.\n\n Args:\n img_scale (tuple): Image size to be logged.\n shape_order (str, optional): The order of image shape.\n 'hw' for (height, width) and 'wh' for (width, height).\n Defaults to 'hw'.\n skip_square (bool, optional): Whether to skip logging for square\n img_scale. Defaults to False.\n\n Returns:\n bool: Whether to have done logging.\n \"\"\"\n if shape_order == 'hw':\n height, width = img_scale\n elif shape_order == 'wh':\n width, height = img_scale\n else:\n raise ValueError(f'Invalid shape_order {shape_order}.')\n\n if skip_square and (height == width):\n return False\n\n caller = get_caller_name()\n print_log(\n f'image shape: height={height}, width={width} in {caller}',\n logger='current')\n\n return True"}],"string":"[\n {\n \"identifier\": \"TRANSFORMS\",\n \"path\": \"mmdet/registry.py\",\n \"snippet\": \"TRANSFORMS = Registry(\\n 'transform',\\n parent=MMENGINE_TRANSFORMS,\\n locations=['mmdet.datasets.transforms'])\"\n },\n {\n \"identifier\": \"autocast_box_type\",\n \"path\": \"mmdet/structures/bbox/box_type.py\",\n \"snippet\": \"def autocast_box_type(dst_box_type='hbox') -> Callable:\\n \\\"\\\"\\\"A decorator which automatically casts results['gt_bboxes'] to the\\n destination box type.\\n\\n It commenly used in mmdet.datasets.transforms to make the transforms up-\\n compatible with the np.ndarray type of results['gt_bboxes'].\\n\\n The speed of processing of np.ndarray and BaseBoxes data are the same:\\n\\n - np.ndarray: 0.0509 img/s\\n - BaseBoxes: 0.0551 img/s\\n\\n Args:\\n dst_box_type (str): Destination box type.\\n \\\"\\\"\\\"\\n _, box_type_cls = get_box_type(dst_box_type)\\n\\n def decorator(func: Callable) -> Callable:\\n\\n def wrapper(self, results: dict, *args, **kwargs) -> dict:\\n if ('gt_bboxes' not in results\\n or isinstance(results['gt_bboxes'], BaseBoxes)):\\n return func(self, results)\\n elif isinstance(results['gt_bboxes'], np.ndarray):\\n results['gt_bboxes'] = box_type_cls(\\n results['gt_bboxes'], clone=False)\\n if 'mix_results' in results:\\n for res in results['mix_results']:\\n if isinstance(res['gt_bboxes'], np.ndarray):\\n res['gt_bboxes'] = box_type_cls(\\n res['gt_bboxes'], clone=False)\\n\\n _results = func(self, results, *args, **kwargs)\\n\\n # In some cases, the function will process gt_bboxes in-place\\n # Simultaneously convert inputting and outputting gt_bboxes\\n # back to np.ndarray\\n if isinstance(_results, dict) and 'gt_bboxes' in _results:\\n if isinstance(_results['gt_bboxes'], BaseBoxes):\\n _results['gt_bboxes'] = _results['gt_bboxes'].numpy()\\n if isinstance(results['gt_bboxes'], BaseBoxes):\\n results['gt_bboxes'] = results['gt_bboxes'].numpy()\\n return _results\\n else:\\n raise TypeError(\\n \\\"auto_box_type requires results['gt_bboxes'] to \\\"\\n 'be BaseBoxes or np.ndarray, but got '\\n f\\\"{type(results['gt_bboxes'])}\\\")\\n\\n return wrapper\\n\\n return decorator\"\n },\n {\n \"identifier\": \"HorizontalBoxes\",\n \"path\": \"mmdet/structures/bbox/horizontal_boxes.py\",\n \"snippet\": \"class HorizontalBoxes(BaseBoxes):\\n \\\"\\\"\\\"The horizontal box class used in MMDetection by default.\\n\\n The ``box_dim`` of ``HorizontalBoxes`` is 4, which means the length of\\n the last dimension of the data should be 4. Two modes of box data are\\n supported in ``HorizontalBoxes``:\\n\\n - 'xyxy': Each row of data indicates (x1, y1, x2, y2), which are the\\n coordinates of the left-top and right-bottom points.\\n - 'cxcywh': Each row of data indicates (x, y, w, h), where (x, y) are the\\n coordinates of the box centers and (w, h) are the width and height.\\n\\n ``HorizontalBoxes`` only restores 'xyxy' mode of data. If the the data is\\n in 'cxcywh' mode, users need to input ``in_mode='cxcywh'`` and The code\\n will convert the 'cxcywh' data to 'xyxy' automatically.\\n\\n Args:\\n data (Tensor or np.ndarray or Sequence): The box data with shape of\\n (..., 4).\\n dtype (torch.dtype, Optional): data type of boxes. Defaults to None.\\n device (str or torch.device, Optional): device of boxes.\\n Default to None.\\n clone (bool): Whether clone ``boxes`` or not. Defaults to True.\\n mode (str, Optional): the mode of boxes. If it is 'cxcywh', the\\n `data` will be converted to 'xyxy' mode. Defaults to None.\\n \\\"\\\"\\\"\\n\\n box_dim: int = 4\\n\\n def __init__(self,\\n data: Union[Tensor, np.ndarray],\\n dtype: torch.dtype = None,\\n device: DeviceType = None,\\n clone: bool = True,\\n in_mode: Optional[str] = None) -> None:\\n super().__init__(data=data, dtype=dtype, device=device, clone=clone)\\n if isinstance(in_mode, str):\\n if in_mode not in ('xyxy', 'cxcywh'):\\n raise ValueError(f'Get invalid mode {in_mode}.')\\n if in_mode == 'cxcywh':\\n self.tensor = self.cxcywh_to_xyxy(self.tensor)\\n\\n @staticmethod\\n def cxcywh_to_xyxy(boxes: Tensor) -> Tensor:\\n \\\"\\\"\\\"Convert box coordinates from (cx, cy, w, h) to (x1, y1, x2, y2).\\n\\n Args:\\n boxes (Tensor): cxcywh boxes tensor with shape of (..., 4).\\n\\n Returns:\\n Tensor: xyxy boxes tensor with shape of (..., 4).\\n \\\"\\\"\\\"\\n ctr, wh = boxes.split((2, 2), dim=-1)\\n return torch.cat([(ctr - wh / 2), (ctr + wh / 2)], dim=-1)\\n\\n @staticmethod\\n def xyxy_to_cxcywh(boxes: Tensor) -> Tensor:\\n \\\"\\\"\\\"Convert box coordinates from (x1, y1, x2, y2) to (cx, cy, w, h).\\n\\n Args:\\n boxes (Tensor): xyxy boxes tensor with shape of (..., 4).\\n\\n Returns:\\n Tensor: cxcywh boxes tensor with shape of (..., 4).\\n \\\"\\\"\\\"\\n xy1, xy2 = boxes.split((2, 2), dim=-1)\\n return torch.cat([(xy2 + xy1) / 2, (xy2 - xy1)], dim=-1)\\n\\n @property\\n def cxcywh(self) -> Tensor:\\n \\\"\\\"\\\"Return a tensor representing the cxcywh boxes.\\\"\\\"\\\"\\n return self.xyxy_to_cxcywh(self.tensor)\\n\\n @property\\n def centers(self) -> Tensor:\\n \\\"\\\"\\\"Return a tensor representing the centers of boxes.\\\"\\\"\\\"\\n boxes = self.tensor\\n return (boxes[..., :2] + boxes[..., 2:]) / 2\\n\\n @property\\n def areas(self) -> Tensor:\\n \\\"\\\"\\\"Return a tensor representing the areas of boxes.\\\"\\\"\\\"\\n boxes = self.tensor\\n return (boxes[..., 2] - boxes[..., 0]) * (\\n boxes[..., 3] - boxes[..., 1])\\n\\n @property\\n def widths(self) -> Tensor:\\n \\\"\\\"\\\"Return a tensor representing the widths of boxes.\\\"\\\"\\\"\\n boxes = self.tensor\\n return boxes[..., 2] - boxes[..., 0]\\n\\n @property\\n def heights(self) -> Tensor:\\n \\\"\\\"\\\"Return a tensor representing the heights of boxes.\\\"\\\"\\\"\\n boxes = self.tensor\\n return boxes[..., 3] - boxes[..., 1]\\n\\n def flip_(self,\\n img_shape: Tuple[int, int],\\n direction: str = 'horizontal') -> None:\\n \\\"\\\"\\\"Flip boxes horizontally or vertically in-place.\\n\\n Args:\\n img_shape (Tuple[int, int]): A tuple of image height and width.\\n direction (str): Flip direction, options are \\\"horizontal\\\",\\n \\\"vertical\\\" and \\\"diagonal\\\". Defaults to \\\"horizontal\\\"\\n \\\"\\\"\\\"\\n assert direction in ['horizontal', 'vertical', 'diagonal']\\n flipped = self.tensor\\n boxes = flipped.clone()\\n if direction == 'horizontal':\\n flipped[..., 0] = img_shape[1] - boxes[..., 2]\\n flipped[..., 2] = img_shape[1] - boxes[..., 0]\\n elif direction == 'vertical':\\n flipped[..., 1] = img_shape[0] - boxes[..., 3]\\n flipped[..., 3] = img_shape[0] - boxes[..., 1]\\n else:\\n flipped[..., 0] = img_shape[1] - boxes[..., 2]\\n flipped[..., 1] = img_shape[0] - boxes[..., 3]\\n flipped[..., 2] = img_shape[1] - boxes[..., 0]\\n flipped[..., 3] = img_shape[0] - boxes[..., 1]\\n\\n def translate_(self, distances: Tuple[float, float]) -> None:\\n \\\"\\\"\\\"Translate boxes in-place.\\n\\n Args:\\n distances (Tuple[float, float]): translate distances. The first\\n is horizontal distance and the second is vertical distance.\\n \\\"\\\"\\\"\\n boxes = self.tensor\\n assert len(distances) == 2\\n self.tensor = boxes + boxes.new_tensor(distances).repeat(2)\\n\\n def clip_(self, img_shape: Tuple[int, int]) -> None:\\n \\\"\\\"\\\"Clip boxes according to the image shape in-place.\\n\\n Args:\\n img_shape (Tuple[int, int]): A tuple of image height and width.\\n \\\"\\\"\\\"\\n boxes = self.tensor\\n boxes[..., 0::2] = boxes[..., 0::2].clamp(0, img_shape[1])\\n boxes[..., 1::2] = boxes[..., 1::2].clamp(0, img_shape[0])\\n\\n def rotate_(self, center: Tuple[float, float], angle: float) -> None:\\n \\\"\\\"\\\"Rotate all boxes in-place.\\n\\n Args:\\n center (Tuple[float, float]): Rotation origin.\\n angle (float): Rotation angle represented in degrees. Positive\\n values mean clockwise rotation.\\n \\\"\\\"\\\"\\n boxes = self.tensor\\n rotation_matrix = boxes.new_tensor(\\n cv2.getRotationMatrix2D(center, -angle, 1))\\n\\n corners = self.hbox2corner(boxes)\\n corners = torch.cat(\\n [corners, corners.new_ones(*corners.shape[:-1], 1)], dim=-1)\\n corners_T = torch.transpose(corners, -1, -2)\\n corners_T = torch.matmul(rotation_matrix, corners_T)\\n corners = torch.transpose(corners_T, -1, -2)\\n self.tensor = self.corner2hbox(corners)\\n\\n def project_(self, homography_matrix: Union[Tensor, np.ndarray]) -> None:\\n \\\"\\\"\\\"Geometric transformat boxes in-place.\\n\\n Args:\\n homography_matrix (Tensor or np.ndarray]):\\n Shape (3, 3) for geometric transformation.\\n \\\"\\\"\\\"\\n boxes = self.tensor\\n if isinstance(homography_matrix, np.ndarray):\\n homography_matrix = boxes.new_tensor(homography_matrix)\\n corners = self.hbox2corner(boxes)\\n corners = torch.cat(\\n [corners, corners.new_ones(*corners.shape[:-1], 1)], dim=-1)\\n corners_T = torch.transpose(corners, -1, -2)\\n corners_T = torch.matmul(homography_matrix, corners_T)\\n corners = torch.transpose(corners_T, -1, -2)\\n # Convert to homogeneous coordinates by normalization\\n corners = corners[..., :2] / corners[..., 2:3]\\n self.tensor = self.corner2hbox(corners)\\n\\n @staticmethod\\n def hbox2corner(boxes: Tensor) -> Tensor:\\n \\\"\\\"\\\"Convert box coordinates from (x1, y1, x2, y2) to corners ((x1, y1),\\n (x2, y1), (x1, y2), (x2, y2)).\\n\\n Args:\\n boxes (Tensor): Horizontal box tensor with shape of (..., 4).\\n\\n Returns:\\n Tensor: Corner tensor with shape of (..., 4, 2).\\n \\\"\\\"\\\"\\n x1, y1, x2, y2 = torch.split(boxes, 1, dim=-1)\\n corners = torch.cat([x1, y1, x2, y1, x1, y2, x2, y2], dim=-1)\\n return corners.reshape(*corners.shape[:-1], 4, 2)\\n\\n @staticmethod\\n def corner2hbox(corners: Tensor) -> Tensor:\\n \\\"\\\"\\\"Convert box coordinates from corners ((x1, y1), (x2, y1), (x1, y2),\\n (x2, y2)) to (x1, y1, x2, y2).\\n\\n Args:\\n corners (Tensor): Corner tensor with shape of (..., 4, 2).\\n\\n Returns:\\n Tensor: Horizontal box tensor with shape of (..., 4).\\n \\\"\\\"\\\"\\n if corners.numel() == 0:\\n return corners.new_zeros((0, 4))\\n min_xy = corners.min(dim=-2)[0]\\n max_xy = corners.max(dim=-2)[0]\\n return torch.cat([min_xy, max_xy], dim=-1)\\n\\n def rescale_(self, scale_factor: Tuple[float, float]) -> None:\\n \\\"\\\"\\\"Rescale boxes w.r.t. rescale_factor in-place.\\n\\n Note:\\n Both ``rescale_`` and ``resize_`` will enlarge or shrink boxes\\n w.r.t ``scale_facotr``. The difference is that ``resize_`` only\\n changes the width and the height of boxes, but ``rescale_`` also\\n rescales the box centers simultaneously.\\n\\n Args:\\n scale_factor (Tuple[float, float]): factors for scaling boxes.\\n The length should be 2.\\n \\\"\\\"\\\"\\n boxes = self.tensor\\n assert len(scale_factor) == 2\\n scale_factor = boxes.new_tensor(scale_factor).repeat(2)\\n self.tensor = boxes * scale_factor\\n\\n def resize_(self, scale_factor: Tuple[float, float]) -> None:\\n \\\"\\\"\\\"Resize the box width and height w.r.t scale_factor in-place.\\n\\n Note:\\n Both ``rescale_`` and ``resize_`` will enlarge or shrink boxes\\n w.r.t ``scale_facotr``. The difference is that ``resize_`` only\\n changes the width and the height of boxes, but ``rescale_`` also\\n rescales the box centers simultaneously.\\n\\n Args:\\n scale_factor (Tuple[float, float]): factors for scaling box\\n shapes. The length should be 2.\\n \\\"\\\"\\\"\\n boxes = self.tensor\\n assert len(scale_factor) == 2\\n ctrs = (boxes[..., 2:] + boxes[..., :2]) / 2\\n wh = boxes[..., 2:] - boxes[..., :2]\\n scale_factor = boxes.new_tensor(scale_factor)\\n wh = wh * scale_factor\\n xy1 = ctrs - 0.5 * wh\\n xy2 = ctrs + 0.5 * wh\\n self.tensor = torch.cat([xy1, xy2], dim=-1)\\n\\n def is_inside(self,\\n img_shape: Tuple[int, int],\\n all_inside: bool = False,\\n allowed_border: int = 0) -> BoolTensor:\\n \\\"\\\"\\\"Find boxes inside the image.\\n\\n Args:\\n img_shape (Tuple[int, int]): A tuple of image height and width.\\n all_inside (bool): Whether the boxes are all inside the image or\\n part inside the image. Defaults to False.\\n allowed_border (int): Boxes that extend beyond the image shape\\n boundary by more than ``allowed_border`` are considered\\n \\\"outside\\\" Defaults to 0.\\n Returns:\\n BoolTensor: A BoolTensor indicating whether the box is inside\\n the image. Assuming the original boxes have shape (m, n, 4),\\n the output has shape (m, n).\\n \\\"\\\"\\\"\\n img_h, img_w = img_shape\\n boxes = self.tensor\\n if all_inside:\\n return (boxes[:, 0] >= -allowed_border) & \\\\\\n (boxes[:, 1] >= -allowed_border) & \\\\\\n (boxes[:, 2] < img_w + allowed_border) & \\\\\\n (boxes[:, 3] < img_h + allowed_border)\\n else:\\n return (boxes[..., 0] < img_w + allowed_border) & \\\\\\n (boxes[..., 1] < img_h + allowed_border) & \\\\\\n (boxes[..., 2] > -allowed_border) & \\\\\\n (boxes[..., 3] > -allowed_border)\\n\\n def find_inside_points(self,\\n points: Tensor,\\n is_aligned: bool = False) -> BoolTensor:\\n \\\"\\\"\\\"Find inside box points. Boxes dimension must be 2.\\n\\n Args:\\n points (Tensor): Points coordinates. Has shape of (m, 2).\\n is_aligned (bool): Whether ``points`` has been aligned with boxes\\n or not. If True, the length of boxes and ``points`` should be\\n the same. Defaults to False.\\n\\n Returns:\\n BoolTensor: A BoolTensor indicating whether a point is inside\\n boxes. Assuming the boxes has shape of (n, 4), if ``is_aligned``\\n is False. The index has shape of (m, n). If ``is_aligned`` is\\n True, m should be equal to n and the index has shape of (m, ).\\n \\\"\\\"\\\"\\n boxes = self.tensor\\n assert boxes.dim() == 2, 'boxes dimension must be 2.'\\n\\n if not is_aligned:\\n boxes = boxes[None, :, :]\\n points = points[:, None, :]\\n else:\\n assert boxes.size(0) == points.size(0)\\n\\n x_min, y_min, x_max, y_max = boxes.unbind(dim=-1)\\n return (points[..., 0] >= x_min) & (points[..., 0] <= x_max) & \\\\\\n (points[..., 1] >= y_min) & (points[..., 1] <= y_max)\\n\\n def create_masks(self, img_shape: Tuple[int, int]) -> BitmapMasks:\\n \\\"\\\"\\\"\\n Args:\\n img_shape (Tuple[int, int]): A tuple of image height and width.\\n\\n Returns:\\n :obj:`BitmapMasks`: Converted masks\\n \\\"\\\"\\\"\\n img_h, img_w = img_shape\\n boxes = self.tensor\\n\\n xmin, ymin = boxes[:, 0:1], boxes[:, 1:2]\\n xmax, ymax = boxes[:, 2:3], boxes[:, 3:4]\\n gt_masks = np.zeros((len(boxes), img_h, img_w), dtype=np.uint8)\\n for i in range(len(boxes)):\\n gt_masks[i,\\n int(ymin[i]):int(ymax[i]),\\n int(xmin[i]):int(xmax[i])] = 1\\n return BitmapMasks(gt_masks, img_h, img_w)\\n\\n @staticmethod\\n def overlaps(boxes1: BaseBoxes,\\n boxes2: BaseBoxes,\\n mode: str = 'iou',\\n is_aligned: bool = False,\\n eps: float = 1e-6) -> Tensor:\\n \\\"\\\"\\\"Calculate overlap between two set of boxes with their types\\n converted to ``HorizontalBoxes``.\\n\\n Args:\\n boxes1 (:obj:`BaseBoxes`): BaseBoxes with shape of (m, box_dim)\\n or empty.\\n boxes2 (:obj:`BaseBoxes`): BaseBoxes with shape of (n, box_dim)\\n or empty.\\n mode (str): \\\"iou\\\" (intersection over union), \\\"iof\\\" (intersection\\n over foreground). Defaults to \\\"iou\\\".\\n is_aligned (bool): If True, then m and n must be equal. Defaults\\n to False.\\n eps (float): A value added to the denominator for numerical\\n stability. Defaults to 1e-6.\\n\\n Returns:\\n Tensor: shape (m, n) if ``is_aligned`` is False else shape (m,)\\n \\\"\\\"\\\"\\n boxes1 = boxes1.convert_to('hbox')\\n boxes2 = boxes2.convert_to('hbox')\\n return bbox_overlaps(\\n boxes1.tensor,\\n boxes2.tensor,\\n mode=mode,\\n is_aligned=is_aligned,\\n eps=eps)\\n\\n @staticmethod\\n def from_instance_masks(masks: MaskType) -> 'HorizontalBoxes':\\n \\\"\\\"\\\"Create horizontal boxes from instance masks.\\n\\n Args:\\n masks (:obj:`BitmapMasks` or :obj:`PolygonMasks`): BitmapMasks or\\n PolygonMasks instance with length of n.\\n\\n Returns:\\n :obj:`HorizontalBoxes`: Converted boxes with shape of (n, 4).\\n \\\"\\\"\\\"\\n num_masks = len(masks)\\n boxes = np.zeros((num_masks, 4), dtype=np.float32)\\n if isinstance(masks, BitmapMasks):\\n x_any = masks.masks.any(axis=1)\\n y_any = masks.masks.any(axis=2)\\n for idx in range(num_masks):\\n x = np.where(x_any[idx, :])[0]\\n y = np.where(y_any[idx, :])[0]\\n if len(x) > 0 and len(y) > 0:\\n # use +1 for x_max and y_max so that the right and bottom\\n # boundary of instance masks are fully included by the box\\n boxes[idx, :] = np.array(\\n [x[0], y[0], x[-1] + 1, y[-1] + 1], dtype=np.float32)\\n elif isinstance(masks, PolygonMasks):\\n for idx, poly_per_obj in enumerate(masks.masks):\\n # simply use a number that is big enough for comparison with\\n # coordinates\\n xy_min = np.array([masks.width * 2, masks.height * 2],\\n dtype=np.float32)\\n xy_max = np.zeros(2, dtype=np.float32)\\n for p in poly_per_obj:\\n xy = np.array(p).reshape(-1, 2).astype(np.float32)\\n xy_min = np.minimum(xy_min, np.min(xy, axis=0))\\n xy_max = np.maximum(xy_max, np.max(xy, axis=0))\\n boxes[idx, :2] = xy_min\\n boxes[idx, 2:] = xy_max\\n else:\\n raise TypeError(\\n '`masks` must be `BitmapMasks` or `PolygonMasks`, '\\n f'but got {type(masks)}.')\\n return HorizontalBoxes(boxes)\"\n },\n {\n \"identifier\": \"BitmapMasks\",\n \"path\": \"mmdet/structures/mask/structures.py\",\n \"snippet\": \"class BitmapMasks(BaseInstanceMasks):\\n \\\"\\\"\\\"This class represents masks in the form of bitmaps.\\n\\n Args:\\n masks (ndarray): ndarray of masks in shape (N, H, W), where N is\\n the number of objects.\\n height (int): height of masks\\n width (int): width of masks\\n\\n Example:\\n >>> from mmdet.data_elements.mask.structures import * # NOQA\\n >>> num_masks, H, W = 3, 32, 32\\n >>> rng = np.random.RandomState(0)\\n >>> masks = (rng.rand(num_masks, H, W) > 0.1).astype(np.int64)\\n >>> self = BitmapMasks(masks, height=H, width=W)\\n\\n >>> # demo crop_and_resize\\n >>> num_boxes = 5\\n >>> bboxes = np.array([[0, 0, 30, 10.0]] * num_boxes)\\n >>> out_shape = (14, 14)\\n >>> inds = torch.randint(0, len(self), size=(num_boxes,))\\n >>> device = 'cpu'\\n >>> interpolation = 'bilinear'\\n >>> new = self.crop_and_resize(\\n ... bboxes, out_shape, inds, device, interpolation)\\n >>> assert len(new) == num_boxes\\n >>> assert new.height, new.width == out_shape\\n \\\"\\\"\\\"\\n\\n def __init__(self, masks, height, width):\\n self.height = height\\n self.width = width\\n if len(masks) == 0:\\n self.masks = np.empty((0, self.height, self.width), dtype=np.uint8)\\n else:\\n assert isinstance(masks, (list, np.ndarray))\\n if isinstance(masks, list):\\n assert isinstance(masks[0], np.ndarray)\\n assert masks[0].ndim == 2 # (H, W)\\n else:\\n assert masks.ndim == 3 # (N, H, W)\\n\\n self.masks = np.stack(masks).reshape(-1, height, width)\\n assert self.masks.shape[1] == self.height\\n assert self.masks.shape[2] == self.width\\n\\n def __getitem__(self, index):\\n \\\"\\\"\\\"Index the BitmapMask.\\n\\n Args:\\n index (int | ndarray): Indices in the format of integer or ndarray.\\n\\n Returns:\\n :obj:`BitmapMasks`: Indexed bitmap masks.\\n \\\"\\\"\\\"\\n masks = self.masks[index].reshape(-1, self.height, self.width)\\n return BitmapMasks(masks, self.height, self.width)\\n\\n def __iter__(self):\\n return iter(self.masks)\\n\\n def __repr__(self):\\n s = self.__class__.__name__ + '('\\n s += f'num_masks={len(self.masks)}, '\\n s += f'height={self.height}, '\\n s += f'width={self.width})'\\n return s\\n\\n def __len__(self):\\n \\\"\\\"\\\"Number of masks.\\\"\\\"\\\"\\n return len(self.masks)\\n\\n def rescale(self, scale, interpolation='nearest'):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.rescale`.\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n new_w, new_h = mmcv.rescale_size((self.width, self.height), scale)\\n rescaled_masks = np.empty((0, new_h, new_w), dtype=np.uint8)\\n else:\\n rescaled_masks = np.stack([\\n mmcv.imrescale(mask, scale, interpolation=interpolation)\\n for mask in self.masks\\n ])\\n height, width = rescaled_masks.shape[1:]\\n return BitmapMasks(rescaled_masks, height, width)\\n\\n def resize(self, out_shape, interpolation='nearest'):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.resize`.\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n resized_masks = np.empty((0, *out_shape), dtype=np.uint8)\\n else:\\n resized_masks = np.stack([\\n mmcv.imresize(\\n mask, out_shape[::-1], interpolation=interpolation)\\n for mask in self.masks\\n ])\\n return BitmapMasks(resized_masks, *out_shape)\\n\\n def flip(self, flip_direction='horizontal'):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.flip`.\\\"\\\"\\\"\\n assert flip_direction in ('horizontal', 'vertical', 'diagonal')\\n\\n if len(self.masks) == 0:\\n flipped_masks = self.masks\\n else:\\n flipped_masks = np.stack([\\n mmcv.imflip(mask, direction=flip_direction)\\n for mask in self.masks\\n ])\\n return BitmapMasks(flipped_masks, self.height, self.width)\\n\\n def pad(self, out_shape, pad_val=0):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.pad`.\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n padded_masks = np.empty((0, *out_shape), dtype=np.uint8)\\n else:\\n padded_masks = np.stack([\\n mmcv.impad(mask, shape=out_shape, pad_val=pad_val)\\n for mask in self.masks\\n ])\\n return BitmapMasks(padded_masks, *out_shape)\\n\\n def crop(self, bbox):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.crop`.\\\"\\\"\\\"\\n assert isinstance(bbox, np.ndarray)\\n assert bbox.ndim == 1\\n\\n # clip the boundary\\n bbox = bbox.copy()\\n bbox[0::2] = np.clip(bbox[0::2], 0, self.width)\\n bbox[1::2] = np.clip(bbox[1::2], 0, self.height)\\n x1, y1, x2, y2 = bbox\\n w = np.maximum(x2 - x1, 1)\\n h = np.maximum(y2 - y1, 1)\\n\\n if len(self.masks) == 0:\\n cropped_masks = np.empty((0, h, w), dtype=np.uint8)\\n else:\\n cropped_masks = self.masks[:, y1:y1 + h, x1:x1 + w]\\n return BitmapMasks(cropped_masks, h, w)\\n\\n def crop_and_resize(self,\\n bboxes,\\n out_shape,\\n inds,\\n device='cpu',\\n interpolation='bilinear',\\n binarize=True):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.crop_and_resize`.\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n empty_masks = np.empty((0, *out_shape), dtype=np.uint8)\\n return BitmapMasks(empty_masks, *out_shape)\\n\\n # convert bboxes to tensor\\n if isinstance(bboxes, np.ndarray):\\n bboxes = torch.from_numpy(bboxes).to(device=device)\\n if isinstance(inds, np.ndarray):\\n inds = torch.from_numpy(inds).to(device=device)\\n\\n num_bbox = bboxes.shape[0]\\n fake_inds = torch.arange(\\n num_bbox, device=device).to(dtype=bboxes.dtype)[:, None]\\n rois = torch.cat([fake_inds, bboxes], dim=1) # Nx5\\n rois = rois.to(device=device)\\n if num_bbox > 0:\\n gt_masks_th = torch.from_numpy(self.masks).to(device).index_select(\\n 0, inds).to(dtype=rois.dtype)\\n targets = roi_align(gt_masks_th[:, None, :, :], rois, out_shape,\\n 1.0, 0, 'avg', True).squeeze(1)\\n if binarize:\\n resized_masks = (targets >= 0.5).cpu().numpy()\\n else:\\n resized_masks = targets.cpu().numpy()\\n else:\\n resized_masks = []\\n return BitmapMasks(resized_masks, *out_shape)\\n\\n def expand(self, expanded_h, expanded_w, top, left):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.expand`.\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n expanded_mask = np.empty((0, expanded_h, expanded_w),\\n dtype=np.uint8)\\n else:\\n expanded_mask = np.zeros((len(self), expanded_h, expanded_w),\\n dtype=np.uint8)\\n expanded_mask[:, top:top + self.height,\\n left:left + self.width] = self.masks\\n return BitmapMasks(expanded_mask, expanded_h, expanded_w)\\n\\n def translate(self,\\n out_shape,\\n offset,\\n direction='horizontal',\\n border_value=0,\\n interpolation='bilinear'):\\n \\\"\\\"\\\"Translate the BitmapMasks.\\n\\n Args:\\n out_shape (tuple[int]): Shape for output mask, format (h, w).\\n offset (int | float): The offset for translate.\\n direction (str): The translate direction, either \\\"horizontal\\\"\\n or \\\"vertical\\\".\\n border_value (int | float): Border value. Default 0 for masks.\\n interpolation (str): Same as :func:`mmcv.imtranslate`.\\n\\n Returns:\\n BitmapMasks: Translated BitmapMasks.\\n\\n Example:\\n >>> from mmdet.data_elements.mask.structures import BitmapMasks\\n >>> self = BitmapMasks.random(dtype=np.uint8)\\n >>> out_shape = (32, 32)\\n >>> offset = 4\\n >>> direction = 'horizontal'\\n >>> border_value = 0\\n >>> interpolation = 'bilinear'\\n >>> # Note, There seem to be issues when:\\n >>> # * the mask dtype is not supported by cv2.AffineWarp\\n >>> new = self.translate(out_shape, offset, direction,\\n >>> border_value, interpolation)\\n >>> assert len(new) == len(self)\\n >>> assert new.height, new.width == out_shape\\n \\\"\\\"\\\"\\n if len(self.masks) == 0:\\n translated_masks = np.empty((0, *out_shape), dtype=np.uint8)\\n else:\\n masks = self.masks\\n if masks.shape[-2:] != out_shape:\\n empty_masks = np.zeros((masks.shape[0], *out_shape),\\n dtype=masks.dtype)\\n min_h = min(out_shape[0], masks.shape[1])\\n min_w = min(out_shape[1], masks.shape[2])\\n empty_masks[:, :min_h, :min_w] = masks[:, :min_h, :min_w]\\n masks = empty_masks\\n translated_masks = mmcv.imtranslate(\\n masks.transpose((1, 2, 0)),\\n offset,\\n direction,\\n border_value=border_value,\\n interpolation=interpolation)\\n if translated_masks.ndim == 2:\\n translated_masks = translated_masks[:, :, None]\\n translated_masks = translated_masks.transpose(\\n (2, 0, 1)).astype(self.masks.dtype)\\n return BitmapMasks(translated_masks, *out_shape)\\n\\n def shear(self,\\n out_shape,\\n magnitude,\\n direction='horizontal',\\n border_value=0,\\n interpolation='bilinear'):\\n \\\"\\\"\\\"Shear the BitmapMasks.\\n\\n Args:\\n out_shape (tuple[int]): Shape for output mask, format (h, w).\\n magnitude (int | float): The magnitude used for shear.\\n direction (str): The shear direction, either \\\"horizontal\\\"\\n or \\\"vertical\\\".\\n border_value (int | tuple[int]): Value used in case of a\\n constant border.\\n interpolation (str): Same as in :func:`mmcv.imshear`.\\n\\n Returns:\\n BitmapMasks: The sheared masks.\\n \\\"\\\"\\\"\\n if len(self.masks) == 0:\\n sheared_masks = np.empty((0, *out_shape), dtype=np.uint8)\\n else:\\n sheared_masks = mmcv.imshear(\\n self.masks.transpose((1, 2, 0)),\\n magnitude,\\n direction,\\n border_value=border_value,\\n interpolation=interpolation)\\n if sheared_masks.ndim == 2:\\n sheared_masks = sheared_masks[:, :, None]\\n sheared_masks = sheared_masks.transpose(\\n (2, 0, 1)).astype(self.masks.dtype)\\n return BitmapMasks(sheared_masks, *out_shape)\\n\\n def rotate(self,\\n out_shape,\\n angle,\\n center=None,\\n scale=1.0,\\n border_value=0,\\n interpolation='bilinear'):\\n \\\"\\\"\\\"Rotate the BitmapMasks.\\n\\n Args:\\n out_shape (tuple[int]): Shape for output mask, format (h, w).\\n angle (int | float): Rotation angle in degrees. Positive values\\n mean counter-clockwise rotation.\\n center (tuple[float], optional): Center point (w, h) of the\\n rotation in source image. If not specified, the center of\\n the image will be used.\\n scale (int | float): Isotropic scale factor.\\n border_value (int | float): Border value. Default 0 for masks.\\n interpolation (str): Same as in :func:`mmcv.imrotate`.\\n\\n Returns:\\n BitmapMasks: Rotated BitmapMasks.\\n \\\"\\\"\\\"\\n if len(self.masks) == 0:\\n rotated_masks = np.empty((0, *out_shape), dtype=self.masks.dtype)\\n else:\\n rotated_masks = mmcv.imrotate(\\n self.masks.transpose((1, 2, 0)),\\n angle,\\n center=center,\\n scale=scale,\\n border_value=border_value,\\n interpolation=interpolation)\\n if rotated_masks.ndim == 2:\\n # case when only one mask, (h, w)\\n rotated_masks = rotated_masks[:, :, None] # (h, w, 1)\\n rotated_masks = rotated_masks.transpose(\\n (2, 0, 1)).astype(self.masks.dtype)\\n return BitmapMasks(rotated_masks, *out_shape)\\n\\n @property\\n def areas(self):\\n \\\"\\\"\\\"See :py:attr:`BaseInstanceMasks.areas`.\\\"\\\"\\\"\\n return self.masks.sum((1, 2))\\n\\n def to_ndarray(self):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.to_ndarray`.\\\"\\\"\\\"\\n return self.masks\\n\\n def to_tensor(self, dtype, device):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.to_tensor`.\\\"\\\"\\\"\\n return torch.tensor(self.masks, dtype=dtype, device=device)\\n\\n @classmethod\\n def random(cls,\\n num_masks=3,\\n height=32,\\n width=32,\\n dtype=np.uint8,\\n rng=None):\\n \\\"\\\"\\\"Generate random bitmap masks for demo / testing purposes.\\n\\n Example:\\n >>> from mmdet.data_elements.mask.structures import BitmapMasks\\n >>> self = BitmapMasks.random()\\n >>> print('self = {}'.format(self))\\n self = BitmapMasks(num_masks=3, height=32, width=32)\\n \\\"\\\"\\\"\\n from mmdet.utils.util_random import ensure_rng\\n rng = ensure_rng(rng)\\n masks = (rng.rand(num_masks, height, width) > 0.1).astype(dtype)\\n self = cls(masks, height=height, width=width)\\n return self\\n\\n @classmethod\\n def cat(cls: Type[T], masks: Sequence[T]) -> T:\\n \\\"\\\"\\\"Concatenate a sequence of masks into one single mask instance.\\n\\n Args:\\n masks (Sequence[BitmapMasks]): A sequence of mask instances.\\n\\n Returns:\\n BitmapMasks: Concatenated mask instance.\\n \\\"\\\"\\\"\\n assert isinstance(masks, Sequence)\\n if len(masks) == 0:\\n raise ValueError('masks should not be an empty list.')\\n assert all(isinstance(m, cls) for m in masks)\\n\\n mask_array = np.concatenate([m.masks for m in masks], axis=0)\\n return cls(mask_array, *mask_array.shape[1:])\"\n },\n {\n \"identifier\": \"PolygonMasks\",\n \"path\": \"mmdet/structures/mask/structures.py\",\n \"snippet\": \"class PolygonMasks(BaseInstanceMasks):\\n \\\"\\\"\\\"This class represents masks in the form of polygons.\\n\\n Polygons is a list of three levels. The first level of the list\\n corresponds to objects, the second level to the polys that compose the\\n object, the third level to the poly coordinates\\n\\n Args:\\n masks (list[list[ndarray]]): The first level of the list\\n corresponds to objects, the second level to the polys that\\n compose the object, the third level to the poly coordinates\\n height (int): height of masks\\n width (int): width of masks\\n\\n Example:\\n >>> from mmdet.data_elements.mask.structures import * # NOQA\\n >>> masks = [\\n >>> [ np.array([0, 0, 10, 0, 10, 10., 0, 10, 0, 0]) ]\\n >>> ]\\n >>> height, width = 16, 16\\n >>> self = PolygonMasks(masks, height, width)\\n\\n >>> # demo translate\\n >>> new = self.translate((16, 16), 4., direction='horizontal')\\n >>> assert np.all(new.masks[0][0][1::2] == masks[0][0][1::2])\\n >>> assert np.all(new.masks[0][0][0::2] == masks[0][0][0::2] + 4)\\n\\n >>> # demo crop_and_resize\\n >>> num_boxes = 3\\n >>> bboxes = np.array([[0, 0, 30, 10.0]] * num_boxes)\\n >>> out_shape = (16, 16)\\n >>> inds = torch.randint(0, len(self), size=(num_boxes,))\\n >>> device = 'cpu'\\n >>> interpolation = 'bilinear'\\n >>> new = self.crop_and_resize(\\n ... bboxes, out_shape, inds, device, interpolation)\\n >>> assert len(new) == num_boxes\\n >>> assert new.height, new.width == out_shape\\n \\\"\\\"\\\"\\n\\n def __init__(self, masks, height, width):\\n assert isinstance(masks, list)\\n if len(masks) > 0:\\n assert isinstance(masks[0], list)\\n assert isinstance(masks[0][0], np.ndarray)\\n\\n self.height = height\\n self.width = width\\n self.masks = masks\\n\\n def __getitem__(self, index):\\n \\\"\\\"\\\"Index the polygon masks.\\n\\n Args:\\n index (ndarray | List): The indices.\\n\\n Returns:\\n :obj:`PolygonMasks`: The indexed polygon masks.\\n \\\"\\\"\\\"\\n if isinstance(index, np.ndarray):\\n if index.dtype == bool:\\n index = np.where(index)[0].tolist()\\n else:\\n index = index.tolist()\\n if isinstance(index, list):\\n masks = [self.masks[i] for i in index]\\n else:\\n try:\\n masks = self.masks[index]\\n except Exception:\\n raise ValueError(\\n f'Unsupported input of type {type(index)} for indexing!')\\n if len(masks) and isinstance(masks[0], np.ndarray):\\n masks = [masks] # ensure a list of three levels\\n return PolygonMasks(masks, self.height, self.width)\\n\\n def __iter__(self):\\n return iter(self.masks)\\n\\n def __repr__(self):\\n s = self.__class__.__name__ + '('\\n s += f'num_masks={len(self.masks)}, '\\n s += f'height={self.height}, '\\n s += f'width={self.width})'\\n return s\\n\\n def __len__(self):\\n \\\"\\\"\\\"Number of masks.\\\"\\\"\\\"\\n return len(self.masks)\\n\\n def rescale(self, scale, interpolation=None):\\n \\\"\\\"\\\"see :func:`BaseInstanceMasks.rescale`\\\"\\\"\\\"\\n new_w, new_h = mmcv.rescale_size((self.width, self.height), scale)\\n if len(self.masks) == 0:\\n rescaled_masks = PolygonMasks([], new_h, new_w)\\n else:\\n rescaled_masks = self.resize((new_h, new_w))\\n return rescaled_masks\\n\\n def resize(self, out_shape, interpolation=None):\\n \\\"\\\"\\\"see :func:`BaseInstanceMasks.resize`\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n resized_masks = PolygonMasks([], *out_shape)\\n else:\\n h_scale = out_shape[0] / self.height\\n w_scale = out_shape[1] / self.width\\n resized_masks = []\\n for poly_per_obj in self.masks:\\n resized_poly = []\\n for p in poly_per_obj:\\n p = p.copy()\\n p[0::2] = p[0::2] * w_scale\\n p[1::2] = p[1::2] * h_scale\\n resized_poly.append(p)\\n resized_masks.append(resized_poly)\\n resized_masks = PolygonMasks(resized_masks, *out_shape)\\n return resized_masks\\n\\n def flip(self, flip_direction='horizontal'):\\n \\\"\\\"\\\"see :func:`BaseInstanceMasks.flip`\\\"\\\"\\\"\\n assert flip_direction in ('horizontal', 'vertical', 'diagonal')\\n if len(self.masks) == 0:\\n flipped_masks = PolygonMasks([], self.height, self.width)\\n else:\\n flipped_masks = []\\n for poly_per_obj in self.masks:\\n flipped_poly_per_obj = []\\n for p in poly_per_obj:\\n p = p.copy()\\n if flip_direction == 'horizontal':\\n p[0::2] = self.width - p[0::2]\\n elif flip_direction == 'vertical':\\n p[1::2] = self.height - p[1::2]\\n else:\\n p[0::2] = self.width - p[0::2]\\n p[1::2] = self.height - p[1::2]\\n flipped_poly_per_obj.append(p)\\n flipped_masks.append(flipped_poly_per_obj)\\n flipped_masks = PolygonMasks(flipped_masks, self.height,\\n self.width)\\n return flipped_masks\\n\\n def crop(self, bbox):\\n \\\"\\\"\\\"see :func:`BaseInstanceMasks.crop`\\\"\\\"\\\"\\n assert isinstance(bbox, np.ndarray)\\n assert bbox.ndim == 1\\n\\n # clip the boundary\\n bbox = bbox.copy()\\n bbox[0::2] = np.clip(bbox[0::2], 0, self.width)\\n bbox[1::2] = np.clip(bbox[1::2], 0, self.height)\\n x1, y1, x2, y2 = bbox\\n w = np.maximum(x2 - x1, 1)\\n h = np.maximum(y2 - y1, 1)\\n\\n if len(self.masks) == 0:\\n cropped_masks = PolygonMasks([], h, w)\\n else:\\n # reference: https://github.com/facebookresearch/fvcore/blob/main/fvcore/transforms/transform.py # noqa\\n crop_box = geometry.box(x1, y1, x2, y2).buffer(0.0)\\n cropped_masks = []\\n # suppress shapely warnings util it incorporates GEOS>=3.11.2\\n # reference: https://github.com/shapely/shapely/issues/1345\\n initial_settings = np.seterr()\\n np.seterr(invalid='ignore')\\n for poly_per_obj in self.masks:\\n cropped_poly_per_obj = []\\n for p in poly_per_obj:\\n p = p.copy()\\n p = geometry.Polygon(p.reshape(-1, 2)).buffer(0.0)\\n # polygon must be valid to perform intersection.\\n if not p.is_valid:\\n continue\\n cropped = p.intersection(crop_box)\\n if cropped.is_empty:\\n continue\\n if isinstance(cropped,\\n geometry.collection.BaseMultipartGeometry):\\n cropped = cropped.geoms\\n else:\\n cropped = [cropped]\\n # one polygon may be cropped to multiple ones\\n for poly in cropped:\\n # ignore lines or points\\n if not isinstance(\\n poly, geometry.Polygon) or not poly.is_valid:\\n continue\\n coords = np.asarray(poly.exterior.coords)\\n # remove an extra identical vertex at the end\\n coords = coords[:-1]\\n coords[:, 0] -= x1\\n coords[:, 1] -= y1\\n cropped_poly_per_obj.append(coords.reshape(-1))\\n # a dummy polygon to avoid misalignment between masks and boxes\\n if len(cropped_poly_per_obj) == 0:\\n cropped_poly_per_obj = [np.array([0, 0, 0, 0, 0, 0])]\\n cropped_masks.append(cropped_poly_per_obj)\\n np.seterr(**initial_settings)\\n cropped_masks = PolygonMasks(cropped_masks, h, w)\\n return cropped_masks\\n\\n def pad(self, out_shape, pad_val=0):\\n \\\"\\\"\\\"padding has no effect on polygons`\\\"\\\"\\\"\\n return PolygonMasks(self.masks, *out_shape)\\n\\n def expand(self, *args, **kwargs):\\n \\\"\\\"\\\"TODO: Add expand for polygon\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n def crop_and_resize(self,\\n bboxes,\\n out_shape,\\n inds,\\n device='cpu',\\n interpolation='bilinear',\\n binarize=True):\\n \\\"\\\"\\\"see :func:`BaseInstanceMasks.crop_and_resize`\\\"\\\"\\\"\\n out_h, out_w = out_shape\\n if len(self.masks) == 0:\\n return PolygonMasks([], out_h, out_w)\\n\\n if not binarize:\\n raise ValueError('Polygons are always binary, '\\n 'setting binarize=False is unsupported')\\n\\n resized_masks = []\\n for i in range(len(bboxes)):\\n mask = self.masks[inds[i]]\\n bbox = bboxes[i, :]\\n x1, y1, x2, y2 = bbox\\n w = np.maximum(x2 - x1, 1)\\n h = np.maximum(y2 - y1, 1)\\n h_scale = out_h / max(h, 0.1) # avoid too large scale\\n w_scale = out_w / max(w, 0.1)\\n\\n resized_mask = []\\n for p in mask:\\n p = p.copy()\\n # crop\\n # pycocotools will clip the boundary\\n p[0::2] = p[0::2] - bbox[0]\\n p[1::2] = p[1::2] - bbox[1]\\n\\n # resize\\n p[0::2] = p[0::2] * w_scale\\n p[1::2] = p[1::2] * h_scale\\n resized_mask.append(p)\\n resized_masks.append(resized_mask)\\n return PolygonMasks(resized_masks, *out_shape)\\n\\n def translate(self,\\n out_shape,\\n offset,\\n direction='horizontal',\\n border_value=None,\\n interpolation=None):\\n \\\"\\\"\\\"Translate the PolygonMasks.\\n\\n Example:\\n >>> self = PolygonMasks.random(dtype=np.int64)\\n >>> out_shape = (self.height, self.width)\\n >>> new = self.translate(out_shape, 4., direction='horizontal')\\n >>> assert np.all(new.masks[0][0][1::2] == self.masks[0][0][1::2])\\n >>> assert np.all(new.masks[0][0][0::2] == self.masks[0][0][0::2] + 4) # noqa: E501\\n \\\"\\\"\\\"\\n assert border_value is None or border_value == 0, \\\\\\n 'Here border_value is not '\\\\\\n f'used, and defaultly should be None or 0. got {border_value}.'\\n if len(self.masks) == 0:\\n translated_masks = PolygonMasks([], *out_shape)\\n else:\\n translated_masks = []\\n for poly_per_obj in self.masks:\\n translated_poly_per_obj = []\\n for p in poly_per_obj:\\n p = p.copy()\\n if direction == 'horizontal':\\n p[0::2] = np.clip(p[0::2] + offset, 0, out_shape[1])\\n elif direction == 'vertical':\\n p[1::2] = np.clip(p[1::2] + offset, 0, out_shape[0])\\n translated_poly_per_obj.append(p)\\n translated_masks.append(translated_poly_per_obj)\\n translated_masks = PolygonMasks(translated_masks, *out_shape)\\n return translated_masks\\n\\n def shear(self,\\n out_shape,\\n magnitude,\\n direction='horizontal',\\n border_value=0,\\n interpolation='bilinear'):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.shear`.\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n sheared_masks = PolygonMasks([], *out_shape)\\n else:\\n sheared_masks = []\\n if direction == 'horizontal':\\n shear_matrix = np.stack([[1, magnitude],\\n [0, 1]]).astype(np.float32)\\n elif direction == 'vertical':\\n shear_matrix = np.stack([[1, 0], [magnitude,\\n 1]]).astype(np.float32)\\n for poly_per_obj in self.masks:\\n sheared_poly = []\\n for p in poly_per_obj:\\n p = np.stack([p[0::2], p[1::2]], axis=0) # [2, n]\\n new_coords = np.matmul(shear_matrix, p) # [2, n]\\n new_coords[0, :] = np.clip(new_coords[0, :], 0,\\n out_shape[1])\\n new_coords[1, :] = np.clip(new_coords[1, :], 0,\\n out_shape[0])\\n sheared_poly.append(\\n new_coords.transpose((1, 0)).reshape(-1))\\n sheared_masks.append(sheared_poly)\\n sheared_masks = PolygonMasks(sheared_masks, *out_shape)\\n return sheared_masks\\n\\n def rotate(self,\\n out_shape,\\n angle,\\n center=None,\\n scale=1.0,\\n border_value=0,\\n interpolation='bilinear'):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.rotate`.\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n rotated_masks = PolygonMasks([], *out_shape)\\n else:\\n rotated_masks = []\\n rotate_matrix = cv2.getRotationMatrix2D(center, -angle, scale)\\n for poly_per_obj in self.masks:\\n rotated_poly = []\\n for p in poly_per_obj:\\n p = p.copy()\\n coords = np.stack([p[0::2], p[1::2]], axis=1) # [n, 2]\\n # pad 1 to convert from format [x, y] to homogeneous\\n # coordinates format [x, y, 1]\\n coords = np.concatenate(\\n (coords, np.ones((coords.shape[0], 1), coords.dtype)),\\n axis=1) # [n, 3]\\n rotated_coords = np.matmul(\\n rotate_matrix[None, :, :],\\n coords[:, :, None])[..., 0] # [n, 2, 1] -> [n, 2]\\n rotated_coords[:, 0] = np.clip(rotated_coords[:, 0], 0,\\n out_shape[1])\\n rotated_coords[:, 1] = np.clip(rotated_coords[:, 1], 0,\\n out_shape[0])\\n rotated_poly.append(rotated_coords.reshape(-1))\\n rotated_masks.append(rotated_poly)\\n rotated_masks = PolygonMasks(rotated_masks, *out_shape)\\n return rotated_masks\\n\\n def to_bitmap(self):\\n \\\"\\\"\\\"convert polygon masks to bitmap masks.\\\"\\\"\\\"\\n bitmap_masks = self.to_ndarray()\\n return BitmapMasks(bitmap_masks, self.height, self.width)\\n\\n @property\\n def areas(self):\\n \\\"\\\"\\\"Compute areas of masks.\\n\\n This func is modified from `detectron2\\n <https://github.com/facebookresearch/detectron2/blob/ffff8acc35ea88ad1cb1806ab0f00b4c1c5dbfd9/detectron2/structures/masks.py#L387>`_.\\n The function only works with Polygons using the shoelace formula.\\n\\n Return:\\n ndarray: areas of each instance\\n \\\"\\\"\\\" # noqa: W501\\n area = []\\n for polygons_per_obj in self.masks:\\n area_per_obj = 0\\n for p in polygons_per_obj:\\n area_per_obj += self._polygon_area(p[0::2], p[1::2])\\n area.append(area_per_obj)\\n return np.asarray(area)\\n\\n def _polygon_area(self, x, y):\\n \\\"\\\"\\\"Compute the area of a component of a polygon.\\n\\n Using the shoelace formula:\\n https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates\\n\\n Args:\\n x (ndarray): x coordinates of the component\\n y (ndarray): y coordinates of the component\\n\\n Return:\\n float: the are of the component\\n \\\"\\\"\\\" # noqa: 501\\n return 0.5 * np.abs(\\n np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))\\n\\n def to_ndarray(self):\\n \\\"\\\"\\\"Convert masks to the format of ndarray.\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n return np.empty((0, self.height, self.width), dtype=np.uint8)\\n bitmap_masks = []\\n for poly_per_obj in self.masks:\\n bitmap_masks.append(\\n polygon_to_bitmap(poly_per_obj, self.height, self.width))\\n return np.stack(bitmap_masks)\\n\\n def to_tensor(self, dtype, device):\\n \\\"\\\"\\\"See :func:`BaseInstanceMasks.to_tensor`.\\\"\\\"\\\"\\n if len(self.masks) == 0:\\n return torch.empty((0, self.height, self.width),\\n dtype=dtype,\\n device=device)\\n ndarray_masks = self.to_ndarray()\\n return torch.tensor(ndarray_masks, dtype=dtype, device=device)\\n\\n @classmethod\\n def random(cls,\\n num_masks=3,\\n height=32,\\n width=32,\\n n_verts=5,\\n dtype=np.float32,\\n rng=None):\\n \\\"\\\"\\\"Generate random polygon masks for demo / testing purposes.\\n\\n Adapted from [1]_\\n\\n References:\\n .. [1] https://gitlab.kitware.com/computer-vision/kwimage/-/blob/928cae35ca8/kwimage/structs/polygon.py#L379 # noqa: E501\\n\\n Example:\\n >>> from mmdet.data_elements.mask.structures import PolygonMasks\\n >>> self = PolygonMasks.random()\\n >>> print('self = {}'.format(self))\\n \\\"\\\"\\\"\\n from mmdet.utils.util_random import ensure_rng\\n rng = ensure_rng(rng)\\n\\n def _gen_polygon(n, irregularity, spikeyness):\\n \\\"\\\"\\\"Creates the polygon by sampling points on a circle around the\\n centre. Random noise is added by varying the angular spacing\\n between sequential points, and by varying the radial distance of\\n each point from the centre.\\n\\n Based on original code by Mike Ounsworth\\n\\n Args:\\n n (int): number of vertices\\n irregularity (float): [0,1] indicating how much variance there\\n is in the angular spacing of vertices. [0,1] will map to\\n [0, 2pi/numberOfVerts]\\n spikeyness (float): [0,1] indicating how much variance there is\\n in each vertex from the circle of radius aveRadius. [0,1]\\n will map to [0, aveRadius]\\n\\n Returns:\\n a list of vertices, in CCW order.\\n \\\"\\\"\\\"\\n from scipy.stats import truncnorm\\n\\n # Generate around the unit circle\\n cx, cy = (0.0, 0.0)\\n radius = 1\\n\\n tau = np.pi * 2\\n\\n irregularity = np.clip(irregularity, 0, 1) * 2 * np.pi / n\\n spikeyness = np.clip(spikeyness, 1e-9, 1)\\n\\n # generate n angle steps\\n lower = (tau / n) - irregularity\\n upper = (tau / n) + irregularity\\n angle_steps = rng.uniform(lower, upper, n)\\n\\n # normalize the steps so that point 0 and point n+1 are the same\\n k = angle_steps.sum() / (2 * np.pi)\\n angles = (angle_steps / k).cumsum() + rng.uniform(0, tau)\\n\\n # Convert high and low values to be wrt the standard normal range\\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.truncnorm.html\\n low = 0\\n high = 2 * radius\\n mean = radius\\n std = spikeyness\\n a = (low - mean) / std\\n b = (high - mean) / std\\n tnorm = truncnorm(a=a, b=b, loc=mean, scale=std)\\n\\n # now generate the points\\n radii = tnorm.rvs(n, random_state=rng)\\n x_pts = cx + radii * np.cos(angles)\\n y_pts = cy + radii * np.sin(angles)\\n\\n points = np.hstack([x_pts[:, None], y_pts[:, None]])\\n\\n # Scale to 0-1 space\\n points = points - points.min(axis=0)\\n points = points / points.max(axis=0)\\n\\n # Randomly place within 0-1 space\\n points = points * (rng.rand() * .8 + .2)\\n min_pt = points.min(axis=0)\\n max_pt = points.max(axis=0)\\n\\n high = (1 - max_pt)\\n low = (0 - min_pt)\\n offset = (rng.rand(2) * (high - low)) + low\\n points = points + offset\\n return points\\n\\n def _order_vertices(verts):\\n \\\"\\\"\\\"\\n References:\\n https://stackoverflow.com/questions/1709283/how-can-i-sort-a-coordinate-list-for-a-rectangle-counterclockwise\\n \\\"\\\"\\\"\\n mlat = verts.T[0].sum() / len(verts)\\n mlng = verts.T[1].sum() / len(verts)\\n\\n tau = np.pi * 2\\n angle = (np.arctan2(mlat - verts.T[0], verts.T[1] - mlng) +\\n tau) % tau\\n sortx = angle.argsort()\\n verts = verts.take(sortx, axis=0)\\n return verts\\n\\n # Generate a random exterior for each requested mask\\n masks = []\\n for _ in range(num_masks):\\n exterior = _order_vertices(_gen_polygon(n_verts, 0.9, 0.9))\\n exterior = (exterior * [(width, height)]).astype(dtype)\\n masks.append([exterior.ravel()])\\n\\n self = cls(masks, height, width)\\n return self\\n\\n @classmethod\\n def cat(cls: Type[T], masks: Sequence[T]) -> T:\\n \\\"\\\"\\\"Concatenate a sequence of masks into one single mask instance.\\n\\n Args:\\n masks (Sequence[PolygonMasks]): A sequence of mask instances.\\n\\n Returns:\\n PolygonMasks: Concatenated mask instance.\\n \\\"\\\"\\\"\\n assert isinstance(masks, Sequence)\\n if len(masks) == 0:\\n raise ValueError('masks should not be an empty list.')\\n assert all(isinstance(m, cls) for m in masks)\\n\\n mask_list = list(itertools.chain(*[m.masks for m in masks]))\\n return cls(mask_list, masks[0].height, masks[0].width)\"\n },\n {\n \"identifier\": \"log_img_scale\",\n \"path\": \"mmdet/utils/logger.py\",\n \"snippet\": \"def log_img_scale(img_scale, shape_order='hw', skip_square=False):\\n \\\"\\\"\\\"Log image size.\\n\\n Args:\\n img_scale (tuple): Image size to be logged.\\n shape_order (str, optional): The order of image shape.\\n 'hw' for (height, width) and 'wh' for (width, height).\\n Defaults to 'hw'.\\n skip_square (bool, optional): Whether to skip logging for square\\n img_scale. Defaults to False.\\n\\n Returns:\\n bool: Whether to have done logging.\\n \\\"\\\"\\\"\\n if shape_order == 'hw':\\n height, width = img_scale\\n elif shape_order == 'wh':\\n width, height = img_scale\\n else:\\n raise ValueError(f'Invalid shape_order {shape_order}.')\\n\\n if skip_square and (height == width):\\n return False\\n\\n caller = get_caller_name()\\n print_log(\\n f'image shape: height={height}, width={width} in {caller}',\\n logger='current')\\n\\n return True\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import copy\nimport inspect\nimport math\nimport warnings\nimport cv2\nimport mmcv\nimport numpy as np\n import albumentations\nfrom typing import List, Optional, Sequence, Tuple, Union\nfrom mmcv.image import imresize\nfrom mmcv.image.geometric import _scale_size\nfrom mmcv.transforms import BaseTransform\nfrom mmcv.transforms import Pad as MMCV_Pad\nfrom mmcv.transforms import RandomFlip as MMCV_RandomFlip\nfrom mmcv.transforms import Resize as MMCV_Resize\nfrom mmcv.transforms.utils import avoid_cache_randomness, cache_randomness\nfrom mmengine.dataset import BaseDataset\nfrom mmengine.utils import is_str\nfrom numpy import random\nfrom mmdet.registry import TRANSFORMS\nfrom mmdet.structures.bbox import HorizontalBoxes, autocast_box_type\nfrom mmdet.structures.mask import BitmapMasks, PolygonMasks\nfrom mmdet.utils import log_img_scale\n from imagecorruptions import corrupt\n from albumentations import Compose"},"token_num":{"kind":"number","value":17900,"string":"17,900"},"cropped_code":{"kind":"string","value":" assert (cutout_shape is None) ^ (cutout_ratio is None), \\\n 'Either cutout_shape or cutout_ratio should be specified.'\n assert (isinstance(cutout_shape, (list, tuple))\n or isinstance(cutout_ratio, (list, tuple)))\n if isinstance(n_holes, tuple):\n assert len(n_holes) == 2 and 0 <= n_holes[0] < n_holes[1]\n else:\n n_holes = (n_holes, n_holes)\n self.n_holes = n_holes\n self.fill_in = fill_in\n self.with_ratio = cutout_ratio is not None\n self.candidates = cutout_ratio if self.with_ratio else cutout_shape\n if not isinstance(self.candidates, list):\n self.candidates = [self.candidates]\n\n @autocast_box_type()\n def transform(self, results: dict) -> dict:\n \"\"\"Call function to drop some regions of image.\"\"\"\n h, w, c = results['img'].shape\n n_holes = np.random.randint(self.n_holes[0], self.n_holes[1] + 1)\n for _ in range(n_holes):\n x1 = np.random.randint(0, w)\n y1 = np.random.randint(0, h)\n index = np.random.randint(0, len(self.candidates))\n if not self.with_ratio:\n cutout_w, cutout_h = self.candidates[index]\n else:\n cutout_w = int(self.candidates[index][0] * w)\n cutout_h = int(self.candidates[index][1] * h)\n\n x2 = np.clip(x1 + cutout_w, 0, w)\n y2 = np.clip(y1 + cutout_h, 0, h)\n results['img'][y1:y2, x1:x2, :] = self.fill_in\n\n return results\n\n def __repr__(self):\n repr_str = self.__class__.__name__\n repr_str += f'(n_holes={self.n_holes}, '\n repr_str += (f'cutout_ratio={self.candidates}, ' if self.with_ratio\n else f'cutout_shape={self.candidates}, ')\n repr_str += f'fill_in={self.fill_in})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass Mosaic(BaseTransform):\n \"\"\"Mosaic augmentation.\n\n Given 4 images, mosaic transform combines them into\n one output image. The output image is composed of the parts from each sub-\n image.\n\n .. code:: text\n\n mosaic transform\n center_x\n +------------------------------+\n | pad | pad |\n | +-----------+ |\n | | | |\n | | image1 |--------+ |\n | | | | |\n | | | image2 | |\n center_y |----+-------------+-----------|\n | | cropped | |\n |pad | image3 | image4 |\n | | | |\n +----|-------------+-----------+\n | |\n +-------------+\n\n The mosaic transform steps are as follows:\n\n 1. Choose the mosaic center as the intersections of 4 images\n 2. Get the left top image according to the index, and randomly\n sample another 3 images from the custom dataset.\n 3. Sub image will be cropped if image is larger than mosaic patch\n\n Required Keys:\n\n - img\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_bboxes_labels (np.int64) (optional)\n - gt_ignore_flags (bool) (optional)\n - mix_results (List[dict])\n\n Modified Keys:\n\n - img\n - img_shape\n - gt_bboxes (optional)\n - gt_bboxes_labels (optional)\n - gt_ignore_flags (optional)\n\n Args:\n img_scale (Sequence[int]): Image size before mosaic pipeline of single\n image. The shape order should be (width, height).\n Defaults to (640, 640).\n center_ratio_range (Sequence[float]): Center ratio range of mosaic\n output. Defaults to (0.5, 1.5).\n bbox_clip_border (bool, optional): Whether to clip the objects outside\n the border of the image. In some dataset like MOT17, the gt bboxes\n are allowed to cross the border of images. Therefore, we don't\n need to clip the gt bboxes in these cases. Defaults to True.\n pad_val (int): Pad value. Defaults to 114.\n prob (float): Probability of applying this transformation.\n Defaults to 1.0.\n \"\"\"\n\n def __init__(self,\n img_scale: Tuple[int, int] = (640, 640),\n center_ratio_range: Tuple[float, float] = (0.5, 1.5),\n bbox_clip_border: bool = True,\n pad_val: float = 114.0,\n prob: float = 1.0) -> None:\n assert isinstance(img_scale, tuple)\n assert 0 <= prob <= 1.0, 'The probability should be in range [0,1]. ' \\\n f'got {prob}.'\n\n"},"all_code":{"kind":"string","value":"# Copyright (c) OpenMMLab. All rights reserved.\n\n\n\ntry:\nexcept ImportError:\n corrupt = None\n\ntry:\nexcept ImportError:\n albumentations = None\n Compose = None\n\nNumber = Union[int, float]\n\n\ndef _fixed_scale_size(\n size: Tuple[int, int],\n scale: Union[float, int, tuple],\n) -> Tuple[int, int]:\n \"\"\"Rescale a size by a ratio.\n\n Args:\n size (tuple[int]): (w, h).\n scale (float | tuple(float)): Scaling factor.\n\n Returns:\n tuple[int]: scaled size.\n \"\"\"\n if isinstance(scale, (float, int)):\n scale = (scale, scale)\n w, h = size\n # don't need o.5 offset\n return int(w * float(scale[0])), int(h * float(scale[1]))\n\n\ndef rescale_size(old_size: tuple,\n scale: Union[float, int, tuple],\n return_scale: bool = False) -> tuple:\n \"\"\"Calculate the new size to be rescaled to.\n\n Args:\n old_size (tuple[int]): The old size (w, h) of image.\n scale (float | tuple[int]): The scaling factor or maximum size.\n If it is a float number, then the image will be rescaled by this\n factor, else if it is a tuple of 2 integers, then the image will\n be rescaled as large as possible within the scale.\n return_scale (bool): Whether to return the scaling factor besides the\n rescaled image size.\n\n Returns:\n tuple[int]: The new rescaled image size.\n \"\"\"\n w, h = old_size\n if isinstance(scale, (float, int)):\n if scale <= 0:\n raise ValueError(f'Invalid scale {scale}, must be positive.')\n scale_factor = scale\n elif isinstance(scale, tuple):\n max_long_edge = max(scale)\n max_short_edge = min(scale)\n scale_factor = min(max_long_edge / max(h, w),\n max_short_edge / min(h, w))\n else:\n raise TypeError(\n f'Scale must be a number or tuple of int, but got {type(scale)}')\n # only change this\n new_size = _fixed_scale_size((w, h), scale_factor)\n\n if return_scale:\n return new_size, scale_factor\n else:\n return new_size\n\n\ndef imrescale(\n img: np.ndarray,\n scale: Union[float, Tuple[int, int]],\n return_scale: bool = False,\n interpolation: str = 'bilinear',\n backend: Optional[str] = None\n) -> Union[np.ndarray, Tuple[np.ndarray, float]]:\n \"\"\"Resize image while keeping the aspect ratio.\n\n Args:\n img (ndarray): The input image.\n scale (float | tuple[int]): The scaling factor or maximum size.\n If it is a float number, then the image will be rescaled by this\n factor, else if it is a tuple of 2 integers, then the image will\n be rescaled as large as possible within the scale.\n return_scale (bool): Whether to return the scaling factor besides the\n rescaled image.\n interpolation (str): Same as :func:`resize`.\n backend (str | None): Same as :func:`resize`.\n\n Returns:\n ndarray: The rescaled image.\n \"\"\"\n h, w = img.shape[:2]\n new_size, scale_factor = rescale_size((w, h), scale, return_scale=True)\n rescaled_img = imresize(\n img, new_size, interpolation=interpolation, backend=backend)\n if return_scale:\n return rescaled_img, scale_factor\n else:\n return rescaled_img\n\n\n@TRANSFORMS.register_module()\nclass Resize(MMCV_Resize):\n \"\"\"Resize images & bbox & seg.\n\n This transform resizes the input image according to ``scale`` or\n ``scale_factor``. Bboxes, masks, and seg map are then resized\n with the same scale factor.\n if ``scale`` and ``scale_factor`` are both set, it will use ``scale`` to\n resize.\n\n Required Keys:\n\n - img\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_masks (BitmapMasks | PolygonMasks) (optional)\n - gt_seg_map (np.uint8) (optional)\n\n Modified Keys:\n\n - img\n - img_shape\n - gt_bboxes\n - gt_masks\n - gt_seg_map\n\n\n Added Keys:\n\n - scale\n - scale_factor\n - keep_ratio\n - homography_matrix\n\n Args:\n scale (int or tuple): Images scales for resizing. Defaults to None\n scale_factor (float or tuple[float]): Scale factors for resizing.\n Defaults to None.\n keep_ratio (bool): Whether to keep the aspect ratio when resizing the\n image. Defaults to False.\n clip_object_border (bool): Whether to clip the objects\n outside the border of the image. In some dataset like MOT17, the gt\n bboxes are allowed to cross the border of images. Therefore, we\n don't need to clip the gt bboxes in these cases. Defaults to True.\n backend (str): Image resize backend, choices are 'cv2' and 'pillow'.\n These two backends generates slightly different results. Defaults\n to 'cv2'.\n interpolation (str): Interpolation method, accepted values are\n \"nearest\", \"bilinear\", \"bicubic\", \"area\", \"lanczos\" for 'cv2'\n backend, \"nearest\", \"bilinear\" for 'pillow' backend. Defaults\n to 'bilinear'.\n \"\"\"\n\n def _resize_masks(self, results: dict) -> None:\n \"\"\"Resize masks with ``results['scale']``\"\"\"\n if results.get('gt_masks', None) is not None:\n if self.keep_ratio:\n results['gt_masks'] = results['gt_masks'].rescale(\n results['scale'])\n else:\n results['gt_masks'] = results['gt_masks'].resize(\n results['img_shape'])\n\n def _resize_bboxes(self, results: dict) -> None:\n \"\"\"Resize bounding boxes with ``results['scale_factor']``.\"\"\"\n if results.get('gt_bboxes', None) is not None:\n results['gt_bboxes'].rescale_(results['scale_factor'])\n if self.clip_object_border:\n results['gt_bboxes'].clip_(results['img_shape'])\n\n def _record_homography_matrix(self, results: dict) -> None:\n \"\"\"Record the homography matrix for the Resize.\"\"\"\n w_scale, h_scale = results['scale_factor']\n homography_matrix = np.array(\n [[w_scale, 0, 0], [0, h_scale, 0], [0, 0, 1]], dtype=np.float32)\n if results.get('homography_matrix', None) is None:\n results['homography_matrix'] = homography_matrix\n else:\n results['homography_matrix'] = homography_matrix @ results[\n 'homography_matrix']\n\n @autocast_box_type()\n def transform(self, results: dict) -> dict:\n \"\"\"Transform function to resize images, bounding boxes and semantic\n segmentation map.\n\n Args:\n results (dict): Result dict from loading pipeline.\n Returns:\n dict: Resized results, 'img', 'gt_bboxes', 'gt_seg_map',\n 'scale', 'scale_factor', 'height', 'width', and 'keep_ratio' keys\n are updated in result dict.\n \"\"\"\n if self.scale:\n results['scale'] = self.scale\n else:\n img_shape = results['img'].shape[:2]\n results['scale'] = _scale_size(img_shape[::-1], self.scale_factor)\n self._resize_img(results)\n self._resize_bboxes(results)\n self._resize_masks(results)\n self._resize_seg(results)\n self._record_homography_matrix(results)\n return results\n\n def __repr__(self) -> str:\n repr_str = self.__class__.__name__\n repr_str += f'(scale={self.scale}, '\n repr_str += f'scale_factor={self.scale_factor}, '\n repr_str += f'keep_ratio={self.keep_ratio}, '\n repr_str += f'clip_object_border={self.clip_object_border}), '\n repr_str += f'backend={self.backend}), '\n repr_str += f'interpolation={self.interpolation})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass FixScaleResize(Resize):\n \"\"\"Compared to Resize, FixScaleResize fixes the scaling issue when\n `keep_ratio=true`.\"\"\"\n\n def _resize_img(self, results):\n \"\"\"Resize images with ``results['scale']``.\"\"\"\n if results.get('img', None) is not None:\n if self.keep_ratio:\n img, scale_factor = imrescale(\n results['img'],\n results['scale'],\n interpolation=self.interpolation,\n return_scale=True,\n backend=self.backend)\n new_h, new_w = img.shape[:2]\n h, w = results['img'].shape[:2]\n w_scale = new_w / w\n h_scale = new_h / h\n else:\n img, w_scale, h_scale = mmcv.imresize(\n results['img'],\n results['scale'],\n interpolation=self.interpolation,\n return_scale=True,\n backend=self.backend)\n results['img'] = img\n results['img_shape'] = img.shape[:2]\n results['scale_factor'] = (w_scale, h_scale)\n results['keep_ratio'] = self.keep_ratio\n\n\n@TRANSFORMS.register_module()\nclass ResizeShortestEdge(BaseTransform):\n \"\"\"Resize the image and mask while keeping the aspect ratio unchanged.\n\n Modified from https://github.com/facebookresearch/detectron2/blob/main/detectron2/data/transforms/augmentation_impl.py#L130 # noqa:E501\n\n This transform attempts to scale the shorter edge to the given\n `scale`, as long as the longer edge does not exceed `max_size`.\n If `max_size` is reached, then downscale so that the longer\n edge does not exceed `max_size`.\n\n Required Keys:\n - img\n - gt_seg_map (optional)\n Modified Keys:\n - img\n - img_shape\n - gt_seg_map (optional))\n Added Keys:\n - scale\n - scale_factor\n - keep_ratio\n\n Args:\n scale (Union[int, Tuple[int, int]]): The target short edge length.\n If it's tuple, will select the min value as the short edge length.\n max_size (int): The maximum allowed longest edge length.\n \"\"\"\n\n def __init__(self,\n scale: Union[int, Tuple[int, int]],\n max_size: Optional[int] = None,\n resize_type: str = 'Resize',\n **resize_kwargs) -> None:\n super().__init__()\n self.scale = scale\n self.max_size = max_size\n\n self.resize_cfg = dict(type=resize_type, **resize_kwargs)\n self.resize = TRANSFORMS.build({'scale': 0, **self.resize_cfg})\n\n def _get_output_shape(\n self, img: np.ndarray,\n short_edge_length: Union[int, Tuple[int, int]]) -> Tuple[int, int]:\n \"\"\"Compute the target image shape with the given `short_edge_length`.\n\n Args:\n img (np.ndarray): The input image.\n short_edge_length (Union[int, Tuple[int, int]]): The target short\n edge length. If it's tuple, will select the min value as the\n short edge length.\n \"\"\"\n h, w = img.shape[:2]\n if isinstance(short_edge_length, int):\n size = short_edge_length * 1.0\n elif isinstance(short_edge_length, tuple):\n size = min(short_edge_length) * 1.0\n scale = size / min(h, w)\n if h < w:\n new_h, new_w = size, scale * w\n else:\n new_h, new_w = scale * h, size\n\n if self.max_size and max(new_h, new_w) > self.max_size:\n scale = self.max_size * 1.0 / max(new_h, new_w)\n new_h *= scale\n new_w *= scale\n\n new_h = int(new_h + 0.5)\n new_w = int(new_w + 0.5)\n return new_w, new_h\n\n def transform(self, results: dict) -> dict:\n self.resize.scale = self._get_output_shape(results['img'], self.scale)\n return self.resize(results)\n\n\n@TRANSFORMS.register_module()\nclass FixShapeResize(Resize):\n \"\"\"Resize images & bbox & seg to the specified size.\n\n This transform resizes the input image according to ``width`` and\n ``height``. Bboxes, masks, and seg map are then resized\n with the same parameters.\n\n Required Keys:\n\n - img\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_masks (BitmapMasks | PolygonMasks) (optional)\n - gt_seg_map (np.uint8) (optional)\n\n Modified Keys:\n\n - img\n - img_shape\n - gt_bboxes\n - gt_masks\n - gt_seg_map\n\n\n Added Keys:\n\n - scale\n - scale_factor\n - keep_ratio\n - homography_matrix\n\n Args:\n width (int): width for resizing.\n height (int): height for resizing.\n Defaults to None.\n pad_val (Number | dict[str, Number], optional): Padding value for if\n the pad_mode is \"constant\". If it is a single number, the value\n to pad the image is the number and to pad the semantic\n segmentation map is 255. If it is a dict, it should have the\n following keys:\n\n - img: The value to pad the image.\n - seg: The value to pad the semantic segmentation map.\n Defaults to dict(img=0, seg=255).\n keep_ratio (bool): Whether to keep the aspect ratio when resizing the\n image. Defaults to False.\n clip_object_border (bool): Whether to clip the objects\n outside the border of the image. In some dataset like MOT17, the gt\n bboxes are allowed to cross the border of images. Therefore, we\n don't need to clip the gt bboxes in these cases. Defaults to True.\n backend (str): Image resize backend, choices are 'cv2' and 'pillow'.\n These two backends generates slightly different results. Defaults\n to 'cv2'.\n interpolation (str): Interpolation method, accepted values are\n \"nearest\", \"bilinear\", \"bicubic\", \"area\", \"lanczos\" for 'cv2'\n backend, \"nearest\", \"bilinear\" for 'pillow' backend. Defaults\n to 'bilinear'.\n \"\"\"\n\n def __init__(self,\n width: int,\n height: int,\n pad_val: Union[Number, dict] = dict(img=0, seg=255),\n keep_ratio: bool = False,\n clip_object_border: bool = True,\n backend: str = 'cv2',\n interpolation: str = 'bilinear') -> None:\n assert width is not None and height is not None, (\n '`width` and'\n '`height` can not be `None`')\n\n self.width = width\n self.height = height\n self.scale = (width, height)\n\n self.backend = backend\n self.interpolation = interpolation\n self.keep_ratio = keep_ratio\n self.clip_object_border = clip_object_border\n\n if keep_ratio is True:\n # padding to the fixed size when keep_ratio=True\n self.pad_transform = Pad(size=self.scale, pad_val=pad_val)\n\n @autocast_box_type()\n def transform(self, results: dict) -> dict:\n \"\"\"Transform function to resize images, bounding boxes and semantic\n segmentation map.\n\n Args:\n results (dict): Result dict from loading pipeline.\n Returns:\n dict: Resized results, 'img', 'gt_bboxes', 'gt_seg_map',\n 'scale', 'scale_factor', 'height', 'width', and 'keep_ratio' keys\n are updated in result dict.\n \"\"\"\n img = results['img']\n h, w = img.shape[:2]\n if self.keep_ratio:\n scale_factor = min(self.width / w, self.height / h)\n results['scale_factor'] = (scale_factor, scale_factor)\n real_w, real_h = int(w * float(scale_factor) +\n 0.5), int(h * float(scale_factor) + 0.5)\n img, scale_factor = mmcv.imrescale(\n results['img'], (real_w, real_h),\n interpolation=self.interpolation,\n return_scale=True,\n backend=self.backend)\n # the w_scale and h_scale has minor difference\n # a real fix should be done in the mmcv.imrescale in the future\n results['img'] = img\n results['img_shape'] = img.shape[:2]\n results['keep_ratio'] = self.keep_ratio\n results['scale'] = (real_w, real_h)\n else:\n results['scale'] = (self.width, self.height)\n results['scale_factor'] = (self.width / w, self.height / h)\n super()._resize_img(results)\n\n self._resize_bboxes(results)\n self._resize_masks(results)\n self._resize_seg(results)\n self._record_homography_matrix(results)\n if self.keep_ratio:\n self.pad_transform(results)\n return results\n\n def __repr__(self) -> str:\n repr_str = self.__class__.__name__\n repr_str += f'(width={self.width}, height={self.height}, '\n repr_str += f'keep_ratio={self.keep_ratio}, '\n repr_str += f'clip_object_border={self.clip_object_border}), '\n repr_str += f'backend={self.backend}), '\n repr_str += f'interpolation={self.interpolation})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass RandomFlip(MMCV_RandomFlip):\n \"\"\"Flip the image & bbox & mask & segmentation map. Added or Updated keys:\n flip, flip_direction, img, gt_bboxes, and gt_seg_map. There are 3 flip\n modes:\n\n - ``prob`` is float, ``direction`` is string: the image will be\n ``direction``ly flipped with probability of ``prob`` .\n E.g., ``prob=0.5``, ``direction='horizontal'``,\n then image will be horizontally flipped with probability of 0.5.\n - ``prob`` is float, ``direction`` is list of string: the image will\n be ``direction[i]``ly flipped with probability of\n ``prob/len(direction)``.\n E.g., ``prob=0.5``, ``direction=['horizontal', 'vertical']``,\n then image will be horizontally flipped with probability of 0.25,\n vertically with probability of 0.25.\n - ``prob`` is list of float, ``direction`` is list of string:\n given ``len(prob) == len(direction)``, the image will\n be ``direction[i]``ly flipped with probability of ``prob[i]``.\n E.g., ``prob=[0.3, 0.5]``, ``direction=['horizontal',\n 'vertical']``, then image will be horizontally flipped with\n probability of 0.3, vertically with probability of 0.5.\n\n\n Required Keys:\n\n - img\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_masks (BitmapMasks | PolygonMasks) (optional)\n - gt_seg_map (np.uint8) (optional)\n\n Modified Keys:\n\n - img\n - gt_bboxes\n - gt_masks\n - gt_seg_map\n\n Added Keys:\n\n - flip\n - flip_direction\n - homography_matrix\n\n\n Args:\n prob (float | list[float], optional): The flipping probability.\n Defaults to None.\n direction(str | list[str]): The flipping direction. Options\n If input is a list, the length must equal ``prob``. Each\n element in ``prob`` indicates the flip probability of\n corresponding direction. Defaults to 'horizontal'.\n \"\"\"\n\n def _record_homography_matrix(self, results: dict) -> None:\n \"\"\"Record the homography matrix for the RandomFlip.\"\"\"\n cur_dir = results['flip_direction']\n h, w = results['img'].shape[:2]\n\n if cur_dir == 'horizontal':\n homography_matrix = np.array([[-1, 0, w], [0, 1, 0], [0, 0, 1]],\n dtype=np.float32)\n elif cur_dir == 'vertical':\n homography_matrix = np.array([[1, 0, 0], [0, -1, h], [0, 0, 1]],\n dtype=np.float32)\n elif cur_dir == 'diagonal':\n homography_matrix = np.array([[-1, 0, w], [0, -1, h], [0, 0, 1]],\n dtype=np.float32)\n else:\n homography_matrix = np.eye(3, dtype=np.float32)\n\n if results.get('homography_matrix', None) is None:\n results['homography_matrix'] = homography_matrix\n else:\n results['homography_matrix'] = homography_matrix @ results[\n 'homography_matrix']\n\n @autocast_box_type()\n def _flip(self, results: dict) -> None:\n \"\"\"Flip images, bounding boxes, and semantic segmentation map.\"\"\"\n # flip image\n results['img'] = mmcv.imflip(\n results['img'], direction=results['flip_direction'])\n\n img_shape = results['img'].shape[:2]\n\n # flip bboxes\n if results.get('gt_bboxes', None) is not None:\n results['gt_bboxes'].flip_(img_shape, results['flip_direction'])\n\n # flip masks\n if results.get('gt_masks', None) is not None:\n results['gt_masks'] = results['gt_masks'].flip(\n results['flip_direction'])\n\n # flip segs\n if results.get('gt_seg_map', None) is not None:\n results['gt_seg_map'] = mmcv.imflip(\n results['gt_seg_map'], direction=results['flip_direction'])\n\n # record homography matrix for flip\n self._record_homography_matrix(results)\n\n\n@TRANSFORMS.register_module()\nclass RandomShift(BaseTransform):\n \"\"\"Shift the image and box given shift pixels and probability.\n\n Required Keys:\n\n - img\n - gt_bboxes (BaseBoxes[torch.float32])\n - gt_bboxes_labels (np.int64)\n - gt_ignore_flags (bool) (optional)\n\n Modified Keys:\n\n - img\n - gt_bboxes\n - gt_bboxes_labels\n - gt_ignore_flags (bool) (optional)\n\n Args:\n prob (float): Probability of shifts. Defaults to 0.5.\n max_shift_px (int): The max pixels for shifting. Defaults to 32.\n filter_thr_px (int): The width and height threshold for filtering.\n The bbox and the rest of the targets below the width and\n height threshold will be filtered. Defaults to 1.\n \"\"\"\n\n def __init__(self,\n prob: float = 0.5,\n max_shift_px: int = 32,\n filter_thr_px: int = 1) -> None:\n assert 0 <= prob <= 1\n assert max_shift_px >= 0\n self.prob = prob\n self.max_shift_px = max_shift_px\n self.filter_thr_px = int(filter_thr_px)\n\n @cache_randomness\n def _random_prob(self) -> float:\n return random.uniform(0, 1)\n\n @autocast_box_type()\n def transform(self, results: dict) -> dict:\n \"\"\"Transform function to random shift images, bounding boxes.\n\n Args:\n results (dict): Result dict from loading pipeline.\n\n Returns:\n dict: Shift results.\n \"\"\"\n if self._random_prob() < self.prob:\n img_shape = results['img'].shape[:2]\n\n random_shift_x = random.randint(-self.max_shift_px,\n self.max_shift_px)\n random_shift_y = random.randint(-self.max_shift_px,\n self.max_shift_px)\n new_x = max(0, random_shift_x)\n ori_x = max(0, -random_shift_x)\n new_y = max(0, random_shift_y)\n ori_y = max(0, -random_shift_y)\n\n # TODO: support mask and semantic segmentation maps.\n bboxes = results['gt_bboxes'].clone()\n bboxes.translate_([random_shift_x, random_shift_y])\n\n # clip border\n bboxes.clip_(img_shape)\n\n # remove invalid bboxes\n valid_inds = (bboxes.widths > self.filter_thr_px).numpy() & (\n bboxes.heights > self.filter_thr_px).numpy()\n # If the shift does not contain any gt-bbox area, skip this\n # image.\n if not valid_inds.any():\n return results\n bboxes = bboxes[valid_inds]\n results['gt_bboxes'] = bboxes\n results['gt_bboxes_labels'] = results['gt_bboxes_labels'][\n valid_inds]\n\n if results.get('gt_ignore_flags', None) is not None:\n results['gt_ignore_flags'] = \\\n results['gt_ignore_flags'][valid_inds]\n\n # shift img\n img = results['img']\n new_img = np.zeros_like(img)\n img_h, img_w = img.shape[:2]\n new_h = img_h - np.abs(random_shift_y)\n new_w = img_w - np.abs(random_shift_x)\n new_img[new_y:new_y + new_h, new_x:new_x + new_w] \\\n = img[ori_y:ori_y + new_h, ori_x:ori_x + new_w]\n results['img'] = new_img\n\n return results\n\n def __repr__(self):\n repr_str = self.__class__.__name__\n repr_str += f'(prob={self.prob}, '\n repr_str += f'max_shift_px={self.max_shift_px}, '\n repr_str += f'filter_thr_px={self.filter_thr_px})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass Pad(MMCV_Pad):\n \"\"\"Pad the image & segmentation map.\n\n There are three padding modes: (1) pad to a fixed size and (2) pad to the\n minimum size that is divisible by some number. and (3)pad to square. Also,\n pad to square and pad to the minimum size can be used as the same time.\n\n Required Keys:\n\n - img\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_masks (BitmapMasks | PolygonMasks) (optional)\n - gt_seg_map (np.uint8) (optional)\n\n Modified Keys:\n\n - img\n - img_shape\n - gt_masks\n - gt_seg_map\n\n Added Keys:\n\n - pad_shape\n - pad_fixed_size\n - pad_size_divisor\n\n Args:\n size (tuple, optional): Fixed padding size.\n Expected padding shape (width, height). Defaults to None.\n size_divisor (int, optional): The divisor of padded size. Defaults to\n None.\n pad_to_square (bool): Whether to pad the image into a square.\n Currently only used for YOLOX. Defaults to False.\n pad_val (Number | dict[str, Number], optional) - Padding value for if\n the pad_mode is \"constant\". If it is a single number, the value\n to pad the image is the number and to pad the semantic\n segmentation map is 255. If it is a dict, it should have the\n following keys:\n\n - img: The value to pad the image.\n - seg: The value to pad the semantic segmentation map.\n Defaults to dict(img=0, seg=255).\n padding_mode (str): Type of padding. Should be: constant, edge,\n reflect or symmetric. Defaults to 'constant'.\n\n - constant: pads with a constant value, this value is specified\n with pad_val.\n - edge: pads with the last value at the edge of the image.\n - reflect: pads with reflection of image without repeating the last\n value on the edge. For example, padding [1, 2, 3, 4] with 2\n elements on both sides in reflect mode will result in\n [3, 2, 1, 2, 3, 4, 3, 2].\n - symmetric: pads with reflection of image repeating the last value\n on the edge. For example, padding [1, 2, 3, 4] with 2 elements on\n both sides in symmetric mode will result in\n [2, 1, 1, 2, 3, 4, 4, 3]\n \"\"\"\n\n def _pad_masks(self, results: dict) -> None:\n \"\"\"Pad masks according to ``results['pad_shape']``.\"\"\"\n if results.get('gt_masks', None) is not None:\n pad_val = self.pad_val.get('masks', 0)\n pad_shape = results['pad_shape'][:2]\n results['gt_masks'] = results['gt_masks'].pad(\n pad_shape, pad_val=pad_val)\n\n def transform(self, results: dict) -> dict:\n \"\"\"Call function to pad images, masks, semantic segmentation maps.\n\n Args:\n results (dict): Result dict from loading pipeline.\n\n Returns:\n dict: Updated result dict.\n \"\"\"\n self._pad_img(results)\n self._pad_seg(results)\n self._pad_masks(results)\n return results\n\n\n@TRANSFORMS.register_module()\nclass RandomCrop(BaseTransform):\n \"\"\"Random crop the image & bboxes & masks.\n\n The absolute ``crop_size`` is sampled based on ``crop_type`` and\n ``image_size``, then the cropped results are generated.\n\n Required Keys:\n\n - img\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_bboxes_labels (np.int64) (optional)\n - gt_masks (BitmapMasks | PolygonMasks) (optional)\n - gt_ignore_flags (bool) (optional)\n - gt_seg_map (np.uint8) (optional)\n\n Modified Keys:\n\n - img\n - img_shape\n - gt_bboxes (optional)\n - gt_bboxes_labels (optional)\n - gt_masks (optional)\n - gt_ignore_flags (optional)\n - gt_seg_map (optional)\n - gt_instances_ids (options, only used in MOT/VIS)\n\n Added Keys:\n\n - homography_matrix\n\n Args:\n crop_size (tuple): The relative ratio or absolute pixels of\n (width, height).\n crop_type (str, optional): One of \"relative_range\", \"relative\",\n \"absolute\", \"absolute_range\". \"relative\" randomly crops\n (h * crop_size[0], w * crop_size[1]) part from an input of size\n (h, w). \"relative_range\" uniformly samples relative crop size from\n range [crop_size[0], 1] and [crop_size[1], 1] for height and width\n respectively. \"absolute\" crops from an input with absolute size\n (crop_size[0], crop_size[1]). \"absolute_range\" uniformly samples\n crop_h in range [crop_size[0], min(h, crop_size[1])] and crop_w\n in range [crop_size[0], min(w, crop_size[1])].\n Defaults to \"absolute\".\n allow_negative_crop (bool, optional): Whether to allow a crop that does\n not contain any bbox area. Defaults to False.\n recompute_bbox (bool, optional): Whether to re-compute the boxes based\n on cropped instance masks. Defaults to False.\n bbox_clip_border (bool, optional): Whether clip the objects outside\n the border of the image. Defaults to True.\n\n Note:\n - If the image is smaller than the absolute crop size, return the\n original image.\n - The keys for bboxes, labels and masks must be aligned. That is,\n ``gt_bboxes`` corresponds to ``gt_labels`` and ``gt_masks``, and\n ``gt_bboxes_ignore`` corresponds to ``gt_labels_ignore`` and\n ``gt_masks_ignore``.\n - If the crop does not contain any gt-bbox region and\n ``allow_negative_crop`` is set to False, skip this image.\n \"\"\"\n\n def __init__(self,\n crop_size: tuple,\n crop_type: str = 'absolute',\n allow_negative_crop: bool = False,\n recompute_bbox: bool = False,\n bbox_clip_border: bool = True) -> None:\n if crop_type not in [\n 'relative_range', 'relative', 'absolute', 'absolute_range'\n ]:\n raise ValueError(f'Invalid crop_type {crop_type}.')\n if crop_type in ['absolute', 'absolute_range']:\n assert crop_size[0] > 0 and crop_size[1] > 0\n assert isinstance(crop_size[0], int) and isinstance(\n crop_size[1], int)\n if crop_type == 'absolute_range':\n assert crop_size[0] <= crop_size[1]\n else:\n assert 0 < crop_size[0] <= 1 and 0 < crop_size[1] <= 1\n self.crop_size = crop_size\n self.crop_type = crop_type\n self.allow_negative_crop = allow_negative_crop\n self.bbox_clip_border = bbox_clip_border\n self.recompute_bbox = recompute_bbox\n\n def _crop_data(self, results: dict, crop_size: Tuple[int, int],\n allow_negative_crop: bool) -> Union[dict, None]:\n \"\"\"Function to randomly crop images, bounding boxes, masks, semantic\n segmentation maps.\n\n Args:\n results (dict): Result dict from loading pipeline.\n crop_size (Tuple[int, int]): Expected absolute size after\n cropping, (h, w).\n allow_negative_crop (bool): Whether to allow a crop that does not\n contain any bbox area.\n\n Returns:\n results (Union[dict, None]): Randomly cropped results, 'img_shape'\n key in result dict is updated according to crop size. None will\n be returned when there is no valid bbox after cropping.\n \"\"\"\n assert crop_size[0] > 0 and crop_size[1] > 0\n img = results['img']\n margin_h = max(img.shape[0] - crop_size[0], 0)\n margin_w = max(img.shape[1] - crop_size[1], 0)\n offset_h, offset_w = self._rand_offset((margin_h, margin_w))\n crop_y1, crop_y2 = offset_h, offset_h + crop_size[0]\n crop_x1, crop_x2 = offset_w, offset_w + crop_size[1]\n\n # Record the homography matrix for the RandomCrop\n homography_matrix = np.array(\n [[1, 0, -offset_w], [0, 1, -offset_h], [0, 0, 1]],\n dtype=np.float32)\n if results.get('homography_matrix', None) is None:\n results['homography_matrix'] = homography_matrix\n else:\n results['homography_matrix'] = homography_matrix @ results[\n 'homography_matrix']\n\n # crop the image\n img = img[crop_y1:crop_y2, crop_x1:crop_x2, ...]\n img_shape = img.shape\n results['img'] = img\n results['img_shape'] = img_shape[:2]\n\n # crop bboxes accordingly and clip to the image boundary\n if results.get('gt_bboxes', None) is not None:\n bboxes = results['gt_bboxes']\n bboxes.translate_([-offset_w, -offset_h])\n if self.bbox_clip_border:\n bboxes.clip_(img_shape[:2])\n valid_inds = bboxes.is_inside(img_shape[:2]).numpy()\n # If the crop does not contain any gt-bbox area and\n # allow_negative_crop is False, skip this image.\n if (not valid_inds.any() and not allow_negative_crop):\n return None\n\n results['gt_bboxes'] = bboxes[valid_inds]\n\n if results.get('gt_ignore_flags', None) is not None:\n results['gt_ignore_flags'] = \\\n results['gt_ignore_flags'][valid_inds]\n\n if results.get('gt_bboxes_labels', None) is not None:\n results['gt_bboxes_labels'] = \\\n results['gt_bboxes_labels'][valid_inds]\n\n if results.get('gt_masks', None) is not None:\n results['gt_masks'] = results['gt_masks'][\n valid_inds.nonzero()[0]].crop(\n np.asarray([crop_x1, crop_y1, crop_x2, crop_y2]))\n if self.recompute_bbox:\n results['gt_bboxes'] = results['gt_masks'].get_bboxes(\n type(results['gt_bboxes']))\n\n # We should remove the instance ids corresponding to invalid boxes.\n if results.get('gt_instances_ids', None) is not None:\n results['gt_instances_ids'] = \\\n results['gt_instances_ids'][valid_inds]\n\n # crop semantic seg\n if results.get('gt_seg_map', None) is not None:\n results['gt_seg_map'] = results['gt_seg_map'][crop_y1:crop_y2,\n crop_x1:crop_x2]\n\n return results\n\n @cache_randomness\n def _rand_offset(self, margin: Tuple[int, int]) -> Tuple[int, int]:\n \"\"\"Randomly generate crop offset.\n\n Args:\n margin (Tuple[int, int]): The upper bound for the offset generated\n randomly.\n\n Returns:\n Tuple[int, int]: The random offset for the crop.\n \"\"\"\n margin_h, margin_w = margin\n offset_h = np.random.randint(0, margin_h + 1)\n offset_w = np.random.randint(0, margin_w + 1)\n\n return offset_h, offset_w\n\n @cache_randomness\n def _get_crop_size(self, image_size: Tuple[int, int]) -> Tuple[int, int]:\n \"\"\"Randomly generates the absolute crop size based on `crop_type` and\n `image_size`.\n\n Args:\n image_size (Tuple[int, int]): (h, w).\n\n Returns:\n crop_size (Tuple[int, int]): (crop_h, crop_w) in absolute pixels.\n \"\"\"\n h, w = image_size\n if self.crop_type == 'absolute':\n return min(self.crop_size[1], h), min(self.crop_size[0], w)\n elif self.crop_type == 'absolute_range':\n crop_h = np.random.randint(\n min(h, self.crop_size[0]),\n min(h, self.crop_size[1]) + 1)\n crop_w = np.random.randint(\n min(w, self.crop_size[0]),\n min(w, self.crop_size[1]) + 1)\n return crop_h, crop_w\n elif self.crop_type == 'relative':\n crop_w, crop_h = self.crop_size\n return int(h * crop_h + 0.5), int(w * crop_w + 0.5)\n else:\n # 'relative_range'\n crop_size = np.asarray(self.crop_size, dtype=np.float32)\n crop_h, crop_w = crop_size + np.random.rand(2) * (1 - crop_size)\n return int(h * crop_h + 0.5), int(w * crop_w + 0.5)\n\n @autocast_box_type()\n def transform(self, results: dict) -> Union[dict, None]:\n \"\"\"Transform function to randomly crop images, bounding boxes, masks,\n semantic segmentation maps.\n\n Args:\n results (dict): Result dict from loading pipeline.\n\n Returns:\n results (Union[dict, None]): Randomly cropped results, 'img_shape'\n key in result dict is updated according to crop size. None will\n be returned when there is no valid bbox after cropping.\n \"\"\"\n image_size = results['img'].shape[:2]\n crop_size = self._get_crop_size(image_size)\n results = self._crop_data(results, crop_size, self.allow_negative_crop)\n return results\n\n def __repr__(self) -> str:\n repr_str = self.__class__.__name__\n repr_str += f'(crop_size={self.crop_size}, '\n repr_str += f'crop_type={self.crop_type}, '\n repr_str += f'allow_negative_crop={self.allow_negative_crop}, '\n repr_str += f'recompute_bbox={self.recompute_bbox}, '\n repr_str += f'bbox_clip_border={self.bbox_clip_border})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass SegRescale(BaseTransform):\n \"\"\"Rescale semantic segmentation maps.\n\n This transform rescale the ``gt_seg_map`` according to ``scale_factor``.\n\n Required Keys:\n\n - gt_seg_map\n\n Modified Keys:\n\n - gt_seg_map\n\n Args:\n scale_factor (float): The scale factor of the final output. Defaults\n to 1.\n backend (str): Image rescale backend, choices are 'cv2' and 'pillow'.\n These two backends generates slightly different results. Defaults\n to 'cv2'.\n \"\"\"\n\n def __init__(self, scale_factor: float = 1, backend: str = 'cv2') -> None:\n self.scale_factor = scale_factor\n self.backend = backend\n\n def transform(self, results: dict) -> dict:\n \"\"\"Transform function to scale the semantic segmentation map.\n\n Args:\n results (dict): Result dict from loading pipeline.\n\n Returns:\n dict: Result dict with semantic segmentation map scaled.\n \"\"\"\n if self.scale_factor != 1:\n results['gt_seg_map'] = mmcv.imrescale(\n results['gt_seg_map'],\n self.scale_factor,\n interpolation='nearest',\n backend=self.backend)\n\n return results\n\n def __repr__(self) -> str:\n repr_str = self.__class__.__name__\n repr_str += f'(scale_factor={self.scale_factor}, '\n repr_str += f'backend={self.backend})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass PhotoMetricDistortion(BaseTransform):\n \"\"\"Apply photometric distortion to image sequentially, every transformation\n is applied with a probability of 0.5. The position of random contrast is in\n second or second to last.\n\n 1. random brightness\n 2. random contrast (mode 0)\n 3. convert color from BGR to HSV\n 4. random saturation\n 5. random hue\n 6. convert color from HSV to BGR\n 7. random contrast (mode 1)\n 8. randomly swap channels\n\n Required Keys:\n\n - img (np.uint8)\n\n Modified Keys:\n\n - img (np.float32)\n\n Args:\n brightness_delta (int): delta of brightness.\n contrast_range (sequence): range of contrast.\n saturation_range (sequence): range of saturation.\n hue_delta (int): delta of hue.\n \"\"\"\n\n def __init__(self,\n brightness_delta: int = 32,\n contrast_range: Sequence[Number] = (0.5, 1.5),\n saturation_range: Sequence[Number] = (0.5, 1.5),\n hue_delta: int = 18) -> None:\n self.brightness_delta = brightness_delta\n self.contrast_lower, self.contrast_upper = contrast_range\n self.saturation_lower, self.saturation_upper = saturation_range\n self.hue_delta = hue_delta\n\n @cache_randomness\n def _random_flags(self) -> Sequence[Number]:\n mode = random.randint(2)\n brightness_flag = random.randint(2)\n contrast_flag = random.randint(2)\n saturation_flag = random.randint(2)\n hue_flag = random.randint(2)\n swap_flag = random.randint(2)\n delta_value = random.uniform(-self.brightness_delta,\n self.brightness_delta)\n alpha_value = random.uniform(self.contrast_lower, self.contrast_upper)\n saturation_value = random.uniform(self.saturation_lower,\n self.saturation_upper)\n hue_value = random.uniform(-self.hue_delta, self.hue_delta)\n swap_value = random.permutation(3)\n\n return (mode, brightness_flag, contrast_flag, saturation_flag,\n hue_flag, swap_flag, delta_value, alpha_value,\n saturation_value, hue_value, swap_value)\n\n def transform(self, results: dict) -> dict:\n \"\"\"Transform function to perform photometric distortion on images.\n\n Args:\n results (dict): Result dict from loading pipeline.\n\n Returns:\n dict: Result dict with images distorted.\n \"\"\"\n assert 'img' in results, '`img` is not found in results'\n img = results['img']\n img = img.astype(np.float32)\n\n (mode, brightness_flag, contrast_flag, saturation_flag, hue_flag,\n swap_flag, delta_value, alpha_value, saturation_value, hue_value,\n swap_value) = self._random_flags()\n\n # random brightness\n if brightness_flag:\n img += delta_value\n\n # mode == 0 --> do random contrast first\n # mode == 1 --> do random contrast last\n if mode == 1:\n if contrast_flag:\n img *= alpha_value\n\n # convert color from BGR to HSV\n img = mmcv.bgr2hsv(img)\n\n # random saturation\n if saturation_flag:\n img[..., 1] *= saturation_value\n # For image(type=float32), after convert bgr to hsv by opencv,\n # valid saturation value range is [0, 1]\n if saturation_value > 1:\n img[..., 1] = img[..., 1].clip(0, 1)\n\n # random hue\n if hue_flag:\n img[..., 0] += hue_value\n img[..., 0][img[..., 0] > 360] -= 360\n img[..., 0][img[..., 0] < 0] += 360\n\n # convert color from HSV to BGR\n img = mmcv.hsv2bgr(img)\n\n # random contrast\n if mode == 0:\n if contrast_flag:\n img *= alpha_value\n\n # randomly swap channels\n if swap_flag:\n img = img[..., swap_value]\n\n results['img'] = img\n return results\n\n def __repr__(self) -> str:\n repr_str = self.__class__.__name__\n repr_str += f'(brightness_delta={self.brightness_delta}, '\n repr_str += 'contrast_range='\n repr_str += f'{(self.contrast_lower, self.contrast_upper)}, '\n repr_str += 'saturation_range='\n repr_str += f'{(self.saturation_lower, self.saturation_upper)}, '\n repr_str += f'hue_delta={self.hue_delta})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass Expand(BaseTransform):\n \"\"\"Random expand the image & bboxes & masks & segmentation map.\n\n Randomly place the original image on a canvas of ``ratio`` x original image\n size filled with mean values. The ratio is in the range of ratio_range.\n\n Required Keys:\n\n - img\n - img_shape\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_masks (BitmapMasks | PolygonMasks) (optional)\n - gt_seg_map (np.uint8) (optional)\n\n Modified Keys:\n\n - img\n - img_shape\n - gt_bboxes\n - gt_masks\n - gt_seg_map\n\n\n Args:\n mean (sequence): mean value of dataset.\n to_rgb (bool): if need to convert the order of mean to align with RGB.\n ratio_range (sequence)): range of expand ratio.\n seg_ignore_label (int): label of ignore segmentation map.\n prob (float): probability of applying this transformation\n \"\"\"\n\n def __init__(self,\n mean: Sequence[Number] = (0, 0, 0),\n to_rgb: bool = True,\n ratio_range: Sequence[Number] = (1, 4),\n seg_ignore_label: int = None,\n prob: float = 0.5) -> None:\n self.to_rgb = to_rgb\n self.ratio_range = ratio_range\n if to_rgb:\n self.mean = mean[::-1]\n else:\n self.mean = mean\n self.min_ratio, self.max_ratio = ratio_range\n self.seg_ignore_label = seg_ignore_label\n self.prob = prob\n\n @cache_randomness\n def _random_prob(self) -> float:\n return random.uniform(0, 1)\n\n @cache_randomness\n def _random_ratio(self) -> float:\n return random.uniform(self.min_ratio, self.max_ratio)\n\n @cache_randomness\n def _random_left_top(self, ratio: float, h: int,\n w: int) -> Tuple[int, int]:\n left = int(random.uniform(0, w * ratio - w))\n top = int(random.uniform(0, h * ratio - h))\n return left, top\n\n @autocast_box_type()\n def transform(self, results: dict) -> dict:\n \"\"\"Transform function to expand images, bounding boxes, masks,\n segmentation map.\n\n Args:\n results (dict): Result dict from loading pipeline.\n\n Returns:\n dict: Result dict with images, bounding boxes, masks, segmentation\n map expanded.\n \"\"\"\n if self._random_prob() > self.prob:\n return results\n assert 'img' in results, '`img` is not found in results'\n img = results['img']\n h, w, c = img.shape\n ratio = self._random_ratio()\n # speedup expand when meets large image\n if np.all(self.mean == self.mean[0]):\n expand_img = np.empty((int(h * ratio), int(w * ratio), c),\n img.dtype)\n expand_img.fill(self.mean[0])\n else:\n expand_img = np.full((int(h * ratio), int(w * ratio), c),\n self.mean,\n dtype=img.dtype)\n left, top = self._random_left_top(ratio, h, w)\n expand_img[top:top + h, left:left + w] = img\n results['img'] = expand_img\n results['img_shape'] = expand_img.shape[:2]\n\n # expand bboxes\n if results.get('gt_bboxes', None) is not None:\n results['gt_bboxes'].translate_([left, top])\n\n # expand masks\n if results.get('gt_masks', None) is not None:\n results['gt_masks'] = results['gt_masks'].expand(\n int(h * ratio), int(w * ratio), top, left)\n\n # expand segmentation map\n if results.get('gt_seg_map', None) is not None:\n gt_seg = results['gt_seg_map']\n expand_gt_seg = np.full((int(h * ratio), int(w * ratio)),\n self.seg_ignore_label,\n dtype=gt_seg.dtype)\n expand_gt_seg[top:top + h, left:left + w] = gt_seg\n results['gt_seg_map'] = expand_gt_seg\n\n return results\n\n def __repr__(self) -> str:\n repr_str = self.__class__.__name__\n repr_str += f'(mean={self.mean}, to_rgb={self.to_rgb}, '\n repr_str += f'ratio_range={self.ratio_range}, '\n repr_str += f'seg_ignore_label={self.seg_ignore_label}, '\n repr_str += f'prob={self.prob})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass MinIoURandomCrop(BaseTransform):\n \"\"\"Random crop the image & bboxes & masks & segmentation map, the cropped\n patches have minimum IoU requirement with original image & bboxes & masks.\n\n & segmentation map, the IoU threshold is randomly selected from min_ious.\n\n\n Required Keys:\n\n - img\n - img_shape\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_bboxes_labels (np.int64) (optional)\n - gt_masks (BitmapMasks | PolygonMasks) (optional)\n - gt_ignore_flags (bool) (optional)\n - gt_seg_map (np.uint8) (optional)\n\n Modified Keys:\n\n - img\n - img_shape\n - gt_bboxes\n - gt_bboxes_labels\n - gt_masks\n - gt_ignore_flags\n - gt_seg_map\n\n\n Args:\n min_ious (Sequence[float]): minimum IoU threshold for all intersections\n with bounding boxes.\n min_crop_size (float): minimum crop's size (i.e. h,w := a*h, a*w,\n where a >= min_crop_size).\n bbox_clip_border (bool, optional): Whether clip the objects outside\n the border of the image. Defaults to True.\n \"\"\"\n\n def __init__(self,\n min_ious: Sequence[float] = (0.1, 0.3, 0.5, 0.7, 0.9),\n min_crop_size: float = 0.3,\n bbox_clip_border: bool = True) -> None:\n\n self.min_ious = min_ious\n self.sample_mode = (1, *min_ious, 0)\n self.min_crop_size = min_crop_size\n self.bbox_clip_border = bbox_clip_border\n\n @cache_randomness\n def _random_mode(self) -> Number:\n return random.choice(self.sample_mode)\n\n @autocast_box_type()\n def transform(self, results: dict) -> dict:\n \"\"\"Transform function to crop images and bounding boxes with minimum\n IoU constraint.\n\n Args:\n results (dict): Result dict from loading pipeline.\n\n Returns:\n dict: Result dict with images and bounding boxes cropped, \\\n 'img_shape' key is updated.\n \"\"\"\n assert 'img' in results, '`img` is not found in results'\n assert 'gt_bboxes' in results, '`gt_bboxes` is not found in results'\n img = results['img']\n boxes = results['gt_bboxes']\n h, w, c = img.shape\n while True:\n mode = self._random_mode()\n self.mode = mode\n if mode == 1:\n return results\n\n min_iou = self.mode\n for i in range(50):\n new_w = random.uniform(self.min_crop_size * w, w)\n new_h = random.uniform(self.min_crop_size * h, h)\n\n # h / w in [0.5, 2]\n if new_h / new_w < 0.5 or new_h / new_w > 2:\n continue\n\n left = random.uniform(w - new_w)\n top = random.uniform(h - new_h)\n\n patch = np.array(\n (int(left), int(top), int(left + new_w), int(top + new_h)))\n # Line or point crop is not allowed\n if patch[2] == patch[0] or patch[3] == patch[1]:\n continue\n overlaps = boxes.overlaps(\n HorizontalBoxes(patch.reshape(-1, 4).astype(np.float32)),\n boxes).numpy().reshape(-1)\n if len(overlaps) > 0 and overlaps.min() < min_iou:\n continue\n\n # center of boxes should inside the crop img\n # only adjust boxes and instance masks when the gt is not empty\n if len(overlaps) > 0:\n # adjust boxes\n def is_center_of_bboxes_in_patch(boxes, patch):\n centers = boxes.centers.numpy()\n mask = ((centers[:, 0] > patch[0]) *\n (centers[:, 1] > patch[1]) *\n (centers[:, 0] < patch[2]) *\n (centers[:, 1] < patch[3]))\n return mask\n\n mask = is_center_of_bboxes_in_patch(boxes, patch)\n if not mask.any():\n continue\n if results.get('gt_bboxes', None) is not None:\n boxes = results['gt_bboxes']\n mask = is_center_of_bboxes_in_patch(boxes, patch)\n boxes = boxes[mask]\n boxes.translate_([-patch[0], -patch[1]])\n if self.bbox_clip_border:\n boxes.clip_(\n [patch[3] - patch[1], patch[2] - patch[0]])\n results['gt_bboxes'] = boxes\n\n # ignore_flags\n if results.get('gt_ignore_flags', None) is not None:\n results['gt_ignore_flags'] = \\\n results['gt_ignore_flags'][mask]\n\n # labels\n if results.get('gt_bboxes_labels', None) is not None:\n results['gt_bboxes_labels'] = results[\n 'gt_bboxes_labels'][mask]\n\n # mask fields\n if results.get('gt_masks', None) is not None:\n results['gt_masks'] = results['gt_masks'][\n mask.nonzero()[0]].crop(patch)\n # adjust the img no matter whether the gt is empty before crop\n img = img[patch[1]:patch[3], patch[0]:patch[2]]\n results['img'] = img\n results['img_shape'] = img.shape[:2]\n\n # seg fields\n if results.get('gt_seg_map', None) is not None:\n results['gt_seg_map'] = results['gt_seg_map'][\n patch[1]:patch[3], patch[0]:patch[2]]\n return results\n\n def __repr__(self) -> str:\n repr_str = self.__class__.__name__\n repr_str += f'(min_ious={self.min_ious}, '\n repr_str += f'min_crop_size={self.min_crop_size}, '\n repr_str += f'bbox_clip_border={self.bbox_clip_border})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass Corrupt(BaseTransform):\n \"\"\"Corruption augmentation.\n\n Corruption transforms implemented based on\n `imagecorruptions <https://github.com/bethgelab/imagecorruptions>`_.\n\n Required Keys:\n\n - img (np.uint8)\n\n\n Modified Keys:\n\n - img (np.uint8)\n\n\n Args:\n corruption (str): Corruption name.\n severity (int): The severity of corruption. Defaults to 1.\n \"\"\"\n\n def __init__(self, corruption: str, severity: int = 1) -> None:\n self.corruption = corruption\n self.severity = severity\n\n def transform(self, results: dict) -> dict:\n \"\"\"Call function to corrupt image.\n\n Args:\n results (dict): Result dict from loading pipeline.\n\n Returns:\n dict: Result dict with images corrupted.\n \"\"\"\n\n if corrupt is None:\n raise RuntimeError('imagecorruptions is not installed')\n results['img'] = corrupt(\n results['img'].astype(np.uint8),\n corruption_name=self.corruption,\n severity=self.severity)\n return results\n\n def __repr__(self) -> str:\n repr_str = self.__class__.__name__\n repr_str += f'(corruption={self.corruption}, '\n repr_str += f'severity={self.severity})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\n@avoid_cache_randomness\nclass Albu(BaseTransform):\n \"\"\"Albumentation augmentation.\n\n Adds custom transformations from Albumentations library.\n Please, visit `https://albumentations.readthedocs.io`\n to get more information.\n\n Required Keys:\n\n - img (np.uint8)\n - gt_bboxes (HorizontalBoxes[torch.float32]) (optional)\n - gt_masks (BitmapMasks | PolygonMasks) (optional)\n\n Modified Keys:\n\n - img (np.uint8)\n - gt_bboxes (HorizontalBoxes[torch.float32]) (optional)\n - gt_masks (BitmapMasks | PolygonMasks) (optional)\n - img_shape (tuple)\n\n An example of ``transforms`` is as followed:\n\n .. code-block::\n\n [\n dict(\n type='ShiftScaleRotate',\n shift_limit=0.0625,\n scale_limit=0.0,\n rotate_limit=0,\n interpolation=1,\n p=0.5),\n dict(\n type='RandomBrightnessContrast',\n brightness_limit=[0.1, 0.3],\n contrast_limit=[0.1, 0.3],\n p=0.2),\n dict(type='ChannelShuffle', p=0.1),\n dict(\n type='OneOf',\n transforms=[\n dict(type='Blur', blur_limit=3, p=1.0),\n dict(type='MedianBlur', blur_limit=3, p=1.0)\n ],\n p=0.1),\n ]\n\n Args:\n transforms (list[dict]): A list of albu transformations\n bbox_params (dict, optional): Bbox_params for albumentation `Compose`\n keymap (dict, optional): Contains\n {'input key':'albumentation-style key'}\n skip_img_without_anno (bool): Whether to skip the image if no ann left\n after aug. Defaults to False.\n \"\"\"\n\n def __init__(self,\n transforms: List[dict],\n bbox_params: Optional[dict] = None,\n keymap: Optional[dict] = None,\n skip_img_without_anno: bool = False) -> None:\n if Compose is None:\n raise RuntimeError('albumentations is not installed')\n\n # Args will be modified later, copying it will be safer\n transforms = copy.deepcopy(transforms)\n if bbox_params is not None:\n bbox_params = copy.deepcopy(bbox_params)\n if keymap is not None:\n keymap = copy.deepcopy(keymap)\n self.transforms = transforms\n self.filter_lost_elements = False\n self.skip_img_without_anno = skip_img_without_anno\n\n # A simple workaround to remove masks without boxes\n if (isinstance(bbox_params, dict) and 'label_fields' in bbox_params\n and 'filter_lost_elements' in bbox_params):\n self.filter_lost_elements = True\n self.origin_label_fields = bbox_params['label_fields']\n bbox_params['label_fields'] = ['idx_mapper']\n del bbox_params['filter_lost_elements']\n\n self.bbox_params = (\n self.albu_builder(bbox_params) if bbox_params else None)\n self.aug = Compose([self.albu_builder(t) for t in self.transforms],\n bbox_params=self.bbox_params)\n\n if not keymap:\n self.keymap_to_albu = {\n 'img': 'image',\n 'gt_masks': 'masks',\n 'gt_bboxes': 'bboxes'\n }\n else:\n self.keymap_to_albu = keymap\n self.keymap_back = {v: k for k, v in self.keymap_to_albu.items()}\n\n def albu_builder(self, cfg: dict) -> albumentations:\n \"\"\"Import a module from albumentations.\n\n It inherits some of :func:`build_from_cfg` logic.\n\n Args:\n cfg (dict): Config dict. It should at least contain the key \"type\".\n\n Returns:\n obj: The constructed object.\n \"\"\"\n\n assert isinstance(cfg, dict) and 'type' in cfg\n args = cfg.copy()\n obj_type = args.pop('type')\n if is_str(obj_type):\n if albumentations is None:\n raise RuntimeError('albumentations is not installed')\n obj_cls = getattr(albumentations, obj_type)\n elif inspect.isclass(obj_type):\n obj_cls = obj_type\n else:\n raise TypeError(\n f'type must be a str or valid type, but got {type(obj_type)}')\n\n if 'transforms' in args:\n args['transforms'] = [\n self.albu_builder(transform)\n for transform in args['transforms']\n ]\n\n return obj_cls(**args)\n\n @staticmethod\n def mapper(d: dict, keymap: dict) -> dict:\n \"\"\"Dictionary mapper. Renames keys according to keymap provided.\n\n Args:\n d (dict): old dict\n keymap (dict): {'old_key':'new_key'}\n Returns:\n dict: new dict.\n \"\"\"\n updated_dict = {}\n for k, v in zip(d.keys(), d.values()):\n new_k = keymap.get(k, k)\n updated_dict[new_k] = d[k]\n return updated_dict\n\n @autocast_box_type()\n def transform(self, results: dict) -> Union[dict, None]:\n \"\"\"Transform function of Albu.\"\"\"\n # TODO: gt_seg_map is not currently supported\n # dict to albumentations format\n results = self.mapper(results, self.keymap_to_albu)\n results, ori_masks = self._preprocess_results(results)\n results = self.aug(**results)\n results = self._postprocess_results(results, ori_masks)\n if results is None:\n return None\n # back to the original format\n results = self.mapper(results, self.keymap_back)\n results['img_shape'] = results['img'].shape[:2]\n return results\n\n def _preprocess_results(self, results: dict) -> tuple:\n \"\"\"Pre-processing results to facilitate the use of Albu.\"\"\"\n if 'bboxes' in results:\n # to list of boxes\n if not isinstance(results['bboxes'], HorizontalBoxes):\n raise NotImplementedError(\n 'Albu only supports horizontal boxes now')\n bboxes = results['bboxes'].numpy()\n results['bboxes'] = [x for x in bboxes]\n # add pseudo-field for filtration\n if self.filter_lost_elements:\n results['idx_mapper'] = np.arange(len(results['bboxes']))\n\n # TODO: Support mask structure in albu\n ori_masks = None\n if 'masks' in results:\n if isinstance(results['masks'], PolygonMasks):\n raise NotImplementedError(\n 'Albu only supports BitMap masks now')\n ori_masks = results['masks']\n if albumentations.__version__ < '0.5':\n results['masks'] = results['masks'].masks\n else:\n results['masks'] = [mask for mask in results['masks'].masks]\n\n return results, ori_masks\n\n def _postprocess_results(\n self,\n results: dict,\n ori_masks: Optional[Union[BitmapMasks,\n PolygonMasks]] = None) -> dict:\n \"\"\"Post-processing Albu output.\"\"\"\n # albumentations may return np.array or list on different versions\n if 'gt_bboxes_labels' in results and isinstance(\n results['gt_bboxes_labels'], list):\n results['gt_bboxes_labels'] = np.array(\n results['gt_bboxes_labels'], dtype=np.int64)\n if 'gt_ignore_flags' in results and isinstance(\n results['gt_ignore_flags'], list):\n results['gt_ignore_flags'] = np.array(\n results['gt_ignore_flags'], dtype=bool)\n\n if 'bboxes' in results:\n if isinstance(results['bboxes'], list):\n results['bboxes'] = np.array(\n results['bboxes'], dtype=np.float32)\n results['bboxes'] = results['bboxes'].reshape(-1, 4)\n results['bboxes'] = HorizontalBoxes(results['bboxes'])\n\n # filter label_fields\n if self.filter_lost_elements:\n\n for label in self.origin_label_fields:\n results[label] = np.array(\n [results[label][i] for i in results['idx_mapper']])\n if 'masks' in results:\n assert ori_masks is not None\n results['masks'] = np.array(\n [results['masks'][i] for i in results['idx_mapper']])\n results['masks'] = ori_masks.__class__(\n results['masks'], ori_masks.height, ori_masks.width)\n\n if (not len(results['idx_mapper'])\n and self.skip_img_without_anno):\n return None\n elif 'masks' in results:\n results['masks'] = ori_masks.__class__(results['masks'],\n ori_masks.height,\n ori_masks.width)\n\n return results\n\n def __repr__(self) -> str:\n repr_str = self.__class__.__name__ + f'(transforms={self.transforms})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\n@avoid_cache_randomness\nclass RandomCenterCropPad(BaseTransform):\n \"\"\"Random center crop and random around padding for CornerNet.\n\n This operation generates randomly cropped image from the original image and\n pads it simultaneously. Different from :class:`RandomCrop`, the output\n shape may not equal to ``crop_size`` strictly. We choose a random value\n from ``ratios`` and the output shape could be larger or smaller than\n ``crop_size``. The padding operation is also different from :class:`Pad`,\n here we use around padding instead of right-bottom padding.\n\n The relation between output image (padding image) and original image:\n\n .. code:: text\n\n output image\n\n +----------------------------+\n | padded area |\n +------|----------------------------|----------+\n | | cropped area | |\n | | +---------------+ | |\n | | | . center | | | original image\n | | | range | | |\n | | +---------------+ | |\n +------|----------------------------|----------+\n | padded area |\n +----------------------------+\n\n There are 5 main areas in the figure:\n\n - output image: output image of this operation, also called padding\n image in following instruction.\n - original image: input image of this operation.\n - padded area: non-intersect area of output image and original image.\n - cropped area: the overlap of output image and original image.\n - center range: a smaller area where random center chosen from.\n center range is computed by ``border`` and original image's shape\n to avoid our random center is too close to original image's border.\n\n Also this operation act differently in train and test mode, the summary\n pipeline is listed below.\n\n Train pipeline:\n\n 1. Choose a ``random_ratio`` from ``ratios``, the shape of padding image\n will be ``random_ratio * crop_size``.\n 2. Choose a ``random_center`` in center range.\n 3. Generate padding image with center matches the ``random_center``.\n 4. Initialize the padding image with pixel value equals to ``mean``.\n 5. Copy the cropped area to padding image.\n 6. Refine annotations.\n\n Test pipeline:\n\n 1. Compute output shape according to ``test_pad_mode``.\n 2. Generate padding image with center matches the original image\n center.\n 3. Initialize the padding image with pixel value equals to ``mean``.\n 4. Copy the ``cropped area`` to padding image.\n\n Required Keys:\n\n - img (np.float32)\n - img_shape (tuple)\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_bboxes_labels (np.int64) (optional)\n - gt_ignore_flags (bool) (optional)\n\n Modified Keys:\n\n - img (np.float32)\n - img_shape (tuple)\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_bboxes_labels (np.int64) (optional)\n - gt_ignore_flags (bool) (optional)\n\n Args:\n crop_size (tuple, optional): expected size after crop, final size will\n computed according to ratio. Requires (width, height)\n in train mode, and None in test mode.\n ratios (tuple, optional): random select a ratio from tuple and crop\n image to (crop_size[0] * ratio) * (crop_size[1] * ratio).\n Only available in train mode. Defaults to (0.9, 1.0, 1.1).\n border (int, optional): max distance from center select area to image\n border. Only available in train mode. Defaults to 128.\n mean (sequence, optional): Mean values of 3 channels.\n std (sequence, optional): Std values of 3 channels.\n to_rgb (bool, optional): Whether to convert the image from BGR to RGB.\n test_mode (bool): whether involve random variables in transform.\n In train mode, crop_size is fixed, center coords and ratio is\n random selected from predefined lists. In test mode, crop_size\n is image's original shape, center coords and ratio is fixed.\n Defaults to False.\n test_pad_mode (tuple, optional): padding method and padding shape\n value, only available in test mode. Default is using\n 'logical_or' with 127 as padding shape value.\n\n - 'logical_or': final_shape = input_shape | padding_shape_value\n - 'size_divisor': final_shape = int(\n ceil(input_shape / padding_shape_value) * padding_shape_value)\n\n Defaults to ('logical_or', 127).\n test_pad_add_pix (int): Extra padding pixel in test mode.\n Defaults to 0.\n bbox_clip_border (bool): Whether clip the objects outside\n the border of the image. Defaults to True.\n \"\"\"\n\n def __init__(self,\n crop_size: Optional[tuple] = None,\n ratios: Optional[tuple] = (0.9, 1.0, 1.1),\n border: Optional[int] = 128,\n mean: Optional[Sequence] = None,\n std: Optional[Sequence] = None,\n to_rgb: Optional[bool] = None,\n test_mode: bool = False,\n test_pad_mode: Optional[tuple] = ('logical_or', 127),\n test_pad_add_pix: int = 0,\n bbox_clip_border: bool = True) -> None:\n if test_mode:\n assert crop_size is None, 'crop_size must be None in test mode'\n assert ratios is None, 'ratios must be None in test mode'\n assert border is None, 'border must be None in test mode'\n assert isinstance(test_pad_mode, (list, tuple))\n assert test_pad_mode[0] in ['logical_or', 'size_divisor']\n else:\n assert isinstance(crop_size, (list, tuple))\n assert crop_size[0] > 0 and crop_size[1] > 0, (\n 'crop_size must > 0 in train mode')\n assert isinstance(ratios, (list, tuple))\n assert test_pad_mode is None, (\n 'test_pad_mode must be None in train mode')\n\n self.crop_size = crop_size\n self.ratios = ratios\n self.border = border\n # We do not set default value to mean, std and to_rgb because these\n # hyper-parameters are easy to forget but could affect the performance.\n # Please use the same setting as Normalize for performance assurance.\n assert mean is not None and std is not None and to_rgb is not None\n self.to_rgb = to_rgb\n self.input_mean = mean\n self.input_std = std\n if to_rgb:\n self.mean = mean[::-1]\n self.std = std[::-1]\n else:\n self.mean = mean\n self.std = std\n self.test_mode = test_mode\n self.test_pad_mode = test_pad_mode\n self.test_pad_add_pix = test_pad_add_pix\n self.bbox_clip_border = bbox_clip_border\n\n def _get_border(self, border, size):\n \"\"\"Get final border for the target size.\n\n This function generates a ``final_border`` according to image's shape.\n The area between ``final_border`` and ``size - final_border`` is the\n ``center range``. We randomly choose center from the ``center range``\n to avoid our random center is too close to original image's border.\n Also ``center range`` should be larger than 0.\n\n Args:\n border (int): The initial border, default is 128.\n size (int): The width or height of original image.\n Returns:\n int: The final border.\n \"\"\"\n k = 2 * border / size\n i = pow(2, np.ceil(np.log2(np.ceil(k))) + (k == int(k)))\n return border // i\n\n def _filter_boxes(self, patch, boxes):\n \"\"\"Check whether the center of each box is in the patch.\n\n Args:\n patch (list[int]): The cropped area, [left, top, right, bottom].\n boxes (numpy array, (N x 4)): Ground truth boxes.\n\n Returns:\n mask (numpy array, (N,)): Each box is inside or outside the patch.\n \"\"\"\n center = boxes.centers.numpy()\n mask = (center[:, 0] > patch[0]) * (center[:, 1] > patch[1]) * (\n center[:, 0] < patch[2]) * (\n center[:, 1] < patch[3])\n return mask\n\n def _crop_image_and_paste(self, image, center, size):\n \"\"\"Crop image with a given center and size, then paste the cropped\n image to a blank image with two centers align.\n\n This function is equivalent to generating a blank image with ``size``\n as its shape. Then cover it on the original image with two centers (\n the center of blank image and the random center of original image)\n aligned. The overlap area is paste from the original image and the\n outside area is filled with ``mean pixel``.\n\n Args:\n image (np array, H x W x C): Original image.\n center (list[int]): Target crop center coord.\n size (list[int]): Target crop size. [target_h, target_w]\n\n Returns:\n cropped_img (np array, target_h x target_w x C): Cropped image.\n border (np array, 4): The distance of four border of\n ``cropped_img`` to the original image area, [top, bottom,\n left, right]\n patch (list[int]): The cropped area, [left, top, right, bottom].\n \"\"\"\n center_y, center_x = center\n target_h, target_w = size\n img_h, img_w, img_c = image.shape\n\n x0 = max(0, center_x - target_w // 2)\n x1 = min(center_x + target_w // 2, img_w)\n y0 = max(0, center_y - target_h // 2)\n y1 = min(center_y + target_h // 2, img_h)\n patch = np.array((int(x0), int(y0), int(x1), int(y1)))\n\n left, right = center_x - x0, x1 - center_x\n top, bottom = center_y - y0, y1 - center_y\n\n cropped_center_y, cropped_center_x = target_h // 2, target_w // 2\n cropped_img = np.zeros((target_h, target_w, img_c), dtype=image.dtype)\n for i in range(img_c):\n cropped_img[:, :, i] += self.mean[i]\n y_slice = slice(cropped_center_y - top, cropped_center_y + bottom)\n x_slice = slice(cropped_center_x - left, cropped_center_x + right)\n cropped_img[y_slice, x_slice, :] = image[y0:y1, x0:x1, :]\n\n border = np.array([\n cropped_center_y - top, cropped_center_y + bottom,\n cropped_center_x - left, cropped_center_x + right\n ],\n dtype=np.float32)\n\n return cropped_img, border, patch\n\n def _train_aug(self, results):\n \"\"\"Random crop and around padding the original image.\n\n Args:\n results (dict): Image infomations in the augment pipeline.\n\n Returns:\n results (dict): The updated dict.\n \"\"\"\n img = results['img']\n h, w, c = img.shape\n gt_bboxes = results['gt_bboxes']\n while True:\n scale = random.choice(self.ratios)\n new_h = int(self.crop_size[1] * scale)\n new_w = int(self.crop_size[0] * scale)\n h_border = self._get_border(self.border, h)\n w_border = self._get_border(self.border, w)\n\n for i in range(50):\n center_x = random.randint(low=w_border, high=w - w_border)\n center_y = random.randint(low=h_border, high=h - h_border)\n\n cropped_img, border, patch = self._crop_image_and_paste(\n img, [center_y, center_x], [new_h, new_w])\n\n if len(gt_bboxes) == 0:\n results['img'] = cropped_img\n results['img_shape'] = cropped_img.shape[:2]\n return results\n\n # if image do not have valid bbox, any crop patch is valid.\n mask = self._filter_boxes(patch, gt_bboxes)\n if not mask.any():\n continue\n\n results['img'] = cropped_img\n results['img_shape'] = cropped_img.shape[:2]\n\n x0, y0, x1, y1 = patch\n\n left_w, top_h = center_x - x0, center_y - y0\n cropped_center_x, cropped_center_y = new_w // 2, new_h // 2\n\n # crop bboxes accordingly and clip to the image boundary\n gt_bboxes = gt_bboxes[mask]\n gt_bboxes.translate_([\n cropped_center_x - left_w - x0,\n cropped_center_y - top_h - y0\n ])\n if self.bbox_clip_border:\n gt_bboxes.clip_([new_h, new_w])\n keep = gt_bboxes.is_inside([new_h, new_w]).numpy()\n gt_bboxes = gt_bboxes[keep]\n\n results['gt_bboxes'] = gt_bboxes\n\n # ignore_flags\n if results.get('gt_ignore_flags', None) is not None:\n gt_ignore_flags = results['gt_ignore_flags'][mask]\n results['gt_ignore_flags'] = \\\n gt_ignore_flags[keep]\n\n # labels\n if results.get('gt_bboxes_labels', None) is not None:\n gt_labels = results['gt_bboxes_labels'][mask]\n results['gt_bboxes_labels'] = gt_labels[keep]\n\n if 'gt_masks' in results or 'gt_seg_map' in results:\n raise NotImplementedError(\n 'RandomCenterCropPad only supports bbox.')\n\n return results\n\n def _test_aug(self, results):\n \"\"\"Around padding the original image without cropping.\n\n The padding mode and value are from ``test_pad_mode``.\n\n Args:\n results (dict): Image infomations in the augment pipeline.\n\n Returns:\n results (dict): The updated dict.\n \"\"\"\n img = results['img']\n h, w, c = img.shape\n if self.test_pad_mode[0] in ['logical_or']:\n # self.test_pad_add_pix is only used for centernet\n target_h = (h | self.test_pad_mode[1]) + self.test_pad_add_pix\n target_w = (w | self.test_pad_mode[1]) + self.test_pad_add_pix\n elif self.test_pad_mode[0] in ['size_divisor']:\n divisor = self.test_pad_mode[1]\n target_h = int(np.ceil(h / divisor)) * divisor\n target_w = int(np.ceil(w / divisor)) * divisor\n else:\n raise NotImplementedError(\n 'RandomCenterCropPad only support two testing pad mode:'\n 'logical-or and size_divisor.')\n\n cropped_img, border, _ = self._crop_image_and_paste(\n img, [h // 2, w // 2], [target_h, target_w])\n results['img'] = cropped_img\n results['img_shape'] = cropped_img.shape[:2]\n results['border'] = border\n return results\n\n @autocast_box_type()\n def transform(self, results: dict) -> dict:\n img = results['img']\n assert img.dtype == np.float32, (\n 'RandomCenterCropPad needs the input image of dtype np.float32,'\n ' please set \"to_float32=True\" in \"LoadImageFromFile\" pipeline')\n h, w, c = img.shape\n assert c == len(self.mean)\n if self.test_mode:\n return self._test_aug(results)\n else:\n return self._train_aug(results)\n\n def __repr__(self):\n repr_str = self.__class__.__name__\n repr_str += f'(crop_size={self.crop_size}, '\n repr_str += f'ratios={self.ratios}, '\n repr_str += f'border={self.border}, '\n repr_str += f'mean={self.input_mean}, '\n repr_str += f'std={self.input_std}, '\n repr_str += f'to_rgb={self.to_rgb}, '\n repr_str += f'test_mode={self.test_mode}, '\n repr_str += f'test_pad_mode={self.test_pad_mode}, '\n repr_str += f'bbox_clip_border={self.bbox_clip_border})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass CutOut(BaseTransform):\n \"\"\"CutOut operation.\n\n Randomly drop some regions of image used in\n `Cutout <https://arxiv.org/abs/1708.04552>`_.\n\n Required Keys:\n\n - img\n\n Modified Keys:\n\n - img\n\n Args:\n n_holes (int or tuple[int, int]): Number of regions to be dropped.\n If it is given as a list, number of holes will be randomly\n selected from the closed interval [``n_holes[0]``, ``n_holes[1]``].\n cutout_shape (tuple[int, int] or list[tuple[int, int]], optional):\n The candidate shape of dropped regions. It can be\n ``tuple[int, int]`` to use a fixed cutout shape, or\n ``list[tuple[int, int]]`` to randomly choose shape\n from the list. Defaults to None.\n cutout_ratio (tuple[float, float] or list[tuple[float, float]],\n optional): The candidate ratio of dropped regions. It can be\n ``tuple[float, float]`` to use a fixed ratio or\n ``list[tuple[float, float]]`` to randomly choose ratio\n from the list. Please note that ``cutout_shape`` and\n ``cutout_ratio`` cannot be both given at the same time.\n Defaults to None.\n fill_in (tuple[float, float, float] or tuple[int, int, int]): The value\n of pixel to fill in the dropped regions. Defaults to (0, 0, 0).\n \"\"\"\n\n def __init__(\n self,\n n_holes: Union[int, Tuple[int, int]],\n cutout_shape: Optional[Union[Tuple[int, int],\n List[Tuple[int, int]]]] = None,\n cutout_ratio: Optional[Union[Tuple[float, float],\n List[Tuple[float, float]]]] = None,\n fill_in: Union[Tuple[float, float, float], Tuple[int, int,\n int]] = (0, 0, 0)\n ) -> None:\n\n assert (cutout_shape is None) ^ (cutout_ratio is None), \\\n 'Either cutout_shape or cutout_ratio should be specified.'\n assert (isinstance(cutout_shape, (list, tuple))\n or isinstance(cutout_ratio, (list, tuple)))\n if isinstance(n_holes, tuple):\n assert len(n_holes) == 2 and 0 <= n_holes[0] < n_holes[1]\n else:\n n_holes = (n_holes, n_holes)\n self.n_holes = n_holes\n self.fill_in = fill_in\n self.with_ratio = cutout_ratio is not None\n self.candidates = cutout_ratio if self.with_ratio else cutout_shape\n if not isinstance(self.candidates, list):\n self.candidates = [self.candidates]\n\n @autocast_box_type()\n def transform(self, results: dict) -> dict:\n \"\"\"Call function to drop some regions of image.\"\"\"\n h, w, c = results['img'].shape\n n_holes = np.random.randint(self.n_holes[0], self.n_holes[1] + 1)\n for _ in range(n_holes):\n x1 = np.random.randint(0, w)\n y1 = np.random.randint(0, h)\n index = np.random.randint(0, len(self.candidates))\n if not self.with_ratio:\n cutout_w, cutout_h = self.candidates[index]\n else:\n cutout_w = int(self.candidates[index][0] * w)\n cutout_h = int(self.candidates[index][1] * h)\n\n x2 = np.clip(x1 + cutout_w, 0, w)\n y2 = np.clip(y1 + cutout_h, 0, h)\n results['img'][y1:y2, x1:x2, :] = self.fill_in\n\n return results\n\n def __repr__(self):\n repr_str = self.__class__.__name__\n repr_str += f'(n_holes={self.n_holes}, '\n repr_str += (f'cutout_ratio={self.candidates}, ' if self.with_ratio\n else f'cutout_shape={self.candidates}, ')\n repr_str += f'fill_in={self.fill_in})'\n return repr_str\n\n\n@TRANSFORMS.register_module()\nclass Mosaic(BaseTransform):\n \"\"\"Mosaic augmentation.\n\n Given 4 images, mosaic transform combines them into\n one output image. The output image is composed of the parts from each sub-\n image.\n\n .. code:: text\n\n mosaic transform\n center_x\n +------------------------------+\n | pad | pad |\n | +-----------+ |\n | | | |\n | | image1 |--------+ |\n | | | | |\n | | | image2 | |\n center_y |----+-------------+-----------|\n | | cropped | |\n |pad | image3 | image4 |\n | | | |\n +----|-------------+-----------+\n | |\n +-------------+\n\n The mosaic transform steps are as follows:\n\n 1. Choose the mosaic center as the intersections of 4 images\n 2. Get the left top image according to the index, and randomly\n sample another 3 images from the custom dataset.\n 3. Sub image will be cropped if image is larger than mosaic patch\n\n Required Keys:\n\n - img\n - gt_bboxes (BaseBoxes[torch.float32]) (optional)\n - gt_bboxes_labels (np.int64) (optional)\n - gt_ignore_flags (bool) (optional)\n - mix_results (List[dict])\n\n Modified Keys:\n\n - img\n - img_shape\n - gt_bboxes (optional)\n - gt_bboxes_labels (optional)\n - gt_ignore_flags (optional)\n\n Args:\n img_scale (Sequence[int]): Image size before mosaic pipeline of single\n image. The shape order should be (width, height).\n Defaults to (640, 640).\n center_ratio_range (Sequence[float]): Center ratio range of mosaic\n output. Defaults to (0.5, 1.5).\n bbox_clip_border (bool, optional): Whether to clip the objects outside\n the border of the image. In some dataset like MOT17, the gt bboxes\n are allowed to cross the border of images. Therefore, we don't\n need to clip the gt bboxes in these cases. Defaults to True.\n pad_val (int): Pad value. Defaults to 114.\n prob (float): Probability of applying this transformation.\n Defaults to 1.0.\n \"\"\"\n\n def __init__(self,\n img_scale: Tuple[int, int] = (640, 640),\n center_ratio_range: Tuple[float, float] = (0.5, 1.5),\n bbox_clip_border: bool = True,\n pad_val: float = 114.0,\n prob: float = 1.0) -> None:\n assert isinstance(img_scale, tuple)\n assert 0 <= prob <= 1.0, 'The probability should be in range [0,1]. ' \\\n f'got {prob}.'\n"},"next_line":{"kind":"string","value":" log_img_scale(img_scale, skip_square=True, shape_order='wh')"},"gold_snippet_index":{"kind":"number","value":5,"string":"5"},"created_at":{"kind":"string","value":"2023-12-11 15:23:03+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5983,"cells":{"repo_name":{"kind":"string","value":"chinhsuanwu/ifusion"},"file_path":{"kind":"string","value":"model/zero123.py"},"context":{"kind":"list like","value":[{"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 inject lora into model, and returns lora parameter groups.\n \"\"\"\n\n require_grad_params = []\n names = []\n\n if loras != None:\n loras = torch.load(loras, map_location=model.device)\n\n for _module, name, _child_module in _find_modules(\n model, target_replace_module, search_class=[nn.Linear, nn.Conv2d]\n ):\n if _child_module.__class__ == nn.Linear:\n weight = _child_module.weight\n bias = _child_module.bias\n _tmp = LoraInjectedLinear(\n _child_module.in_features,\n _child_module.out_features,\n _child_module.bias is not None,\n r=r,\n )\n _tmp.linear.weight = weight\n if bias is not None:\n _tmp.linear.bias = bias\n elif _child_module.__class__ == nn.Conv2d:\n weight = _child_module.weight\n bias = _child_module.bias\n _tmp = LoraInjectedConv2d(\n _child_module.in_channels,\n _child_module.out_channels,\n _child_module.kernel_size,\n _child_module.stride,\n _child_module.padding,\n _child_module.dilation,\n _child_module.groups,\n _child_module.bias is not None,\n r=r,\n )\n\n _tmp.conv.weight = weight\n if bias is not None:\n _tmp.conv.bias = bias\n\n # switch the module\n _tmp.to(_child_module.weight.device).to(_child_module.weight.dtype)\n if bias is not None:\n _tmp.to(_child_module.bias.device).to(_child_module.bias.dtype)\n\n _module._modules[name] = _tmp\n\n require_grad_params.append(_module._modules[name].lora_up.parameters())\n require_grad_params.append(_module._modules[name].lora_down.parameters())\n\n if loras != None:\n _module._modules[name].lora_up.weight = nn.Parameter(loras.pop(0).to(model.dtype))\n _module._modules[name].lora_down.weight = nn.Parameter(loras.pop(0).to(model.dtype))\n\n _module._modules[name].lora_up.weight.requires_grad = True if not eval else False\n _module._modules[name].lora_down.weight.requires_grad = True if not eval else False\n names.append(name)\n\n return require_grad_params, names"},{"identifier":"monkeypatch_remove_lora","path":"ldm/lora.py","snippet":"def monkeypatch_remove_lora(model):\n for _module, name, _child_module in _find_modules(\n model, search_class=[LoraInjectedLinear, LoraInjectedConv2d]\n ):\n if isinstance(_child_module, LoraInjectedLinear):\n _source = _child_module.linear\n weight, bias = _source.weight, _source.bias\n\n _tmp = nn.Linear(\n _source.in_features, _source.out_features, bias is not None\n )\n\n _tmp.weight = weight\n if bias is not None:\n _tmp.bias = bias\n\n else:\n _source = _child_module.conv\n weight, bias = _source.weight, _source.bias\n\n _tmp = nn.Conv2d(\n in_channels=_source.in_channels,\n out_channels=_source.out_channels,\n kernel_size=_source.kernel_size,\n stride=_source.stride,\n padding=_source.padding,\n dilation=_source.dilation,\n groups=_source.groups,\n bias=bias is not None,\n )\n\n _tmp.weight = weight\n if bias is not None:\n _tmp.bias = bias\n\n _module._modules[name] = _tmp"},{"identifier":"save_lora_weight","path":"ldm/lora.py","snippet":"def save_lora_weight(\n model,\n path=\"./lora.pt\",\n target_replace_module=DEFAULT_TARGET_REPLACE,\n):\n weights = []\n for _up, _down in extract_lora_ups_down(\n model, target_replace_module=target_replace_module\n ):\n weights.append(_up.weight.to(\"cpu\").to(torch.float16))\n weights.append(_down.weight.to(\"cpu\").to(torch.float16))\n\n torch.save(weights, path)"},{"identifier":"LatentDiffusion","path":"ldm/models/diffusion/ddpm.py","snippet":"class LatentDiffusion(DDPM):\n \"\"\"main class\"\"\"\n\n def __init__(\n self,\n first_stage_config,\n cond_stage_config,\n num_timesteps_cond=None,\n cond_stage_key=\"image_cond\",\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 unet_trainable=True,\n *args,\n **kwargs,\n ):\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__\":\n conditioning_key = None\n ckpt_path = kwargs.pop(\"ckpt_path\", None)\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.unet_trainable = unet_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\n # construct linear projection layer for concatenating image CLIP embedding and RT\n self.cc_projection = nn.Linear(772, 768)\n nn.init.eye_(list(self.cc_projection.parameters())[0][:768, :768])\n nn.init.zeros_(list(self.cc_projection.parameters())[1])\n self.cc_projection.requires_grad_(True)\n\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\n def make_cond_schedule(\n self,\n ):\n self.cond_ids = torch.full(\n size=(self.num_timesteps,),\n fill_value=self.num_timesteps - 1,\n dtype=torch.long,\n )\n ids = torch.round(\n torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)\n ).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 (\n self.scale_by_std\n and self.current_epoch == 0\n and self.global_step == 0\n and batch_idx == 0\n and not self.restarted_from_ckpt\n ):\n assert (\n self.scale_factor == 1.0\n ), \"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.0 / z.flatten().std())\n print(f\"setting self.scale_factor to {self.scale_factor}\")\n print(\"### USING STD-RESCALING ###\")\n\n def register_schedule(\n self,\n given_betas=None,\n beta_schedule=\"linear\",\n timesteps=1000,\n linear_start=1e-4,\n linear_end=2e-2,\n cosine_s=8e-3,\n ):\n super().register_schedule(\n given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s\n )\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(\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"},{"identifier":"load_model_from_config","path":"ldm/util.py","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"},{"identifier":"make_T","path":"util/pose.py","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 )"},{"identifier":"default","path":"util/util.py","snippet":"def default(val, d):\n if exists(val):\n return val\n return d() if isfunction(d) else d"}],"string":"[\n {\n \"identifier\": \"inject_trainable_lora_extended\",\n \"path\": \"ldm/lora.py\",\n \"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 inject lora into model, and returns lora parameter groups.\\n \\\"\\\"\\\"\\n\\n require_grad_params = []\\n names = []\\n\\n if loras != None:\\n loras = torch.load(loras, map_location=model.device)\\n\\n for _module, name, _child_module in _find_modules(\\n model, target_replace_module, search_class=[nn.Linear, nn.Conv2d]\\n ):\\n if _child_module.__class__ == nn.Linear:\\n weight = _child_module.weight\\n bias = _child_module.bias\\n _tmp = LoraInjectedLinear(\\n _child_module.in_features,\\n _child_module.out_features,\\n _child_module.bias is not None,\\n r=r,\\n )\\n _tmp.linear.weight = weight\\n if bias is not None:\\n _tmp.linear.bias = bias\\n elif _child_module.__class__ == nn.Conv2d:\\n weight = _child_module.weight\\n bias = _child_module.bias\\n _tmp = LoraInjectedConv2d(\\n _child_module.in_channels,\\n _child_module.out_channels,\\n _child_module.kernel_size,\\n _child_module.stride,\\n _child_module.padding,\\n _child_module.dilation,\\n _child_module.groups,\\n _child_module.bias is not None,\\n r=r,\\n )\\n\\n _tmp.conv.weight = weight\\n if bias is not None:\\n _tmp.conv.bias = bias\\n\\n # switch the module\\n _tmp.to(_child_module.weight.device).to(_child_module.weight.dtype)\\n if bias is not None:\\n _tmp.to(_child_module.bias.device).to(_child_module.bias.dtype)\\n\\n _module._modules[name] = _tmp\\n\\n require_grad_params.append(_module._modules[name].lora_up.parameters())\\n require_grad_params.append(_module._modules[name].lora_down.parameters())\\n\\n if loras != None:\\n _module._modules[name].lora_up.weight = nn.Parameter(loras.pop(0).to(model.dtype))\\n _module._modules[name].lora_down.weight = nn.Parameter(loras.pop(0).to(model.dtype))\\n\\n _module._modules[name].lora_up.weight.requires_grad = True if not eval else False\\n _module._modules[name].lora_down.weight.requires_grad = True if not eval else False\\n names.append(name)\\n\\n return require_grad_params, names\"\n },\n {\n \"identifier\": \"monkeypatch_remove_lora\",\n \"path\": \"ldm/lora.py\",\n \"snippet\": \"def monkeypatch_remove_lora(model):\\n for _module, name, _child_module in _find_modules(\\n model, search_class=[LoraInjectedLinear, LoraInjectedConv2d]\\n ):\\n if isinstance(_child_module, LoraInjectedLinear):\\n _source = _child_module.linear\\n weight, bias = _source.weight, _source.bias\\n\\n _tmp = nn.Linear(\\n _source.in_features, _source.out_features, bias is not None\\n )\\n\\n _tmp.weight = weight\\n if bias is not None:\\n _tmp.bias = bias\\n\\n else:\\n _source = _child_module.conv\\n weight, bias = _source.weight, _source.bias\\n\\n _tmp = nn.Conv2d(\\n in_channels=_source.in_channels,\\n out_channels=_source.out_channels,\\n kernel_size=_source.kernel_size,\\n stride=_source.stride,\\n padding=_source.padding,\\n dilation=_source.dilation,\\n groups=_source.groups,\\n bias=bias is not None,\\n )\\n\\n _tmp.weight = weight\\n if bias is not None:\\n _tmp.bias = bias\\n\\n _module._modules[name] = _tmp\"\n },\n {\n \"identifier\": \"save_lora_weight\",\n \"path\": \"ldm/lora.py\",\n \"snippet\": \"def save_lora_weight(\\n model,\\n path=\\\"./lora.pt\\\",\\n target_replace_module=DEFAULT_TARGET_REPLACE,\\n):\\n weights = []\\n for _up, _down in extract_lora_ups_down(\\n model, target_replace_module=target_replace_module\\n ):\\n weights.append(_up.weight.to(\\\"cpu\\\").to(torch.float16))\\n weights.append(_down.weight.to(\\\"cpu\\\").to(torch.float16))\\n\\n torch.save(weights, path)\"\n },\n {\n \"identifier\": \"LatentDiffusion\",\n \"path\": \"ldm/models/diffusion/ddpm.py\",\n \"snippet\": \"class LatentDiffusion(DDPM):\\n \\\"\\\"\\\"main class\\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n first_stage_config,\\n cond_stage_config,\\n num_timesteps_cond=None,\\n cond_stage_key=\\\"image_cond\\\",\\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 unet_trainable=True,\\n *args,\\n **kwargs,\\n ):\\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__\\\":\\n conditioning_key = None\\n ckpt_path = kwargs.pop(\\\"ckpt_path\\\", None)\\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.unet_trainable = unet_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\\n # construct linear projection layer for concatenating image CLIP embedding and RT\\n self.cc_projection = nn.Linear(772, 768)\\n nn.init.eye_(list(self.cc_projection.parameters())[0][:768, :768])\\n nn.init.zeros_(list(self.cc_projection.parameters())[1])\\n self.cc_projection.requires_grad_(True)\\n\\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\\n def make_cond_schedule(\\n self,\\n ):\\n self.cond_ids = torch.full(\\n size=(self.num_timesteps,),\\n fill_value=self.num_timesteps - 1,\\n dtype=torch.long,\\n )\\n ids = torch.round(\\n torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)\\n ).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 (\\n self.scale_by_std\\n and self.current_epoch == 0\\n and self.global_step == 0\\n and batch_idx == 0\\n and not self.restarted_from_ckpt\\n ):\\n assert (\\n self.scale_factor == 1.0\\n ), \\\"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.0 / z.flatten().std())\\n print(f\\\"setting self.scale_factor to {self.scale_factor}\\\")\\n print(\\\"### USING STD-RESCALING ###\\\")\\n\\n def register_schedule(\\n self,\\n given_betas=None,\\n beta_schedule=\\\"linear\\\",\\n timesteps=1000,\\n linear_start=1e-4,\\n linear_end=2e-2,\\n cosine_s=8e-3,\\n ):\\n super().register_schedule(\\n given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s\\n )\\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(\\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":15893,"string":"15,893"},"cropped_code":{"kind":"string","value":" 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 save_lora_weight(\n self.model.model,\n ckpt_fp,\n target_replace_module=set(target_replace_module),\n )\n print(f\"[INFO] Saved LoRA to {ckpt_fp}\")\n\n def remove_lora(self):\n print(\"[INFO] Removing LoRA\")\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 ):\n save_lora_weight(\n self.model.model,\n ckpt_fp,\n target_replace_module=set(target_replace_module),\n )\n print(f\"[INFO] Saved LoRA to {ckpt_fp}\")\n\n def remove_lora(self):\n print(\"[INFO] Removing LoRA\")"},"next_line":{"kind":"string","value":" monkeypatch_remove_lora(self.model.model)"},"gold_snippet_index":{"kind":"number","value":1,"string":"1"},"created_at":{"kind":"string","value":"2023-12-17 12:45:38+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5984,"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":15725,"string":"15,725"},"cropped_code":{"kind":"string","value":"\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"},"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("},"next_line":{"kind":"string","value":"\t\t\t\t\tMixedGroundingDataset("},"gold_snippet_index":{"kind":"number","value":9,"string":"9"},"created_at":{"kind":"string","value":"2023-12-15 14:58:24+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5985,"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":21323,"string":"21,323"},"cropped_code":{"kind":"string","value":" \"\"\"\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"},"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 )"},"next_line":{"kind":"string","value":" return colormaps.apply_depth_colormap(outputs[reformatted_output], accumulation=outputs[accumulation_str])"},"gold_snippet_index":{"kind":"number","value":5,"string":"5"},"created_at":{"kind":"string","value":"2023-12-15 20:07:22+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5986,"cells":{"repo_name":{"kind":"string","value":"alipay/PainlessInferenceAcceleration"},"file_path":{"kind":"string","value":"pia/lookahead/models/chatglm/modeling_chatglm.py"},"context":{"kind":"list like","value":[{"identifier":"ChatGLMConfig","path":"pia/lookahead/models/chatglm/configuration_chatglm.py","snippet":"class ChatGLMConfig(PretrainedConfig):\n model_type = \"chatglm\"\n\n def __init__(\n self,\n num_layers=28,\n padded_vocab_size=65024,\n hidden_size=4096,\n ffn_hidden_size=13696,\n kv_channels=128,\n num_attention_heads=32,\n seq_length=2048,\n hidden_dropout=0.0,\n attention_dropout=0.0,\n layernorm_epsilon=1e-5,\n rmsnorm=True,\n apply_residual_connection_post_layernorm=False,\n post_layer_norm=True,\n add_bias_linear=False,\n add_qkv_bias=False,\n interleaved_qkv=False,\n bias_dropout_fusion=True,\n multi_query_attention=False,\n multi_query_group_num=1,\n apply_query_key_layer_scaling=True,\n attention_softmax_in_fp32=True,\n fp32_residual_connection=False,\n quantization_bit=0,\n pre_seq_len=None,\n prefix_projection=False,\n **kwargs\n ):\n self.num_layers = num_layers\n self.vocab_size = padded_vocab_size\n self.padded_vocab_size = padded_vocab_size\n self.hidden_size = hidden_size\n self.ffn_hidden_size = ffn_hidden_size\n self.kv_channels = kv_channels\n self.num_attention_heads = num_attention_heads\n self.seq_length = seq_length\n self.hidden_dropout = hidden_dropout\n self.attention_dropout = attention_dropout\n self.layernorm_epsilon = layernorm_epsilon\n self.rmsnorm = rmsnorm\n self.apply_residual_connection_post_layernorm = apply_residual_connection_post_layernorm\n self.post_layer_norm = post_layer_norm\n self.add_bias_linear = add_bias_linear\n self.add_qkv_bias = add_qkv_bias\n self.bias_dropout_fusion = bias_dropout_fusion\n self.multi_query_attention = multi_query_attention\n self.multi_query_group_num = multi_query_group_num\n self.apply_query_key_layer_scaling = apply_query_key_layer_scaling\n self.attention_softmax_in_fp32 = attention_softmax_in_fp32\n self.fp32_residual_connection = fp32_residual_connection\n self.quantization_bit = quantization_bit\n self.pre_seq_len = pre_seq_len\n self.prefix_projection = prefix_projection\n super().__init__(**kwargs)"},{"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 )"}],"string":"[\n {\n \"identifier\": \"ChatGLMConfig\",\n \"path\": \"pia/lookahead/models/chatglm/configuration_chatglm.py\",\n \"snippet\": \"class ChatGLMConfig(PretrainedConfig):\\n model_type = \\\"chatglm\\\"\\n\\n def __init__(\\n self,\\n num_layers=28,\\n padded_vocab_size=65024,\\n hidden_size=4096,\\n ffn_hidden_size=13696,\\n kv_channels=128,\\n num_attention_heads=32,\\n seq_length=2048,\\n hidden_dropout=0.0,\\n attention_dropout=0.0,\\n layernorm_epsilon=1e-5,\\n rmsnorm=True,\\n apply_residual_connection_post_layernorm=False,\\n post_layer_norm=True,\\n add_bias_linear=False,\\n add_qkv_bias=False,\\n interleaved_qkv=False,\\n bias_dropout_fusion=True,\\n multi_query_attention=False,\\n multi_query_group_num=1,\\n apply_query_key_layer_scaling=True,\\n attention_softmax_in_fp32=True,\\n fp32_residual_connection=False,\\n quantization_bit=0,\\n pre_seq_len=None,\\n prefix_projection=False,\\n **kwargs\\n ):\\n self.num_layers = num_layers\\n self.vocab_size = padded_vocab_size\\n self.padded_vocab_size = padded_vocab_size\\n self.hidden_size = hidden_size\\n self.ffn_hidden_size = ffn_hidden_size\\n self.kv_channels = kv_channels\\n self.num_attention_heads = num_attention_heads\\n self.seq_length = seq_length\\n self.hidden_dropout = hidden_dropout\\n self.attention_dropout = attention_dropout\\n self.layernorm_epsilon = layernorm_epsilon\\n self.rmsnorm = rmsnorm\\n self.apply_residual_connection_post_layernorm = apply_residual_connection_post_layernorm\\n self.post_layer_norm = post_layer_norm\\n self.add_bias_linear = add_bias_linear\\n self.add_qkv_bias = add_qkv_bias\\n self.bias_dropout_fusion = bias_dropout_fusion\\n self.multi_query_attention = multi_query_attention\\n self.multi_query_group_num = multi_query_group_num\\n self.apply_query_key_layer_scaling = apply_query_key_layer_scaling\\n self.attention_softmax_in_fp32 = attention_softmax_in_fp32\\n self.fp32_residual_connection = fp32_residual_connection\\n self.quantization_bit = quantization_bit\\n self.pre_seq_len = pre_seq_len\\n self.prefix_projection = prefix_projection\\n super().__init__(**kwargs)\"\n },\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]","isConversational":false},"import_statement":{"kind":"string","value":"import copy\nimport math\nimport warnings\nimport torch\nimport torch.nn.functional as F\nimport torch.utils.checkpoint\nfrom typing import Optional, Tuple, List, Callable, Dict, Any\nfrom pia.lookahead.models.chatglm.configuration_chatglm import ChatGLMConfig\nfrom torch import nn\nfrom torch.nn import CrossEntropyLoss, LayerNorm\nfrom torch.nn.utils import skip_init\nfrom transformers.generation.logits_process import LogitsProcessor\nfrom transformers.generation.utils import LogitsProcessorList, StoppingCriteriaList, GenerationConfig, ModelOutput\nfrom transformers.modeling_outputs import (\n BaseModelOutputWithPast,\n CausalLMOutputWithPast,\n)\nfrom transformers.utils import logging\nfrom pia.lookahead.common.pretrained_model import LookaheadPreTrainedModel"},"token_num":{"kind":"number","value":16924,"string":"16,924"},"cropped_code":{"kind":"string","value":" attention_output, kv_cache = self.self_attention(\n layernorm_output,\n attention_mask,\n rotary_pos_emb,\n kv_cache=kv_cache,\n use_cache=use_cache\n )\n\n # Residual connection.\n if self.apply_residual_connection_post_layernorm:\n residual = layernorm_output\n else:\n residual = hidden_states\n\n # layernorm_input = torch.nn.functional.dropout(attention_output, p=self.hidden_dropout, training=self.training)\n layernorm_input = attention_output\n layernorm_input = residual + layernorm_input\n\n # Layer norm post the self attention.\n layernorm_output = self.post_attention_layernorm(layernorm_input)\n\n # MLP.\n mlp_output = self.mlp(layernorm_output)\n\n # Second residual connection.\n if self.apply_residual_connection_post_layernorm:\n residual = layernorm_output\n else:\n residual = layernorm_input\n\n # output = torch.nn.functional.dropout(mlp_output, p=self.hidden_dropout, training=self.training)\n output = mlp_output\n output = residual + output\n\n return output, kv_cache\n\n\nclass GLMTransformer(torch.nn.Module):\n \"\"\"Transformer class.\"\"\"\n\n def __init__(self, config: ChatGLMConfig, device=None):\n super(GLMTransformer, self).__init__()\n\n self.fp32_residual_connection = config.fp32_residual_connection\n self.post_layer_norm = config.post_layer_norm\n\n # Number of layers.\n self.num_layers = config.num_layers\n\n # Transformer layers.\n def build_layer(layer_number):\n return GLMBlock(config, layer_number, device=device)\n\n self.layers = torch.nn.ModuleList([build_layer(i + 1) for i in range(self.num_layers)])\n\n if self.post_layer_norm:\n LayerNormFunc = RMSNorm if config.rmsnorm else LayerNorm\n # Final layer norm before output.\n self.final_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device,\n dtype=config.torch_dtype)\n\n self.gradient_checkpointing = False\n\n def _get_layer(self, layer_number):\n return self.layers[layer_number]\n\n def forward(\n self, hidden_states, attention_mask, rotary_pos_emb, kv_caches=None,\n use_cache: Optional[bool] = True,\n output_hidden_states: Optional[bool] = False,\n ):\n num_layers = len(self.layers)\n if not kv_caches:\n kv_caches = [None for _ in range(num_layers)]\n presents = () if use_cache else None\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 all_self_attentions = None\n all_hidden_states = () if output_hidden_states else None\n for index in range(num_layers):\n if output_hidden_states:\n all_hidden_states = all_hidden_states + (hidden_states,)\n\n layer = self._get_layer(index)\n if self.gradient_checkpointing and self.training:\n layer_ret = torch.utils.checkpoint.checkpoint(\n layer,\n hidden_states,\n attention_mask,\n rotary_pos_emb,\n kv_caches[index],\n use_cache\n )\n else:\n layer_ret = layer(\n hidden_states,\n attention_mask,\n rotary_pos_emb,\n kv_cache=kv_caches[index],\n use_cache=use_cache\n )\n hidden_states, kv_cache = layer_ret\n if use_cache:\n presents = presents + (kv_cache,)\n\n if output_hidden_states:\n all_hidden_states = all_hidden_states + (hidden_states,)\n\n # Final layer norm.\n if self.post_layer_norm:\n hidden_states = self.final_layernorm(hidden_states)\n\n return hidden_states, presents, all_hidden_states, all_self_attentions\n\n\n"},"all_code":{"kind":"string","value":"\"\"\" PyTorch ChatGLM model. \"\"\"\n\n\n\n# from transformers.modeling_utils import PreTrainedModel\n\n# flags required to enable jit fusion kernels\n\n# if sys.platform != 'darwin':\n# torch._C._jit_set_profiling_mode(False)\n# torch._C._jit_set_profiling_executor(False)\n# torch._C._jit_override_can_fuse_on_cpu(True)\n# torch._C._jit_override_can_fuse_on_gpu(True)\n\nlogger = logging.get_logger(__name__)\n\n_CHECKPOINT_FOR_DOC = \"THUDM/ChatGLM2-6B\"\n_CONFIG_FOR_DOC = \"ChatGLM6BConfig\"\n\nCHATGLM_6B_PRETRAINED_MODEL_ARCHIVE_LIST = [\n \"THUDM/chatglm2-6b\",\n # See all ChatGLM models at https://huggingface.co/models?filter=chatglm\n]\n\n\ndef default_init(cls, *args, **kwargs):\n return cls(*args, **kwargs)\n\n\nclass InvalidScoreLogitsProcessor(LogitsProcessor):\n def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:\n if torch.isnan(scores).any() or torch.isinf(scores).any():\n scores.zero_()\n scores[..., 5] = 5e4\n return scores\n\n\nclass PrefixEncoder(torch.nn.Module):\n \"\"\"\n The torch.nn model to encode the prefix\n Input shape: (batch-size, prefix-length)\n Output shape: (batch-size, prefix-length, 2*layers*hidden)\n \"\"\"\n\n def __init__(self, config: ChatGLMConfig):\n super().__init__()\n self.prefix_projection = config.prefix_projection\n if self.prefix_projection:\n # Use a two-layer MLP to encode the prefix\n self.embedding = torch.nn.Embedding(config.pre_seq_len, config.hidden_size)\n self.trans = torch.nn.Sequential(\n torch.nn.Linear(config.hidden_size, config.hidden_size),\n torch.nn.Tanh(),\n torch.nn.Linear(config.hidden_size, config.num_layers * config.hidden_size * 2)\n )\n else:\n self.embedding = torch.nn.Embedding(config.pre_seq_len,\n config.num_layers * config.kv_channels * config.multi_query_group_num * 2)\n\n def forward(self, prefix: torch.Tensor):\n if self.prefix_projection:\n prefix_tokens = self.embedding(prefix)\n past_key_values = self.trans(prefix_tokens)\n else:\n past_key_values = self.embedding(prefix)\n return past_key_values\n\n\ndef split_tensor_along_last_dim(\n tensor: torch.Tensor,\n num_partitions: int,\n contiguous_split_chunks: bool = False,\n) -> List[torch.Tensor]:\n \"\"\"Split a tensor along its last dimension.\n\n Arguments:\n tensor: input tensor.\n num_partitions: number of partitions to split the tensor\n contiguous_split_chunks: If True, make each chunk contiguous\n in memory.\n\n Returns:\n A list of Tensors\n \"\"\"\n # Get the size and dimension.\n last_dim = tensor.dim() - 1\n last_dim_size = tensor.size()[last_dim] // num_partitions\n # Split.\n tensor_list = torch.split(tensor, last_dim_size, dim=last_dim)\n # Note: torch.split does not create contiguous tensors by default.\n if contiguous_split_chunks:\n return tuple(chunk.contiguous() for chunk in tensor_list)\n\n return tensor_list\n\n\nclass RotaryEmbedding(nn.Module):\n def __init__(self, dim, original_impl=False, device=None, dtype=None):\n super().__init__()\n inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2, device=device).to(dtype=dtype) / dim))\n self.register_buffer(\"inv_freq\", inv_freq)\n self.dim = dim\n self.original_impl = original_impl\n\n def forward_impl(\n self, seq_len: int, n_elem: int, dtype: torch.dtype, device: torch.device, base: int = 10000\n ):\n \"\"\"Enhanced Transformer with Rotary Position Embedding.\n\n Derived from: https://github.com/labmlai/annotated_deep_learning_paper_implementations/blob/master/labml_nn/\n transformers/rope/__init__.py. MIT License:\n https://github.com/labmlai/annotated_deep_learning_paper_implementations/blob/master/license.\n \"\"\"\n # $\\Theta = {\\theta_i = 10000^{\\frac{2(i-1)}{d}}, i \\in [1, 2, ..., \\frac{d}{2}]}$\n theta = 1.0 / (base ** (torch.arange(0, n_elem, 2, dtype=dtype, device=device) / n_elem))\n\n # Create position indexes `[0, 1, ..., seq_len - 1]`\n seq_idx = torch.arange(seq_len, dtype=dtype, device=device)\n\n # Calculate the product of position index and $\\theta_i$\n idx_theta = torch.outer(seq_idx, theta).float()\n\n cache = torch.stack([torch.cos(idx_theta), torch.sin(idx_theta)], dim=-1)\n\n # this is to mimic the behaviour of complex32, else we will get different results\n if dtype in (torch.float16, torch.bfloat16, torch.int8):\n cache = cache.bfloat16() if dtype == torch.bfloat16 else cache.half()\n return cache\n\n def forward(self, max_seq_len, offset=0):\n return self.forward_impl(\n max_seq_len, self.dim, dtype=self.inv_freq.dtype, device=self.inv_freq.device\n )\n\n\n# @torch.jit.script\ndef apply_rotary_pos_emb(x: torch.Tensor, rope_cache: torch.Tensor) -> torch.Tensor:\n # x: [sq, b, np, hn]\n sq, b, np, hn = x.size(0), x.size(1), x.size(2), x.size(3)\n rot_dim = rope_cache.shape[-2] * 2\n x, x_pass = x[..., :rot_dim], x[..., rot_dim:]\n # truncate to support variable sizes\n rope_cache = rope_cache[:sq]\n xshaped = x.reshape(sq, -1, np, rot_dim // 2, 2)\n rope_cache = rope_cache.view(sq, -1, 1, xshaped.size(3), 2)\n x_out2 = torch.stack(\n [\n xshaped[..., 0] * rope_cache[..., 0] - xshaped[..., 1] * rope_cache[..., 1],\n xshaped[..., 1] * rope_cache[..., 0] + xshaped[..., 0] * rope_cache[..., 1],\n ],\n -1,\n )\n x_out2 = x_out2.flatten(3)\n return torch.cat((x_out2, x_pass), dim=-1)\n\n\nclass RMSNorm(torch.nn.Module):\n def __init__(self, normalized_shape, eps=1e-5, device=None, dtype=None, **kwargs):\n super().__init__()\n self.weight = torch.nn.Parameter(torch.empty(normalized_shape, device=device, dtype=dtype))\n self.eps = eps\n\n def forward(self, hidden_states: torch.Tensor):\n input_dtype = hidden_states.dtype\n variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)\n hidden_states = hidden_states * torch.rsqrt(variance + self.eps)\n\n return (self.weight * hidden_states).to(input_dtype)\n\n\nclass CoreAttention(torch.nn.Module):\n def __init__(self, config: ChatGLMConfig, layer_number):\n super(CoreAttention, self).__init__()\n\n self.apply_query_key_layer_scaling = config.apply_query_key_layer_scaling\n self.attention_softmax_in_fp32 = config.attention_softmax_in_fp32\n if self.apply_query_key_layer_scaling:\n self.attention_softmax_in_fp32 = True\n self.layer_number = max(1, layer_number)\n\n projection_size = config.kv_channels * config.num_attention_heads\n\n # Per attention head and per partition values.\n self.hidden_size_per_partition = projection_size\n self.hidden_size_per_attention_head = projection_size // config.num_attention_heads\n self.num_attention_heads_per_partition = config.num_attention_heads\n\n coeff = None\n self.norm_factor = math.sqrt(self.hidden_size_per_attention_head)\n if self.apply_query_key_layer_scaling:\n coeff = self.layer_number\n self.norm_factor *= coeff\n self.coeff = coeff\n\n # self.attention_dropout = torch.nn.Dropout(config.attention_dropout)\n\n def forward(self, query_layer, key_layer, value_layer, attention_mask):\n pytorch_major_version = int(torch.__version__.split('.')[0])\n if pytorch_major_version >= 2:\n query_layer, key_layer, value_layer = [k.permute(1, 2, 0, 3) for k in [query_layer, key_layer, value_layer]]\n if attention_mask is None and query_layer.shape[2] == key_layer.shape[2]:\n context_layer = torch.nn.functional.scaled_dot_product_attention(query_layer, key_layer, value_layer,\n is_causal=True)\n else:\n if attention_mask is not None:\n attention_mask = ~attention_mask\n context_layer = torch.nn.functional.scaled_dot_product_attention(query_layer, key_layer, value_layer,\n attention_mask)\n context_layer = context_layer.permute(2, 0, 1, 3)\n new_context_layer_shape = context_layer.size()[:-2] + (self.hidden_size_per_partition,)\n context_layer = context_layer.reshape(*new_context_layer_shape)\n else:\n # Raw attention scores\n\n # [b, np, sq, sk]\n output_size = (query_layer.size(1), query_layer.size(2), query_layer.size(0), key_layer.size(0))\n\n # [sq, b, np, hn] -> [sq, b * np, hn]\n query_layer = query_layer.view(output_size[2], output_size[0] * output_size[1], -1)\n # [sk, b, np, hn] -> [sk, b * np, hn]\n key_layer = key_layer.view(output_size[3], output_size[0] * output_size[1], -1)\n\n # preallocting input tensor: [b * np, sq, sk]\n matmul_input_buffer = torch.empty(\n output_size[0] * output_size[1], output_size[2], output_size[3], dtype=query_layer.dtype,\n device=query_layer.device\n )\n\n # Raw attention scores. [b * np, sq, sk]\n matmul_result = torch.baddbmm(\n matmul_input_buffer,\n query_layer.transpose(0, 1), # [b * np, sq, hn]\n key_layer.transpose(0, 1).transpose(1, 2), # [b * np, hn, sk]\n beta=0.0,\n alpha=(1.0 / self.norm_factor),\n )\n\n # change view to [b, np, sq, sk]\n attention_scores = matmul_result.view(*output_size)\n\n # ===========================\n # Attention probs and dropout\n # ===========================\n\n # attention scores and attention mask [b, np, sq, sk]\n if self.attention_softmax_in_fp32:\n attention_scores = attention_scores.float()\n if self.coeff is not None:\n attention_scores = attention_scores * self.coeff\n if attention_mask is None and attention_scores.shape[2] == attention_scores.shape[3]:\n attention_mask = torch.ones(output_size[0], 1, output_size[2], output_size[3],\n device=attention_scores.device, dtype=torch.bool)\n attention_mask.tril_()\n attention_mask = ~attention_mask\n if attention_mask is not None:\n attention_scores = attention_scores.masked_fill(attention_mask, float(\"-inf\"))\n attention_probs = F.softmax(attention_scores, dim=-1)\n attention_probs = attention_probs.type_as(value_layer)\n\n # This is actually dropping out entire tokens to attend to, which might\n # seem a bit unusual, but is taken from the original Transformer paper.\n # attention_probs = self.attention_dropout(attention_probs)\n # =========================\n # Context layer. [sq, b, hp]\n # =========================\n\n # value_layer -> context layer.\n # [sk, b, np, hn] --> [b, np, sq, hn]\n\n # context layer shape: [b, np, sq, hn]\n output_size = (value_layer.size(1), value_layer.size(2), query_layer.size(0), value_layer.size(3))\n # change view [sk, b * np, hn]\n value_layer = value_layer.view(value_layer.size(0), output_size[0] * output_size[1], -1)\n # change view [b * np, sq, sk]\n attention_probs = attention_probs.view(output_size[0] * output_size[1], output_size[2], -1)\n # matmul: [b * np, sq, hn]\n context_layer = torch.bmm(attention_probs, value_layer.transpose(0, 1))\n # change view [b, np, sq, hn]\n context_layer = context_layer.view(*output_size)\n # [b, np, sq, hn] --> [sq, b, np, hn]\n context_layer = context_layer.permute(2, 0, 1, 3).contiguous()\n # [sq, b, np, hn] --> [sq, b, hp]\n new_context_layer_shape = context_layer.size()[:-2] + (self.hidden_size_per_partition,)\n context_layer = context_layer.view(*new_context_layer_shape)\n\n return context_layer\n\n\nclass SelfAttention(torch.nn.Module):\n \"\"\"Parallel self-attention layer abstract class.\n\n Self-attention layer takes input with size [s, b, h]\n and returns output of the same size.\n \"\"\"\n\n def __init__(self, config: ChatGLMConfig, layer_number, device=None):\n super(SelfAttention, self).__init__()\n self.layer_number = max(1, layer_number)\n\n self.projection_size = config.kv_channels * config.num_attention_heads\n\n # Per attention head and per partition values.\n self.hidden_size_per_attention_head = self.projection_size // config.num_attention_heads\n self.num_attention_heads_per_partition = config.num_attention_heads\n\n self.multi_query_attention = config.multi_query_attention\n self.qkv_hidden_size = 3 * self.projection_size\n if self.multi_query_attention:\n self.num_multi_query_groups_per_partition = config.multi_query_group_num\n self.qkv_hidden_size = (\n self.projection_size + 2 * self.hidden_size_per_attention_head * config.multi_query_group_num\n )\n self.query_key_value = nn.Linear(config.hidden_size, self.qkv_hidden_size,\n bias=config.add_bias_linear or config.add_qkv_bias,\n device=device, **_config_to_kwargs(config)\n )\n\n self.core_attention = CoreAttention(config, self.layer_number)\n\n # Output.\n self.dense = nn.Linear(self.projection_size, config.hidden_size, bias=config.add_bias_linear,\n device=device, **_config_to_kwargs(config)\n )\n\n def _allocate_memory(self, inference_max_sequence_len, batch_size, device=None, dtype=None):\n if self.multi_query_attention:\n num_attention_heads = self.num_multi_query_groups_per_partition\n else:\n num_attention_heads = self.num_attention_heads_per_partition\n return torch.empty(\n inference_max_sequence_len,\n batch_size,\n num_attention_heads,\n self.hidden_size_per_attention_head,\n dtype=dtype,\n device=device,\n )\n\n def forward(\n self, hidden_states, attention_mask, rotary_pos_emb, kv_cache=None, use_cache=True\n ):\n # hidden_states: [sq, b, h]\n\n # =================================================\n # Pre-allocate memory for key-values for inference.\n # =================================================\n # =====================\n # Query, Key, and Value\n # =====================\n\n # Attention heads [sq, b, h] --> [sq, b, (np * 3 * hn)]\n mixed_x_layer = self.query_key_value(hidden_states)\n\n if self.multi_query_attention:\n (query_layer, key_layer, value_layer) = mixed_x_layer.split(\n [\n self.num_attention_heads_per_partition * self.hidden_size_per_attention_head,\n self.num_multi_query_groups_per_partition * self.hidden_size_per_attention_head,\n self.num_multi_query_groups_per_partition * self.hidden_size_per_attention_head,\n ],\n dim=-1,\n )\n query_layer = query_layer.view(\n query_layer.size()[:-1] + (self.num_attention_heads_per_partition, self.hidden_size_per_attention_head)\n )\n key_layer = key_layer.view(\n key_layer.size()[:-1] + (self.num_multi_query_groups_per_partition, self.hidden_size_per_attention_head)\n )\n value_layer = value_layer.view(\n value_layer.size()[:-1]\n + (self.num_multi_query_groups_per_partition, self.hidden_size_per_attention_head)\n )\n else:\n new_tensor_shape = mixed_x_layer.size()[:-1] + \\\n (self.num_attention_heads_per_partition,\n 3 * self.hidden_size_per_attention_head)\n mixed_x_layer = mixed_x_layer.view(*new_tensor_shape)\n\n # [sq, b, np, 3 * hn] --> 3 [sq, b, np, hn]\n (query_layer, key_layer, value_layer) = split_tensor_along_last_dim(mixed_x_layer, 3)\n\n # apply relative positional encoding (rotary embedding)\n if rotary_pos_emb is not None:\n query_layer = apply_rotary_pos_emb(query_layer, rotary_pos_emb)\n key_layer = apply_rotary_pos_emb(key_layer, rotary_pos_emb)\n\n # adjust key and value for inference\n if kv_cache is not None:\n cache_k, cache_v = kv_cache\n key_layer = torch.cat((cache_k, key_layer), dim=0)\n value_layer = torch.cat((cache_v, value_layer), dim=0)\n if use_cache:\n kv_cache = (key_layer, value_layer)\n else:\n kv_cache = None\n\n if self.multi_query_attention:\n key_layer = key_layer.unsqueeze(-2)\n key_layer = key_layer.expand(\n -1, -1, -1, self.num_attention_heads_per_partition // self.num_multi_query_groups_per_partition, -1\n )\n key_layer = key_layer.contiguous().view(\n key_layer.size()[:2] + (self.num_attention_heads_per_partition, self.hidden_size_per_attention_head)\n )\n value_layer = value_layer.unsqueeze(-2)\n value_layer = value_layer.expand(\n -1, -1, -1, self.num_attention_heads_per_partition // self.num_multi_query_groups_per_partition, -1\n )\n value_layer = value_layer.contiguous().view(\n value_layer.size()[:2] + (self.num_attention_heads_per_partition, self.hidden_size_per_attention_head)\n )\n\n # ==================================\n # core attention computation\n # ==================================\n\n context_layer = self.core_attention(query_layer, key_layer, value_layer, attention_mask)\n\n # =================\n # Output. [sq, b, h]\n # =================\n\n output = self.dense(context_layer)\n\n return output, kv_cache\n\n\ndef _config_to_kwargs(args):\n common_kwargs = {\n \"dtype\": args.torch_dtype,\n }\n return common_kwargs\n\n\nclass MLP(torch.nn.Module):\n \"\"\"MLP.\n\n MLP will take the input with h hidden state, project it to 4*h\n hidden dimension, perform nonlinear transformation, and project the\n state back into h hidden dimension.\n \"\"\"\n\n def __init__(self, config: ChatGLMConfig, device=None):\n super(MLP, self).__init__()\n\n self.add_bias = config.add_bias_linear\n\n # Project to 4h. If using swiglu double the output width, see https://arxiv.org/pdf/2002.05202.pdf\n self.dense_h_to_4h = nn.Linear(\n config.hidden_size,\n config.ffn_hidden_size * 2,\n bias=self.add_bias,\n device=device,\n **_config_to_kwargs(config)\n )\n\n def swiglu(x):\n x = torch.chunk(x, 2, dim=-1)\n return F.silu(x[0]) * x[1]\n\n self.activation_func = swiglu\n\n # Project back to h.\n self.dense_4h_to_h = nn.Linear(\n config.ffn_hidden_size,\n config.hidden_size,\n bias=self.add_bias,\n device=device,\n **_config_to_kwargs(config)\n )\n\n def forward(self, hidden_states):\n # [s, b, 4hp]\n intermediate_parallel = self.dense_h_to_4h(hidden_states)\n intermediate_parallel = self.activation_func(intermediate_parallel)\n # [s, b, h]\n output = self.dense_4h_to_h(intermediate_parallel)\n return output\n\n\nclass GLMBlock(torch.nn.Module):\n \"\"\"A single transformer layer.\n\n Transformer layer takes input with size [s, b, h] and returns an\n output of the same size.\n \"\"\"\n\n def __init__(self, config: ChatGLMConfig, layer_number, device=None):\n super(GLMBlock, self).__init__()\n self.layer_number = layer_number\n\n self.apply_residual_connection_post_layernorm = config.apply_residual_connection_post_layernorm\n\n self.fp32_residual_connection = config.fp32_residual_connection\n\n LayerNormFunc = RMSNorm if config.rmsnorm else LayerNorm\n # Layernorm on the input data.\n self.input_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device,\n dtype=config.torch_dtype)\n\n # Self attention.\n self.self_attention = SelfAttention(config, layer_number, device=device)\n # self.hidden_dropout = config.hidden_dropout\n\n # Layernorm on the attention output\n self.post_attention_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device,\n dtype=config.torch_dtype)\n\n # MLP\n self.mlp = MLP(config, device=device)\n\n def forward(\n self, hidden_states, attention_mask, rotary_pos_emb, kv_cache=None, use_cache=True,\n ):\n # hidden_states: [s, b, h]\n\n # Layer norm at the beginning of the transformer layer.\n layernorm_output = self.input_layernorm(hidden_states)\n # Self attention.\n attention_output, kv_cache = self.self_attention(\n layernorm_output,\n attention_mask,\n rotary_pos_emb,\n kv_cache=kv_cache,\n use_cache=use_cache\n )\n\n # Residual connection.\n if self.apply_residual_connection_post_layernorm:\n residual = layernorm_output\n else:\n residual = hidden_states\n\n # layernorm_input = torch.nn.functional.dropout(attention_output, p=self.hidden_dropout, training=self.training)\n layernorm_input = attention_output\n layernorm_input = residual + layernorm_input\n\n # Layer norm post the self attention.\n layernorm_output = self.post_attention_layernorm(layernorm_input)\n\n # MLP.\n mlp_output = self.mlp(layernorm_output)\n\n # Second residual connection.\n if self.apply_residual_connection_post_layernorm:\n residual = layernorm_output\n else:\n residual = layernorm_input\n\n # output = torch.nn.functional.dropout(mlp_output, p=self.hidden_dropout, training=self.training)\n output = mlp_output\n output = residual + output\n\n return output, kv_cache\n\n\nclass GLMTransformer(torch.nn.Module):\n \"\"\"Transformer class.\"\"\"\n\n def __init__(self, config: ChatGLMConfig, device=None):\n super(GLMTransformer, self).__init__()\n\n self.fp32_residual_connection = config.fp32_residual_connection\n self.post_layer_norm = config.post_layer_norm\n\n # Number of layers.\n self.num_layers = config.num_layers\n\n # Transformer layers.\n def build_layer(layer_number):\n return GLMBlock(config, layer_number, device=device)\n\n self.layers = torch.nn.ModuleList([build_layer(i + 1) for i in range(self.num_layers)])\n\n if self.post_layer_norm:\n LayerNormFunc = RMSNorm if config.rmsnorm else LayerNorm\n # Final layer norm before output.\n self.final_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device,\n dtype=config.torch_dtype)\n\n self.gradient_checkpointing = False\n\n def _get_layer(self, layer_number):\n return self.layers[layer_number]\n\n def forward(\n self, hidden_states, attention_mask, rotary_pos_emb, kv_caches=None,\n use_cache: Optional[bool] = True,\n output_hidden_states: Optional[bool] = False,\n ):\n num_layers = len(self.layers)\n if not kv_caches:\n kv_caches = [None for _ in range(num_layers)]\n presents = () if use_cache else None\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 all_self_attentions = None\n all_hidden_states = () if output_hidden_states else None\n for index in range(num_layers):\n if output_hidden_states:\n all_hidden_states = all_hidden_states + (hidden_states,)\n\n layer = self._get_layer(index)\n if self.gradient_checkpointing and self.training:\n layer_ret = torch.utils.checkpoint.checkpoint(\n layer,\n hidden_states,\n attention_mask,\n rotary_pos_emb,\n kv_caches[index],\n use_cache\n )\n else:\n layer_ret = layer(\n hidden_states,\n attention_mask,\n rotary_pos_emb,\n kv_cache=kv_caches[index],\n use_cache=use_cache\n )\n hidden_states, kv_cache = layer_ret\n if use_cache:\n presents = presents + (kv_cache,)\n\n if output_hidden_states:\n all_hidden_states = all_hidden_states + (hidden_states,)\n\n # Final layer norm.\n if self.post_layer_norm:\n hidden_states = self.final_layernorm(hidden_states)\n\n return hidden_states, presents, all_hidden_states, all_self_attentions\n\n"},"next_line":{"kind":"string","value":"class ChatGLMPreTrainedModel(LookaheadPreTrainedModel):"},"gold_snippet_index":{"kind":"number","value":1,"string":"1"},"created_at":{"kind":"string","value":"2023-12-19 13:11:38+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5987,"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":18306,"string":"18,306"},"cropped_code":{"kind":"string","value":" 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 conv_nd(dims, in_channels, model_channels, 3, padding=1)\n )\n ]\n )\n self._feature_size = model_channels\n input_block_chans = [model_channels]\n ch = model_channels\n ds = 1\n for level, mult in enumerate(channel_mult):\n for nr in range(self.num_res_blocks[level]):\n layers = [\n ResBlock(\n ch,\n time_embed_dim,\n dropout,\n out_channels=mult * model_channels,\n dims=dims,\n use_checkpoint=use_checkpoint,\n use_scale_shift_norm=use_scale_shift_norm,\n )\n ]\n ch = mult * model_channels\n if ds in attention_resolutions:\n if num_head_channels == -1:\n dim_head = ch // num_heads\n else:\n num_heads = ch // num_head_channels\n dim_head = num_head_channels\n if legacy:\n #num_heads = 1\n dim_head = ch // num_heads if use_spatial_transformer else num_head_channels\n if exists(disable_self_attentions):\n disabled_sa = disable_self_attentions[level]\n else:\n disabled_sa = False\n\n if not exists(num_attention_blocks) or nr < num_attention_blocks[level]:\n layers.append(\n AttentionBlock(\n ch,\n use_checkpoint=use_checkpoint,\n num_heads=num_heads,\n num_head_channels=dim_head,\n use_new_attention_order=use_new_attention_order,\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(\n conv_nd(dims, in_channels, model_channels, 3, padding=1)\n )\n ]\n )\n self._feature_size = model_channels\n input_block_chans = [model_channels]\n ch = model_channels\n ds = 1\n for level, mult in enumerate(channel_mult):\n for nr in range(self.num_res_blocks[level]):\n layers = [\n ResBlock(\n ch,\n time_embed_dim,\n dropout,\n out_channels=mult * model_channels,\n dims=dims,\n use_checkpoint=use_checkpoint,\n use_scale_shift_norm=use_scale_shift_norm,\n )\n ]\n ch = mult * model_channels\n if ds in attention_resolutions:\n if num_head_channels == -1:\n dim_head = ch // num_heads\n else:\n num_heads = ch // num_head_channels\n dim_head = num_head_channels\n if legacy:\n #num_heads = 1\n dim_head = ch // num_heads if use_spatial_transformer else num_head_channels\n if exists(disable_self_attentions):\n disabled_sa = disable_self_attentions[level]\n else:\n disabled_sa = False\n\n if not exists(num_attention_blocks) or nr < num_attention_blocks[level]:\n layers.append(\n AttentionBlock(\n ch,\n use_checkpoint=use_checkpoint,\n num_heads=num_heads,\n num_head_channels=dim_head,\n use_new_attention_order=use_new_attention_order,"},"next_line":{"kind":"string","value":" ) if not use_spatial_transformer else SpatialTransformer("},"gold_snippet_index":{"kind":"number","value":4,"string":"4"},"created_at":{"kind":"string","value":"2023-12-16 03:31:33+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5988,"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":14540,"string":"14,540"},"cropped_code":{"kind":"string","value":" 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"},"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)"},"next_line":{"kind":"string","value":" add_wandb_config(cfg)"},"gold_snippet_index":{"kind":"number","value":2,"string":"2"},"created_at":{"kind":"string","value":"2023-12-15 15:40:58+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5989,"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":17572,"string":"17,572"},"cropped_code":{"kind":"string","value":"\n self.use_nfm = use_nfm\n\n #self.n_heads = n_heads\n self.n_heads = 12\n self.n_blocks = n_blocks\n self.dim = dim\n self.block_dim = dim // self.n_blocks\n #self.head_dim = self.block_dim // self.n_heads\n self.head_dim = 64\n self.scale = self.head_dim ** -0.5\n\n self.query_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)\n self.key_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)\n self.value_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)\n self.final = GroupLinearLayer(self.head_dim * self.n_heads, self.block_dim, n_blocks)\n\n def forward(self, x, qkv=None):\n\n use_exshare = False\n\n if qkv is not None:\n klst, vlst = qkv\n\n seq_len, bsz, _ = x.shape\n\n\n if use_exshare:\n x = x.view(seq_len, bsz, self.n_blocks * self.block_dim)\n q = self.query_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)\n k = self.key_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)\n v = self.value_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)\n else:\n x = x.view(seq_len, bsz, self.n_blocks * self.block_dim)\n q = self.query_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)\n k = self.key_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)\n v = self.value_net(x).view(seq_len, bsz, self.n_blocks, 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\n if random.uniform(0,1) < 0.00001:\n print('use NFM?', self.use_nfm)\n\n if self.use_nfm:\n if qkv is not None:\n klst.append(k)\n vlst.append(v)\n #print('len qlst', len(qlst))\n #for kval in klst:\n # print(kval.shape)\n\n k = torch.cat(klst, dim=3)\n v = torch.cat(vlst, dim=3)\n\n\n #should return these q,k,v and save to a big list. Also pull in from the list passed in and concat along dim=3, i.e. so that it's nblocks * nlayers.\n #print('running comm attention with shapes', q.shape, k.shape, v.shape)\n\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, bsz, self.n_blocks * self.head_dim * self.n_heads)\n out = self.final(out)\n out = out.view(seq_len, bsz, self.dim)\n\n return out, score\n\nclass NormLayer(nn.Module):\n def __init__(self, num_rims, dim, export=False):\n super(NormLayer, self).__init__()\n\n self.num_rims = num_rims\n self.dim = dim\n\n self.weight = nn.Parameter(torch.ones(1,1,dim*num_rims,))\n self.bias = nn.Parameter(torch.zeros(1,1,dim*num_rims,))\n\n self.norm = LayerNorm(dim, export=export, elementwise_affine=False)\n\n def forward(self, x):\n seq_len, bsz, _ = x.shape\n x = x.view(seq_len, bsz, self.num_rims, self.dim)\n\n x = self.norm(x)\n\n x = x.view(seq_len, bsz, self.num_rims * self.dim)\n\n weight_use = self.weight.repeat(seq_len, bsz, 1)\n bias_use = self.bias.repeat(seq_len, bsz, 1)\n\n x = x * weight_use + bias_use\n\n return x\n\nclass TransformerEncoderLayer(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, nb, blockatt, blockatt_memory, use_nfm, out_proj_dim=None):\n super().__init__()\n\n self.blockatt = blockatt\n self.blockatt_memory = blockatt_memory\n\n self.embed_dim = args.encoder_embed_dim\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):\n return MultiheadAttention(\n embed_dim,\n args.encoder_attention_heads,\n dropout=args.attention_dropout,\n self_attention=args.self_attention,\n shared_memory_attention = args.shared_memory_attention,\n use_topk = args.use_topk,\n topk = args.topk,\n num_steps = args.num_steps,\n mem_slots = args.mem_slots,\n null_attention = args.null_attention,\n regressive = args.regressive\n )\n\n def upgrade_state_dict_named(self, state_dict, name):\n \"\"\"\n Rename layer norm states from `...layer_norms.0.weight` to\n `...self_attn_layer_norm.weight` and `...layer_norms.1.weight` to\n `...final_layer_norm.weight`\n \"\"\"\n layer_norm_map = {\"0\": \"self_attn_layer_norm\", \"1\": \"final_layer_norm\"}\n for old, new in layer_norm_map.items():\n for m in (\"weight\", \"bias\"):\n k = \"{}.layer_norms.{}.{}\".format(name, old, m)\n if k in state_dict:\n state_dict[\"{}.{}.{}\".format(name, new, m)] = state_dict[k]\n del state_dict[k]\n\n def forward(self, x, encoder_padding_mask, attn_mask: Optional[Tensor] = None, state = None, memory = None):\n \"\"\"\n Args:\n x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)`\n encoder_padding_mask (ByteTensor): binary ByteTensor of shape\n `(batch, src_len)` where padding elements are indicated by ``1``.\n attn_mask (ByteTensor): binary tensor of shape (T_tgt, T_src), where\n T_tgt is the length of query, while T_src is the length of key,\n though here both query and key is x here,\n attn_mask[t_tgt, t_src] = 1 means when calculating embedding\n for t_tgt, t_src is excluded (or masked out), =0 means it is\n included in attention\n Returns:\n encoded output of shape `(seq_len, batch, embed_dim)`\n \"\"\"\n residual = x \n if self.normalize_before:\n x = self.self_attn_layer_norm(x)\n if attn_mask is not None:\n attn_mask = attn_mask.masked_fill(attn_mask.to(torch.bool), -1e8)\n # anything in original attn_mask = 1, becomes -1e8\n # anything in original attn_mask = 0, becomes 0\n # Note that we cannot use -inf here, because at some edge cases,\n # the attention weight (before softmax) for some padded element in query\n # will become -inf, which results in NaN in model parameters\n # TODO: to formally solve this problem, we need to change fairseq's\n # MultiheadAttention. We will do this later on.\n #print(state is not None)\n\n x, memory, _ = self.self_attn( \n query=state if state is not None else x, \n key=x, \n value=x, \n key_padding_mask=encoder_padding_mask, \n attn_mask=attn_mask, \n memory = memory\n )\n\n x = F.dropout(x, p=self.dropout, training=self.training)\n x = residual + x\n if not self.normalize_before:\n x = self.self_attn_layer_norm(x)\n\n residual = x\n if self.normalize_before:\n x = self.final_layer_norm(x)\n x = self.activation_fn(self.fc1(x))\n x = F.dropout(x, p=float(self.activation_dropout), training=self.training)\n x = self.fc2(x)\n x = F.dropout(x, p=self.dropout, training=self.training)\n x = residual + x\n if not self.normalize_before:\n x = self.final_layer_norm(x)\n if self.final_linear is not None:\n x = self.final_linear(x)\n return x, memory \n\nclass Attention(nn.Module):\n def __init__(self, n_heads, n_blocks, dim, use_nfm):\n super(Attention, self).__init__()\n\n self.use_nfm = use_nfm\n\n #self.n_heads = n_heads\n self.n_heads = 12\n self.n_blocks = n_blocks\n self.dim = dim\n self.block_dim = dim // self.n_blocks\n #self.head_dim = self.block_dim // self.n_heads\n self.head_dim = 64\n self.scale = self.head_dim ** -0.5\n\n self.query_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)\n self.key_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)\n self.value_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)\n self.final = GroupLinearLayer(self.head_dim * self.n_heads, self.block_dim, n_blocks)\n\n def forward(self, x, qkv=None):\n\n use_exshare = False\n\n if qkv is not None:\n klst, vlst = qkv\n\n seq_len, bsz, _ = x.shape\n\n\n if use_exshare:\n x = x.view(seq_len, bsz, self.n_blocks * self.block_dim)\n q = self.query_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)\n k = self.key_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)\n v = self.value_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)\n else:\n x = x.view(seq_len, bsz, self.n_blocks * self.block_dim)\n q = self.query_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)\n k = self.key_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)\n v = self.value_net(x).view(seq_len, bsz, self.n_blocks, 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\n if random.uniform(0,1) < 0.00001:\n print('use NFM?', self.use_nfm)\n\n if self.use_nfm:\n if qkv is not None:\n klst.append(k)\n vlst.append(v)\n #print('len qlst', len(qlst))\n #for kval in klst:\n # print(kval.shape)\n\n k = torch.cat(klst, dim=3)\n v = torch.cat(vlst, dim=3)\n\n\n #should return these q,k,v and save to a big list. Also pull in from the list passed in and concat along dim=3, i.e. so that it's nblocks * nlayers.\n #print('running comm attention with shapes', q.shape, k.shape, v.shape)\n\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, bsz, self.n_blocks * self.head_dim * self.n_heads)\n out = self.final(out)\n out = out.view(seq_len, bsz, self.dim)\n\n return out, score\n\nclass NormLayer(nn.Module):\n def __init__(self, num_rims, dim, export=False):\n super(NormLayer, self).__init__()\n\n self.num_rims = num_rims\n self.dim = dim\n\n self.weight = nn.Parameter(torch.ones(1,1,dim*num_rims,))\n self.bias = nn.Parameter(torch.zeros(1,1,dim*num_rims,))\n\n self.norm = LayerNorm(dim, export=export, elementwise_affine=False)\n\n def forward(self, x):\n seq_len, bsz, _ = x.shape\n x = x.view(seq_len, bsz, self.num_rims, self.dim)\n\n x = self.norm(x)\n\n x = x.view(seq_len, bsz, self.num_rims * self.dim)\n\n weight_use = self.weight.repeat(seq_len, bsz, 1)\n bias_use = self.bias.repeat(seq_len, bsz, 1)\n\n x = x * weight_use + bias_use\n\n return x\n\nclass TransformerEncoderLayer(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, nb, blockatt, blockatt_memory, use_nfm, out_proj_dim=None):\n super().__init__()\n\n self.blockatt = blockatt\n self.blockatt_memory = blockatt_memory\n\n self.embed_dim = args.encoder_embed_dim"},"next_line":{"kind":"string","value":" self.quant_noise = getattr(args, \"quant_noise_pq\", 0)"},"gold_snippet_index":{"kind":"number","value":5,"string":"5"},"created_at":{"kind":"string","value":"2023-12-15 13:13:01+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5990,"cells":{"repo_name":{"kind":"string","value":"m-abr/FCPCodebase"},"file_path":{"kind":"string","value":"scripts/utils/Localization.py"},"context":{"kind":"list like","value":[{"identifier":"Agent","path":"agent/Agent.py","snippet":"class Agent(Base_Agent):\n def __init__(self, host:str, agent_port:int, monitor_port:int, unum:int,\n team_name:str, enable_log, enable_draw, wait_for_server=True, is_fat_proxy=False) -> None:\n \n # define robot type\n robot_type = (0,1,1,1,2,3,3,3,4,4,4)[unum-1]\n\n # Initialize base agent\n # Args: Server IP, Agent Port, Monitor Port, Uniform No., Robot Type, Team Name, Enable Log, Enable Draw, play mode correction, Wait for Server, Hear Callback\n super().__init__(host, agent_port, monitor_port, unum, robot_type, team_name, enable_log, enable_draw, True, wait_for_server, None)\n\n self.enable_draw = enable_draw\n self.state = 0 # 0-Normal, 1-Getting up, 2-Kicking\n self.kick_direction = 0\n self.kick_distance = 0\n self.fat_proxy_cmd = \"\" if is_fat_proxy else None\n self.fat_proxy_walk = np.zeros(3) # filtered walk parameters for fat proxy\n\n self.init_pos = ([-14,0],[-9,-5],[-9,0],[-9,5],[-5,-5],[-5,0],[-5,5],[-1,-6],[-1,-2.5],[-1,2.5],[-1,6])[unum-1] # initial formation\n\n\n def beam(self, avoid_center_circle=False):\n r = self.world.robot\n pos = self.init_pos[:] # copy position list \n self.state = 0\n\n # Avoid center circle by moving the player back \n if avoid_center_circle and np.linalg.norm(self.init_pos) < 2.5:\n pos[0] = -2.3 \n\n if np.linalg.norm(pos - r.loc_head_position[:2]) > 0.1 or self.behavior.is_ready(\"Get_Up\"):\n self.scom.commit_beam(pos, M.vector_angle((-pos[0],-pos[1]))) # beam to initial position, face coordinate (0,0)\n else:\n if self.fat_proxy_cmd is None: # normal behavior\n self.behavior.execute(\"Zero_Bent_Knees_Auto_Head\")\n else: # fat proxy behavior\n self.fat_proxy_cmd += \"(proxy dash 0 0 0)\"\n self.fat_proxy_walk = np.zeros(3) # reset fat proxy walk\n\n\n def move(self, target_2d=(0,0), orientation=None, is_orientation_absolute=True,\n avoid_obstacles=True, priority_unums=[], is_aggressive=False, timeout=3000):\n '''\n Walk to target position\n\n Parameters\n ----------\n target_2d : array_like\n 2D target in absolute coordinates\n orientation : float\n absolute or relative orientation of torso, in degrees\n set to None to go towards the target (is_orientation_absolute is ignored)\n is_orientation_absolute : bool\n True if orientation is relative to the field, False if relative to the robot's torso\n avoid_obstacles : bool\n True to avoid obstacles using path planning (maybe reduce timeout arg if this function is called multiple times per simulation cycle)\n priority_unums : list\n list of teammates to avoid (since their role is more important)\n is_aggressive : bool\n if True, safety margins are reduced for opponents\n timeout : float\n restrict path planning to a maximum duration (in microseconds) \n '''\n r = self.world.robot\n\n if self.fat_proxy_cmd is not None: # fat proxy behavior\n self.fat_proxy_move(target_2d, orientation, is_orientation_absolute) # ignore obstacles\n return\n\n if avoid_obstacles:\n target_2d, _, distance_to_final_target = self.path_manager.get_path_to_target(\n target_2d, priority_unums=priority_unums, is_aggressive=is_aggressive, timeout=timeout)\n else:\n distance_to_final_target = np.linalg.norm(target_2d - r.loc_head_position[:2])\n\n self.behavior.execute(\"Walk\", target_2d, True, orientation, is_orientation_absolute, distance_to_final_target) # Args: target, is_target_abs, ori, is_ori_abs, distance\n\n\n\n\n\n def kick(self, kick_direction=None, kick_distance=None, abort=False, enable_pass_command=False):\n '''\n Walk to ball and kick\n\n Parameters\n ----------\n kick_direction : float\n kick direction, in degrees, relative to the field\n kick_distance : float\n kick distance in meters\n abort : bool\n True to abort.\n The method returns True upon successful abortion, which is immediate while the robot is aligning itself. \n However, if the abortion is requested during the kick, it is delayed until the kick is completed.\n avoid_pass_command : bool\n When False, the pass command will be used when at least one opponent is near the ball\n \n Returns\n -------\n finished : bool\n Returns True if the behavior finished or was successfully aborted.\n '''\n\n if self.min_opponent_ball_dist < 1.45 and enable_pass_command:\n self.scom.commit_pass_command()\n\n self.kick_direction = self.kick_direction if kick_direction is None else kick_direction\n self.kick_distance = self.kick_distance if kick_distance is None else kick_distance\n\n if self.fat_proxy_cmd is None: # normal behavior\n return self.behavior.execute(\"Basic_Kick\", self.kick_direction, abort) # Basic_Kick has no kick distance control\n else: # fat proxy behavior\n return self.fat_proxy_kick()\n\n\n\n\n def think_and_send(self):\n w = self.world\n r = self.world.robot \n my_head_pos_2d = r.loc_head_position[:2]\n my_ori = r.imu_torso_orientation\n ball_2d = w.ball_abs_pos[:2]\n ball_vec = ball_2d - my_head_pos_2d\n ball_dir = M.vector_angle(ball_vec)\n ball_dist = np.linalg.norm(ball_vec)\n ball_sq_dist = ball_dist * ball_dist # for faster comparisons\n ball_speed = np.linalg.norm(w.get_ball_abs_vel(6)[:2])\n behavior = self.behavior\n goal_dir = M.target_abs_angle(ball_2d,(15.05,0))\n path_draw_options = self.path_manager.draw_options\n PM = w.play_mode\n PM_GROUP = w.play_mode_group\n\n #--------------------------------------- 1. Preprocessing\n\n slow_ball_pos = w.get_predicted_ball_pos(0.5) # predicted future 2D ball position when ball speed <= 0.5 m/s\n\n # list of squared distances between teammates (including self) and slow ball (sq distance is set to 1000 in some conditions)\n teammates_ball_sq_dist = [np.sum((p.state_abs_pos[:2] - slow_ball_pos) ** 2) # squared distance between teammate and ball\n if p.state_last_update != 0 and (w.time_local_ms - p.state_last_update <= 360 or p.is_self) and not p.state_fallen\n else 1000 # force large distance if teammate does not exist, or its state info is not recent (360 ms), or it has fallen\n for p in w.teammates ]\n\n # list of squared distances between opponents and slow ball (sq distance is set to 1000 in some conditions)\n opponents_ball_sq_dist = [np.sum((p.state_abs_pos[:2] - slow_ball_pos) ** 2) # squared distance between teammate and ball\n if p.state_last_update != 0 and w.time_local_ms - p.state_last_update <= 360 and not p.state_fallen\n else 1000 # force large distance if opponent does not exist, or its state info is not recent (360 ms), or it has fallen\n for p in w.opponents ]\n\n min_teammate_ball_sq_dist = min(teammates_ball_sq_dist)\n self.min_teammate_ball_dist = math.sqrt(min_teammate_ball_sq_dist) # distance between ball and closest teammate\n self.min_opponent_ball_dist = math.sqrt(min(opponents_ball_sq_dist)) # distance between ball and closest opponent\n\n active_player_unum = teammates_ball_sq_dist.index(min_teammate_ball_sq_dist) + 1\n\n\n #--------------------------------------- 2. Decide action\n\n\n\n if PM == w.M_GAME_OVER:\n pass\n elif PM_GROUP == w.MG_ACTIVE_BEAM:\n self.beam()\n elif PM_GROUP == w.MG_PASSIVE_BEAM:\n self.beam(True) # avoid center circle\n elif self.state == 1 or (behavior.is_ready(\"Get_Up\") and self.fat_proxy_cmd is None):\n self.state = 0 if behavior.execute(\"Get_Up\") else 1 # return to normal state if get up behavior has finished\n elif PM == w.M_OUR_KICKOFF:\n if r.unum == 9:\n self.kick(120,3) # no need to change the state when PM is not Play On\n else:\n self.move(self.init_pos, orientation=ball_dir) # walk in place\n elif PM == w.M_THEIR_KICKOFF:\n self.move(self.init_pos, orientation=ball_dir) # walk in place\n elif active_player_unum != r.unum: # I am not the active player\n if r.unum == 1: # I am the goalkeeper\n self.move(self.init_pos, orientation=ball_dir) # walk in place \n else:\n # compute basic formation position based on ball position\n new_x = max(0.5,(ball_2d[0]+15)/15) * (self.init_pos[0]+15) - 15\n if self.min_teammate_ball_dist < self.min_opponent_ball_dist:\n new_x = min(new_x + 3.5, 13) # advance if team has possession\n self.move((new_x,self.init_pos[1]), orientation=ball_dir, priority_unums=[active_player_unum])\n\n else: # I am the active player\n path_draw_options(enable_obstacles=True, enable_path=True, use_team_drawing_channel=True) # enable path drawings for active player (ignored if self.enable_draw is False)\n enable_pass_command = (PM == w.M_PLAY_ON and ball_2d[0]<6)\n\n if r.unum == 1 and PM_GROUP == w.MG_THEIR_KICK: # goalkeeper during their kick\n self.move(self.init_pos, orientation=ball_dir) # walk in place \n if PM == w.M_OUR_CORNER_KICK:\n self.kick( -np.sign(ball_2d[1])*95, 5.5) # kick the ball into the space in front of the opponent's goal\n # no need to change the state when PM is not Play On\n elif self.min_opponent_ball_dist + 0.5 < self.min_teammate_ball_dist: # defend if opponent is considerably closer to the ball\n if self.state == 2: # commit to kick while aborting\n self.state = 0 if self.kick(abort=True) else 2\n else: # move towards ball, but position myself between ball and our goal\n self.move(slow_ball_pos + M.normalize_vec((-16,0) - slow_ball_pos) * 0.2, is_aggressive=True)\n else:\n self.state = 0 if self.kick(goal_dir,9,False,enable_pass_command) else 2\n\n path_draw_options(enable_obstacles=False, enable_path=False) # disable path drawings\n\n #--------------------------------------- 3. Broadcast\n self.radio.broadcast()\n\n #--------------------------------------- 4. Send to server\n if self.fat_proxy_cmd is None: # normal behavior\n self.scom.commit_and_send( r.get_command() )\n else: # fat proxy behavior\n self.scom.commit_and_send( self.fat_proxy_cmd.encode() ) \n self.fat_proxy_cmd = \"\"\n\n #---------------------- annotations for debugging\n if self.enable_draw: \n d = w.draw\n if active_player_unum == r.unum:\n d.point(slow_ball_pos, 3, d.Color.pink, \"status\", False) # predicted future 2D ball position when ball speed <= 0.5 m/s\n d.point(w.ball_2d_pred_pos[-1], 5, d.Color.pink, \"status\", False) # last ball prediction\n d.annotation((*my_head_pos_2d, 0.6), \"I've got it!\" , d.Color.yellow, \"status\")\n else:\n d.clear(\"status\")\n\n\n\n\n #--------------------------------------- Fat proxy auxiliary methods\n\n\n def fat_proxy_kick(self):\n w = self.world\n r = self.world.robot \n ball_2d = w.ball_abs_pos[:2]\n my_head_pos_2d = r.loc_head_position[:2]\n\n if np.linalg.norm(ball_2d - my_head_pos_2d) < 0.25:\n # fat proxy kick arguments: power [0,10]; relative horizontal angle [-180,180]; vertical angle [0,70]\n self.fat_proxy_cmd += f\"(proxy kick 10 {M.normalize_deg( self.kick_direction - r.imu_torso_orientation ):.2f} 20)\" \n self.fat_proxy_walk = np.zeros(3) # reset fat proxy walk\n return True\n else:\n self.fat_proxy_move(ball_2d-(-0.1,0), None, True) # ignore obstacles\n return False\n\n\n def fat_proxy_move(self, target_2d, orientation, is_orientation_absolute):\n r = self.world.robot\n\n target_dist = np.linalg.norm(target_2d - r.loc_head_position[:2])\n target_dir = M.target_rel_angle(r.loc_head_position[:2], r.imu_torso_orientation, target_2d)\n\n if target_dist > 0.1 and abs(target_dir) < 8:\n self.fat_proxy_cmd += (f\"(proxy dash {100} {0} {0})\")\n return\n\n if target_dist < 0.1:\n if is_orientation_absolute:\n orientation = M.normalize_deg( orientation - r.imu_torso_orientation )\n target_dir = np.clip(orientation, -60, 60)\n self.fat_proxy_cmd += (f\"(proxy dash {0} {0} {target_dir:.1f})\")\n else:\n self.fat_proxy_cmd += (f\"(proxy dash {20} {0} {target_dir:.1f})\")"},{"identifier":"Math_Ops","path":"math_ops/Math_Ops.py","snippet":"class Math_Ops():\n '''\n This class provides general mathematical operations that are not directly available through numpy \n '''\n \n @staticmethod\n def deg_sph2cart(spherical_vec):\n ''' Converts SimSpark's spherical coordinates in degrees to cartesian coordinates '''\n r = spherical_vec[0]\n h = spherical_vec[1] * pi / 180\n v = spherical_vec[2] * pi / 180\n return np.array([r * cos(v) * cos(h), r * cos(v) * sin(h), r * sin(v)])\n\n @staticmethod\n def deg_sin(deg_angle):\n ''' Returns sin of degrees '''\n return sin(deg_angle * pi / 180)\n\n @staticmethod\n def deg_cos(deg_angle):\n ''' Returns cos of degrees '''\n return cos(deg_angle * pi / 180)\n\n @staticmethod\n def to_3d(vec_2d, value=0) -> np.ndarray:\n ''' Returns new 3d vector from 2d vector '''\n return np.append(vec_2d,value)\n\n @staticmethod\n def to_2d_as_3d(vec_3d) -> np.ndarray:\n ''' Returns new 3d vector where the 3rd dimension is zero '''\n vec_2d_as_3d = np.copy(vec_3d)\n vec_2d_as_3d[2] = 0\n return vec_2d_as_3d\n\n @staticmethod\n def normalize_vec(vec) -> np.ndarray:\n ''' Divides vector by its length '''\n size = np.linalg.norm(vec)\n if size == 0: return vec\n return vec / size\n\n @staticmethod\n def get_active_directory(dir:str) -> str:\n global GLOBAL_DIR\n return GLOBAL_DIR + dir\n\n @staticmethod\n def acos(val):\n ''' arccosine function that limits input '''\n return acos( np.clip(val,-1,1) )\n \n @staticmethod\n def asin(val):\n ''' arcsine function that limits input '''\n return asin( np.clip(val,-1,1) )\n\n @staticmethod\n def normalize_deg(val):\n ''' normalize val in range [-180,180[ '''\n return (val + 180.0) % 360 - 180\n\n @staticmethod\n def normalize_rad(val):\n ''' normalize val in range [-pi,pi[ '''\n return (val + pi) % (2*pi) - pi\n\n @staticmethod\n def deg_to_rad(val):\n ''' convert degrees to radians '''\n return val * 0.01745329251994330\n\n @staticmethod\n def rad_to_deg(val):\n ''' convert radians to degrees '''\n return val * 57.29577951308232\n\n @staticmethod\n def vector_angle(vector, is_rad=False):\n ''' angle (degrees or radians) of 2D vector '''\n if is_rad:\n return atan2(vector[1], vector[0])\n else:\n return atan2(vector[1], vector[0]) * 180 / pi\n\n @staticmethod\n def vectors_angle(vec1, vec2, is_rad=False):\n ''' get angle between vectors (degrees or radians) '''\n ang_rad = acos(np.dot(Math_Ops.normalize_vec(vec1),Math_Ops.normalize_vec(vec2)))\n return ang_rad if is_rad else ang_rad * 180 / pi\n\n @staticmethod\n def vector_from_angle(angle, is_rad=False):\n ''' unit vector with direction given by `angle` '''\n if is_rad:\n return np.array([cos(angle), sin(angle)], float)\n else:\n return np.array([Math_Ops.deg_cos(angle), Math_Ops.deg_sin(angle)], float)\n\n @staticmethod\n def target_abs_angle(pos2d, target, is_rad=False):\n ''' angle (degrees or radians) of vector (target-pos2d) '''\n if is_rad:\n return atan2(target[1]-pos2d[1], target[0]-pos2d[0])\n else:\n return atan2(target[1]-pos2d[1], target[0]-pos2d[0]) * 180 / pi\n\n @staticmethod\n def target_rel_angle(pos2d, ori, target, is_rad=False):\n ''' relative angle (degrees or radians) of target if we're located at 'pos2d' with orientation 'ori' (degrees or radians) '''\n if is_rad:\n return Math_Ops.normalize_rad( atan2(target[1]-pos2d[1], target[0]-pos2d[0]) - ori )\n else:\n return Math_Ops.normalize_deg( atan2(target[1]-pos2d[1], target[0]-pos2d[0]) * 180 / pi - ori )\n\n @staticmethod\n def rotate_2d_vec(vec, angle, is_rad=False):\n ''' rotate 2D vector anticlockwise around the origin by `angle` '''\n cos_ang = cos(angle) if is_rad else cos(angle * pi / 180)\n sin_ang = sin(angle) if is_rad else sin(angle * pi / 180)\n return np.array([cos_ang*vec[0]-sin_ang*vec[1], sin_ang*vec[0]+cos_ang*vec[1]])\n\n @staticmethod\n def distance_point_to_line(p:np.ndarray, a:np.ndarray, b:np.ndarray):\n ''' \n Distance between point p and 2d line 'ab' (and side where p is)\n\n Parameters\n ----------\n a : ndarray\n 2D point that defines line\n b : ndarray\n 2D point that defines line\n p : ndarray\n 2D point\n\n Returns\n -------\n distance : float\n distance between line and point\n side : str\n if we are at a, looking at b, p may be at our \"left\" or \"right\"\n '''\n line_len = np.linalg.norm(b-a)\n\n if line_len == 0: # assumes vertical line\n dist = sdist = np.linalg.norm(p-a)\n else:\n sdist = np.cross(b-a,p-a)/line_len\n dist = abs(sdist)\n\n return dist, \"left\" if sdist>0 else \"right\"\n\n @staticmethod\n def distance_point_to_segment(p:np.ndarray, a:np.ndarray, b:np.ndarray):\n ''' Distance from point p to 2d line segment 'ab' '''\n \n ap = p-a\n ab = b-a\n\n ad = Math_Ops.vector_projection(ap,ab)\n\n # Is d in ab? We can find k in (ad = k * ab) without computing any norm\n # we use the largest dimension of ab to avoid division by 0\n k = ad[0]/ab[0] if abs(ab[0])>abs(ab[1]) else ad[1]/ab[1]\n\n if k <= 0: return np.linalg.norm(ap)\n elif k >= 1: return np.linalg.norm(p-b)\n else: return np.linalg.norm(p-(ad + a)) # p-d\n\n @staticmethod\n def distance_point_to_ray(p:np.ndarray, ray_start:np.ndarray, ray_direction:np.ndarray):\n ''' Distance from point p to 2d ray '''\n \n rp = p-ray_start\n rd = Math_Ops.vector_projection(rp,ray_direction)\n\n # Is d in ray? We can find k in (rd = k * ray_direction) without computing any norm\n # we use the largest dimension of ray_direction to avoid division by 0\n k = rd[0]/ray_direction[0] if abs(ray_direction[0])>abs(ray_direction[1]) else rd[1]/ray_direction[1]\n\n if k <= 0: return np.linalg.norm(rp)\n else: return np.linalg.norm(p-(rd + ray_start)) # p-d\n\n @staticmethod\n def closest_point_on_ray_to_point(p:np.ndarray, ray_start:np.ndarray, ray_direction:np.ndarray):\n ''' Point on ray closest to point p '''\n \n rp = p-ray_start\n rd = Math_Ops.vector_projection(rp,ray_direction)\n\n # Is d in ray? We can find k in (rd = k * ray_direction) without computing any norm\n # we use the largest dimension of ray_direction to avoid division by 0\n k = rd[0]/ray_direction[0] if abs(ray_direction[0])>abs(ray_direction[1]) else rd[1]/ray_direction[1]\n\n if k <= 0: return ray_start\n else: return rd + ray_start\n\n @staticmethod\n def does_circle_intersect_segment(p:np.ndarray, r, a:np.ndarray, b:np.ndarray):\n ''' Returns true if circle (center p, radius r) intersect 2d line segment '''\n\n ap = p-a\n ab = b-a\n\n ad = Math_Ops.vector_projection(ap,ab)\n\n # Is d in ab? We can find k in (ad = k * ab) without computing any norm\n # we use the largest dimension of ab to avoid division by 0\n k = ad[0]/ab[0] if abs(ab[0])>abs(ab[1]) else ad[1]/ab[1]\n\n if k <= 0: return np.dot(ap,ap) <= r*r\n elif k >= 1: return np.dot(p-b,p-b) <= r*r\n \n dp = p-(ad + a)\n return np.dot(dp,dp) <= r*r\n\n @staticmethod\n def vector_projection(a:np.ndarray, b:np.ndarray):\n ''' Vector projection of a onto b '''\n b_dot = np.dot(b,b)\n return b * np.dot(a,b) / b_dot if b_dot != 0 else b\n\n @staticmethod\n def do_noncollinear_segments_intersect(a,b,c,d):\n ''' \n Check if 2d line segment 'ab' intersects with noncollinear 2d line segment 'cd' \n Explanation: https://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/ \n '''\n\n ccw = lambda a,b,c: (c[1]-a[1]) * (b[0]-a[0]) > (b[1]-a[1]) * (c[0]-a[0])\n return ccw(a,c,d) != ccw(b,c,d) and ccw(a,b,c) != ccw(a,b,d)\n\n @staticmethod\n def intersection_segment_opp_goal(a:np.ndarray, b:np.ndarray):\n ''' Computes the intersection point of 2d segment 'ab' and the opponents' goal (front line) '''\n vec_x = b[0]-a[0]\n\n # Collinear intersections are not accepted\n if vec_x == 0: return None\n \n k = (15.01-a[0])/vec_x\n\n # No collision\n if k < 0 or k > 1: return None\n\n intersection_pt = a + (b-a) * k\n\n if -1.01 <= intersection_pt[1] <= 1.01:\n return intersection_pt\n else:\n return None\n\n @staticmethod\n def intersection_circle_opp_goal(p:np.ndarray, r):\n ''' \n Computes the intersection segment of circle (center p, radius r) and the opponents' goal (front line)\n Only the y coordinates are returned since the x coordinates are always equal to 15\n '''\n\n x_dev = abs(15-p[0])\n\n if x_dev > r:\n return None # no intersection with x=15\n\n y_dev = sqrt(r*r - x_dev*x_dev)\n\n p1 = max(p[1] - y_dev, -1.01)\n p2 = min(p[1] + y_dev, 1.01)\n\n if p1 == p2:\n return p1 # return the y coordinate of a single intersection point\n elif p2 < p1:\n return None # no intersection\n else:\n return p1, p2 # return the y coordinates of the intersection segment\n\n\n @staticmethod\n def distance_point_to_opp_goal(p:np.ndarray):\n ''' Distance between point 'p' and the opponents' goal (front line) '''\n\n if p[1] < -1.01:\n return np.linalg.norm( p-(15,-1.01) )\n elif p[1] > 1.01:\n return np.linalg.norm( p-(15, 1.01) )\n else:\n return abs(15-p[0])\n\n\n @staticmethod\n def circle_line_segment_intersection(circle_center, circle_radius, pt1, pt2, full_line=True, tangent_tol=1e-9):\n \"\"\" Find the points at which a circle intersects a line-segment. This can happen at 0, 1, or 2 points.\n\n :param circle_center: The (x, y) location of the circle center\n :param circle_radius: The radius of the circle\n :param pt1: The (x, y) location of the first point of the segment\n :param pt2: The (x, y) location of the second point of the segment\n :param full_line: True to find intersections along full line - not just in the segment. False will just return intersections within the segment.\n :param tangent_tol: Numerical tolerance at which we decide the intersections are close enough to consider it a tangent\n :return Sequence[Tuple[float, float]]: A list of length 0, 1, or 2, where each element is a point at which the circle intercepts a line segment.\n\n Note: We follow: http://mathworld.wolfram.com/Circle-LineIntersection.html\n \"\"\"\n\n (p1x, p1y), (p2x, p2y), (cx, cy) = pt1, pt2, circle_center\n (x1, y1), (x2, y2) = (p1x - cx, p1y - cy), (p2x - cx, p2y - cy)\n dx, dy = (x2 - x1), (y2 - y1)\n dr = (dx ** 2 + dy ** 2)**.5\n big_d = x1 * y2 - x2 * y1\n discriminant = circle_radius ** 2 * dr ** 2 - big_d ** 2\n\n if discriminant < 0: # No intersection between circle and line\n return []\n else: # There may be 0, 1, or 2 intersections with the segment\n intersections = [\n (cx + (big_d * dy + sign * (-1 if dy < 0 else 1) * dx * discriminant**.5) / dr ** 2,\n cy + (-big_d * dx + sign * abs(dy) * discriminant**.5) / dr ** 2)\n for sign in ((1, -1) if dy < 0 else (-1, 1))] # This makes sure the order along the segment is correct\n if not full_line: # If only considering the segment, filter out intersections that do not fall within the segment\n fraction_along_segment = [\n (xi - p1x) / dx if abs(dx) > abs(dy) else (yi - p1y) / dy for xi, yi in intersections]\n intersections = [pt for pt, frac in zip(\n intersections, fraction_along_segment) if 0 <= frac <= 1]\n # If line is tangent to circle, return just one point (as both intersections have same location)\n if len(intersections) == 2 and abs(discriminant) <= tangent_tol:\n return [intersections[0]]\n else:\n return intersections\n\n\n\n\n # adapted from https://stackoverflow.com/questions/3252194/numpy-and-line-intersections\n @staticmethod\n def get_line_intersection(a1, a2, b1, b2):\n \"\"\" \n Returns the point of intersection of the lines passing through a2,a1 and b2,b1.\n a1: [x, y] a point on the first line\n a2: [x, y] another point on the first line\n b1: [x, y] a point on the second line\n b2: [x, y] another point on the second line\n \"\"\"\n s = np.vstack([a1,a2,b1,b2]) # s for stacked\n h = np.hstack((s, np.ones((4, 1)))) # h for homogeneous\n l1 = np.cross(h[0], h[1]) # get first line\n l2 = np.cross(h[2], h[3]) # get second line\n x, y, z = np.cross(l1, l2) # point of intersection\n if z == 0: # lines are parallel\n return np.array([float('inf'), float('inf')])\n return np.array([x/z, y/z],float)"},{"identifier":"Script","path":"scripts/commons/Script.py","snippet":"class Script():\n ROOT_DIR = path.dirname(path.dirname(realpath( join(getcwd(), dirname(__file__))) )) # project root directory\n\n def __init__(self, cpp_builder_unum=0) -> None:\n\n '''\n Arguments specification\n -----------------------\n - To add new arguments, edit the information below\n - After changing information below, the config.json file must be manually deleted\n - In other modules, these arguments can be accessed by their 1-letter ID\n '''\n # list of arguments: 1-letter ID, Description, Hardcoded default\n self.options = {'i': ('Server Hostname/IP', 'localhost'),\n 'p': ('Agent Port', '3100'),\n 'm': ('Monitor Port', '3200'),\n 't': ('Team Name', 'FCPortugal'),\n 'u': ('Uniform Number', '1'),\n 'r': ('Robot Type', '1'),\n 'P': ('Penalty Shootout', '0'),\n 'F': ('magmaFatProxy', '0'),\n 'D': ('Debug Mode', '1')}\n\n # list of arguments: 1-letter ID, data type, choices \n self.op_types = {'i': (str, None),\n 'p': (int, None),\n 'm': (int, None),\n 't': (str, None),\n 'u': (int, range(1,12)),\n 'r': (int, [0,1,2,3,4]),\n 'P': (int, [0,1]),\n 'F': (int, [0,1]),\n 'D': (int, [0,1])}\n \n '''\n End of arguments specification\n '''\n\n self.read_or_create_config()\n\n #advance help text position\n formatter = lambda prog: argparse.HelpFormatter(prog,max_help_position=52)\n parser = argparse.ArgumentParser(formatter_class=formatter)\n\n o = self.options\n t = self.op_types\n\n for id in self.options: # shorter metavar for aesthetic reasons\n parser.add_argument(f\"-{id}\", help=f\"{o[id][0]:30}[{o[id][1]:20}]\", type=t[id][0], nargs='?', default=o[id][1], metavar='X', choices=t[id][1])\n \n self.args = parser.parse_args()\n\n if getattr(sys, 'frozen', False): # disable debug mode when running from binary\n self.args.D = 0\n\n self.players = [] # list of created players\n\n Script.build_cpp_modules(exit_on_build = (cpp_builder_unum != 0 and cpp_builder_unum != self.args.u))\n\n if self.args.D:\n try:\n print(f\"\\nNOTE: for help run \\\"python {__main__.__file__} -h\\\"\")\n except:\n pass\n\n columns = [[],[],[]]\n for key, value in vars(self.args).items():\n columns[0].append(o[key][0])\n columns[1].append(o[key][1])\n columns[2].append(value)\n\n UI.print_table(columns, [\"Argument\",\"Default at /config.json\",\"Active\"], alignment=[\"<\",\"^\",\"^\"])\n\n\n def read_or_create_config(self) -> None:\n\n if not path.isfile('config.json'): # save hardcoded default values if file does not exist\n with open(\"config.json\", \"w\") as f:\n json.dump(self.options, f, indent=4)\n else: # load user-defined values (that can be overwritten by command-line arguments)\n if path.getsize(\"config.json\") == 0: # wait for possible write operation when launching multiple agents\n from time import sleep\n sleep(1)\n if path.getsize(\"config.json\") == 0: # abort after 1 second\n print(\"Aborting: 'config.json' is empty. Manually verify and delete if still empty.\")\n exit()\n \n with open(\"config.json\", \"r\") as f:\n self.options = json.loads(f.read())\n\n\n @staticmethod\n def build_cpp_modules(special_environment_prefix=[], exit_on_build=False):\n '''\n Build C++ modules in folder /cpp using Pybind11\n \n Parameters\n ----------\n special_environment_prefix : `list`\n command prefix to run a given command in the desired environment\n useful to compile C++ modules for different python interpreter versions (other than default version)\n Conda Env. example: ['conda', 'run', '-n', 'myEnv']\n If [] the default python interpreter is used as compilation target\n exit_on_build : bool\n exit if there is something to build (so that only 1 player per team builds c++ modules)\n '''\n cpp_path = Script.ROOT_DIR + \"/cpp/\"\n exclusions = [\"__pycache__\"]\n\n cpp_modules = [d for d in listdir(cpp_path) if isdir(join(cpp_path, d)) and d not in exclusions]\n\n if not cpp_modules: return #no modules to build\n\n python_cmd = f\"python{sys.version_info.major}.{sys.version_info.minor}\" # \"python3\" can select the wrong version, this prevents that\n\n def init():\n print(\"--------------------------\\nC++ modules:\",cpp_modules)\n\n try:\n process = subprocess.Popen(special_environment_prefix+[python_cmd, \"-m\", \"pybind11\", \"--includes\"], stdout=subprocess.PIPE)\n (includes, err) = process.communicate()\n process.wait()\n except:\n print(f\"Error while executing child program: '{python_cmd} -m pybind11 --includes'\")\n exit()\n\n includes = includes.decode().rstrip() # strip trailing newlines (and other whitespace chars)\n print(\"Using Pybind11 includes: '\",includes,\"'\",sep=\"\")\n return includes\n\n nproc = str(cpu_count())\n zero_modules = True\n\n for module in cpp_modules:\n module_path = join(cpp_path, module)\n\n # skip module if there is no Makefile (typical distribution case)\n if not isfile(join(module_path, \"Makefile\")):\n continue\n\n # skip module in certain conditions\n if isfile(join(module_path, module+\".so\")) and isfile(join(module_path, module+\".c_info\")):\n with open(join(module_path, module+\".c_info\"), 'rb') as f:\n info = pickle.load(f)\n if info == python_cmd:\n code_mod_time = max(getmtime(join(module_path, f)) for f in listdir(module_path) if f.endswith(\".cpp\") or f.endswith(\".h\"))\n bin_mod_time = getmtime(join(module_path, module+\".so\"))\n if bin_mod_time + 30 > code_mod_time: # favor not building with a margin of 30s (scenario: we unzip the fcpy project, including the binaries, the modification times are all similar)\n continue\n\n # init: print stuff & get Pybind11 includes\n if zero_modules:\n if exit_on_build:\n print(\"There are C++ modules to build. This player is not allowed to build. Aborting.\")\n exit()\n zero_modules = False\n includes = init()\n\n # build module\n print(f'{f\"Building: {module}... \":40}',end='',flush=True)\n process = subprocess.Popen(['make', '-j'+nproc, 'PYBIND_INCLUDES='+includes], stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=module_path)\n (output, err) = process.communicate()\n exit_code = process.wait()\n if exit_code == 0:\n print(\"success!\")\n with open(join(module_path, module+\".c_info\"),\"wb\") as f: # save python version\n pickle.dump(python_cmd, f, protocol=4) # protocol 4 is backward compatible with Python 3.4\n else:\n print(\"Aborting! Building errors:\")\n print(output.decode(), err.decode())\n exit() \n\n if not zero_modules:\n print(\"All modules were built successfully!\\n--------------------------\")\n\n\n def batch_create(self, agent_cls, args_per_player): \n ''' Creates batch of agents '''\n\n for a in args_per_player:\n self.players.append( agent_cls(*a) )\n\n def batch_execute_agent(self, index : slice = slice(None)): \n ''' \n Executes agent normally (including commit & send)\n\n Parameters\n ----------\n index : slice\n subset of agents\n (e.g. index=slice(1,2) will select the second agent)\n (e.g. index=slice(1,3) will select the second and third agents)\n by default, all agents are selected\n ''' \n for p in self.players[index]:\n p.think_and_send()\n\n def batch_execute_behavior(self, behavior, index : slice = slice(None)):\n '''\n Executes behavior\n\n Parameters\n ----------\n behavior : str\n name of behavior to execute\n index : slice\n subset of agents\n (e.g. index=slice(1,2) will select the second agent)\n (e.g. index=slice(1,3) will select the second and third agents)\n by default, all agents are selected\n '''\n for p in self.players[index]:\n p.behavior.execute(behavior)\n\n def batch_commit_and_send(self, index : slice = slice(None)):\n '''\n Commits & sends data to server\n\n Parameters\n ----------\n index : slice\n subset of agents\n (e.g. index=slice(1,2) will select the second agent)\n (e.g. index=slice(1,3) will select the second and third agents)\n by default, all agents are selected\n '''\n for p in self.players[index]:\n p.scom.commit_and_send( p.world.robot.get_command() ) \n\n def batch_receive(self, index : slice = slice(None), update=True):\n ''' \n Waits for server messages\n\n Parameters\n ----------\n index : slice\n subset of agents\n (e.g. index=slice(1,2) will select the second agent)\n (e.g. index=slice(1,3) will select the second and third agents)\n by default, all agents are selected\n update : bool\n update world state based on information received from server\n if False, the agent becomes unaware of itself and its surroundings\n which is useful for reducing cpu resources for dummy agents in demonstrations\n '''\n for p in self.players[index]:\n p.scom.receive(update)\n\n def batch_commit_beam(self, pos2d_and_rotation, index : slice = slice(None)):\n '''\n Beam all player to 2D position with a given rotation\n\n Parameters\n ----------\n pos2d_and_rotation : `list`\n iterable of 2D positions and rotations e.g. [(0,0,45),(-5,0,90)]\n index : slice\n subset of agents\n (e.g. index=slice(1,2) will select the second agent)\n (e.g. index=slice(1,3) will select the second and third agents)\n by default, all agents are selected\n ''' \n for p, pos_rot in zip(self.players[index], pos2d_and_rotation): \n p.scom.commit_beam(pos_rot[0:2],pos_rot[2])\n\n def batch_unofficial_beam(self, pos3d_and_rotation, index : slice = slice(None)):\n '''\n Beam all player to 3D position with a given rotation\n\n Parameters\n ----------\n pos3d_and_rotation : `list`\n iterable of 3D positions and rotations e.g. [(0,0,0.5,45),(-5,0,0.5,90)]\n index : slice\n subset of agents\n (e.g. index=slice(1,2) will select the second agent)\n (e.g. index=slice(1,3) will select the second and third agents)\n by default, all agents are selected\n ''' \n for p, pos_rot in zip(self.players[index], pos3d_and_rotation): \n p.scom.unofficial_beam(pos_rot[0:3],pos_rot[3])\n\n def batch_terminate(self, index : slice = slice(None)):\n '''\n Close all sockets connected to the agent port\n For scripts where the agent lives until the application ends, this is not needed\n\n Parameters\n ----------\n index : slice\n subset of agents\n (e.g. index=slice(1,2) will select the second agent)\n (e.g. index=slice(1,3) will select the second and third agents)\n by default, all agents are selected\n '''\n for p in self.players[index]:\n p.terminate()\n del self.players[index] # delete selection"},{"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)"}],"string":"[\n {\n \"identifier\": \"Agent\",\n \"path\": \"agent/Agent.py\",\n \"snippet\": \"class Agent(Base_Agent):\\n def __init__(self, host:str, agent_port:int, monitor_port:int, unum:int,\\n team_name:str, enable_log, enable_draw, wait_for_server=True, is_fat_proxy=False) -> None:\\n \\n # define robot type\\n robot_type = (0,1,1,1,2,3,3,3,4,4,4)[unum-1]\\n\\n # Initialize base agent\\n # Args: Server IP, Agent Port, Monitor Port, Uniform No., Robot Type, Team Name, Enable Log, Enable Draw, play mode correction, Wait for Server, Hear Callback\\n super().__init__(host, agent_port, monitor_port, unum, robot_type, team_name, enable_log, enable_draw, True, wait_for_server, None)\\n\\n self.enable_draw = enable_draw\\n self.state = 0 # 0-Normal, 1-Getting up, 2-Kicking\\n self.kick_direction = 0\\n self.kick_distance = 0\\n self.fat_proxy_cmd = \\\"\\\" if is_fat_proxy else None\\n self.fat_proxy_walk = np.zeros(3) # filtered walk parameters for fat proxy\\n\\n self.init_pos = ([-14,0],[-9,-5],[-9,0],[-9,5],[-5,-5],[-5,0],[-5,5],[-1,-6],[-1,-2.5],[-1,2.5],[-1,6])[unum-1] # initial formation\\n\\n\\n def beam(self, avoid_center_circle=False):\\n r = self.world.robot\\n pos = self.init_pos[:] # copy position list \\n self.state = 0\\n\\n # Avoid center circle by moving the player back \\n if avoid_center_circle and np.linalg.norm(self.init_pos) < 2.5:\\n pos[0] = -2.3 \\n\\n if np.linalg.norm(pos - r.loc_head_position[:2]) > 0.1 or self.behavior.is_ready(\\\"Get_Up\\\"):\\n self.scom.commit_beam(pos, M.vector_angle((-pos[0],-pos[1]))) # beam to initial position, face coordinate (0,0)\\n else:\\n if self.fat_proxy_cmd is None: # normal behavior\\n self.behavior.execute(\\\"Zero_Bent_Knees_Auto_Head\\\")\\n else: # fat proxy behavior\\n self.fat_proxy_cmd += \\\"(proxy dash 0 0 0)\\\"\\n self.fat_proxy_walk = np.zeros(3) # reset fat proxy walk\\n\\n\\n def move(self, target_2d=(0,0), orientation=None, is_orientation_absolute=True,\\n avoid_obstacles=True, priority_unums=[], is_aggressive=False, timeout=3000):\\n '''\\n Walk to target position\\n\\n Parameters\\n ----------\\n target_2d : array_like\\n 2D target in absolute coordinates\\n orientation : float\\n absolute or relative orientation of torso, in degrees\\n set to None to go towards the target (is_orientation_absolute is ignored)\\n is_orientation_absolute : bool\\n True if orientation is relative to the field, False if relative to the robot's torso\\n avoid_obstacles : bool\\n True to avoid obstacles using path planning (maybe reduce timeout arg if this function is called multiple times per simulation cycle)\\n priority_unums : list\\n list of teammates to avoid (since their role is more important)\\n is_aggressive : bool\\n if True, safety margins are reduced for opponents\\n timeout : float\\n restrict path planning to a maximum duration (in microseconds) \\n '''\\n r = self.world.robot\\n\\n if self.fat_proxy_cmd is not None: # fat proxy behavior\\n self.fat_proxy_move(target_2d, orientation, is_orientation_absolute) # ignore obstacles\\n return\\n\\n if avoid_obstacles:\\n target_2d, _, distance_to_final_target = self.path_manager.get_path_to_target(\\n target_2d, priority_unums=priority_unums, is_aggressive=is_aggressive, timeout=timeout)\\n else:\\n distance_to_final_target = np.linalg.norm(target_2d - r.loc_head_position[:2])\\n\\n self.behavior.execute(\\\"Walk\\\", target_2d, True, orientation, is_orientation_absolute, distance_to_final_target) # Args: target, is_target_abs, ori, is_ori_abs, distance\\n\\n\\n\\n\\n\\n def kick(self, kick_direction=None, kick_distance=None, abort=False, enable_pass_command=False):\\n '''\\n Walk to ball and kick\\n\\n Parameters\\n ----------\\n kick_direction : float\\n kick direction, in degrees, relative to the field\\n kick_distance : float\\n kick distance in meters\\n abort : bool\\n True to abort.\\n The method returns True upon successful abortion, which is immediate while the robot is aligning itself. \\n However, if the abortion is requested during the kick, it is delayed until the kick is completed.\\n avoid_pass_command : bool\\n When False, the pass command will be used when at least one opponent is near the ball\\n \\n Returns\\n -------\\n finished : bool\\n Returns True if the behavior finished or was successfully aborted.\\n '''\\n\\n if self.min_opponent_ball_dist < 1.45 and enable_pass_command:\\n self.scom.commit_pass_command()\\n\\n self.kick_direction = self.kick_direction if kick_direction is None else kick_direction\\n self.kick_distance = self.kick_distance if kick_distance is None else kick_distance\\n\\n if self.fat_proxy_cmd is None: # normal behavior\\n return self.behavior.execute(\\\"Basic_Kick\\\", self.kick_direction, abort) # Basic_Kick has no kick distance control\\n else: # fat proxy behavior\\n return self.fat_proxy_kick()\\n\\n\\n\\n\\n def think_and_send(self):\\n w = self.world\\n r = self.world.robot \\n my_head_pos_2d = r.loc_head_position[:2]\\n my_ori = r.imu_torso_orientation\\n ball_2d = w.ball_abs_pos[:2]\\n ball_vec = ball_2d - my_head_pos_2d\\n ball_dir = M.vector_angle(ball_vec)\\n ball_dist = np.linalg.norm(ball_vec)\\n ball_sq_dist = ball_dist * ball_dist # for faster comparisons\\n ball_speed = np.linalg.norm(w.get_ball_abs_vel(6)[:2])\\n behavior = self.behavior\\n goal_dir = M.target_abs_angle(ball_2d,(15.05,0))\\n path_draw_options = self.path_manager.draw_options\\n PM = w.play_mode\\n PM_GROUP = w.play_mode_group\\n\\n #--------------------------------------- 1. Preprocessing\\n\\n slow_ball_pos = w.get_predicted_ball_pos(0.5) # predicted future 2D ball position when ball speed <= 0.5 m/s\\n\\n # list of squared distances between teammates (including self) and slow ball (sq distance is set to 1000 in some conditions)\\n teammates_ball_sq_dist = [np.sum((p.state_abs_pos[:2] - slow_ball_pos) ** 2) # squared distance between teammate and ball\\n if p.state_last_update != 0 and (w.time_local_ms - p.state_last_update <= 360 or p.is_self) and not p.state_fallen\\n else 1000 # force large distance if teammate does not exist, or its state info is not recent (360 ms), or it has fallen\\n for p in w.teammates ]\\n\\n # list of squared distances between opponents and slow ball (sq distance is set to 1000 in some conditions)\\n opponents_ball_sq_dist = [np.sum((p.state_abs_pos[:2] - slow_ball_pos) ** 2) # squared distance between teammate and ball\\n if p.state_last_update != 0 and w.time_local_ms - p.state_last_update <= 360 and not p.state_fallen\\n else 1000 # force large distance if opponent does not exist, or its state info is not recent (360 ms), or it has fallen\\n for p in w.opponents ]\\n\\n min_teammate_ball_sq_dist = min(teammates_ball_sq_dist)\\n self.min_teammate_ball_dist = math.sqrt(min_teammate_ball_sq_dist) # distance between ball and closest teammate\\n self.min_opponent_ball_dist = math.sqrt(min(opponents_ball_sq_dist)) # distance between ball and closest opponent\\n\\n active_player_unum = teammates_ball_sq_dist.index(min_teammate_ball_sq_dist) + 1\\n\\n\\n #--------------------------------------- 2. Decide action\\n\\n\\n\\n if PM == w.M_GAME_OVER:\\n pass\\n elif PM_GROUP == w.MG_ACTIVE_BEAM:\\n self.beam()\\n elif PM_GROUP == w.MG_PASSIVE_BEAM:\\n self.beam(True) # avoid center circle\\n elif self.state == 1 or (behavior.is_ready(\\\"Get_Up\\\") and self.fat_proxy_cmd is None):\\n self.state = 0 if behavior.execute(\\\"Get_Up\\\") else 1 # return to normal state if get up behavior has finished\\n elif PM == w.M_OUR_KICKOFF:\\n if r.unum == 9:\\n self.kick(120,3) # no need to change the state when PM is not Play On\\n else:\\n self.move(self.init_pos, orientation=ball_dir) # walk in place\\n elif PM == w.M_THEIR_KICKOFF:\\n self.move(self.init_pos, orientation=ball_dir) # walk in place\\n elif active_player_unum != r.unum: # I am not the active player\\n if r.unum == 1: # I am the goalkeeper\\n self.move(self.init_pos, orientation=ball_dir) # walk in place \\n else:\\n # compute basic formation position based on ball position\\n new_x = max(0.5,(ball_2d[0]+15)/15) * (self.init_pos[0]+15) - 15\\n if self.min_teammate_ball_dist < self.min_opponent_ball_dist:\\n new_x = min(new_x + 3.5, 13) # advance if team has possession\\n self.move((new_x,self.init_pos[1]), orientation=ball_dir, priority_unums=[active_player_unum])\\n\\n else: # I am the active player\\n path_draw_options(enable_obstacles=True, enable_path=True, use_team_drawing_channel=True) # enable path drawings for active player (ignored if self.enable_draw is False)\\n enable_pass_command = (PM == w.M_PLAY_ON and ball_2d[0]<6)\\n\\n if r.unum == 1 and PM_GROUP == w.MG_THEIR_KICK: # goalkeeper during their kick\\n self.move(self.init_pos, orientation=ball_dir) # walk in place \\n if PM == w.M_OUR_CORNER_KICK:\\n self.kick( -np.sign(ball_2d[1])*95, 5.5) # kick the ball into the space in front of the opponent's goal\\n # no need to change the state when PM is not Play On\\n elif self.min_opponent_ball_dist + 0.5 < self.min_teammate_ball_dist: # defend if opponent is considerably closer to the ball\\n if self.state == 2: # commit to kick while aborting\\n self.state = 0 if self.kick(abort=True) else 2\\n else: # move towards ball, but position myself between ball and our goal\\n self.move(slow_ball_pos + M.normalize_vec((-16,0) - slow_ball_pos) * 0.2, is_aggressive=True)\\n else:\\n self.state = 0 if self.kick(goal_dir,9,False,enable_pass_command) else 2\\n\\n path_draw_options(enable_obstacles=False, enable_path=False) # disable path drawings\\n\\n #--------------------------------------- 3. Broadcast\\n self.radio.broadcast()\\n\\n #--------------------------------------- 4. Send to server\\n if self.fat_proxy_cmd is None: # normal behavior\\n self.scom.commit_and_send( r.get_command() )\\n else: # fat proxy behavior\\n self.scom.commit_and_send( self.fat_proxy_cmd.encode() ) \\n self.fat_proxy_cmd = \\\"\\\"\\n\\n #---------------------- annotations for debugging\\n if self.enable_draw: \\n d = w.draw\\n if active_player_unum == r.unum:\\n d.point(slow_ball_pos, 3, d.Color.pink, \\\"status\\\", False) # predicted future 2D ball position when ball speed <= 0.5 m/s\\n d.point(w.ball_2d_pred_pos[-1], 5, d.Color.pink, \\\"status\\\", False) # last ball prediction\\n d.annotation((*my_head_pos_2d, 0.6), \\\"I've got it!\\\" , d.Color.yellow, \\\"status\\\")\\n else:\\n d.clear(\\\"status\\\")\\n\\n\\n\\n\\n #--------------------------------------- Fat proxy auxiliary methods\\n\\n\\n def fat_proxy_kick(self):\\n w = self.world\\n r = self.world.robot \\n ball_2d = w.ball_abs_pos[:2]\\n my_head_pos_2d = r.loc_head_position[:2]\\n\\n if np.linalg.norm(ball_2d - my_head_pos_2d) < 0.25:\\n # fat proxy kick arguments: power [0,10]; relative horizontal angle [-180,180]; vertical angle [0,70]\\n self.fat_proxy_cmd += f\\\"(proxy kick 10 {M.normalize_deg( self.kick_direction - r.imu_torso_orientation ):.2f} 20)\\\" \\n self.fat_proxy_walk = np.zeros(3) # reset fat proxy walk\\n return True\\n else:\\n self.fat_proxy_move(ball_2d-(-0.1,0), None, True) # ignore obstacles\\n return False\\n\\n\\n def fat_proxy_move(self, target_2d, orientation, is_orientation_absolute):\\n r = self.world.robot\\n\\n target_dist = np.linalg.norm(target_2d - r.loc_head_position[:2])\\n target_dir = M.target_rel_angle(r.loc_head_position[:2], r.imu_torso_orientation, target_2d)\\n\\n if target_dist > 0.1 and abs(target_dir) < 8:\\n self.fat_proxy_cmd += (f\\\"(proxy dash {100} {0} {0})\\\")\\n return\\n\\n if target_dist < 0.1:\\n if is_orientation_absolute:\\n orientation = M.normalize_deg( orientation - r.imu_torso_orientation )\\n target_dir = np.clip(orientation, -60, 60)\\n self.fat_proxy_cmd += (f\\\"(proxy dash {0} {0} {target_dir:.1f})\\\")\\n else:\\n self.fat_proxy_cmd += (f\\\"(proxy dash {20} {0} {target_dir:.1f})\\\")\"\n },\n {\n \"identifier\": \"Math_Ops\",\n \"path\": \"math_ops/Math_Ops.py\",\n \"snippet\": \"class Math_Ops():\\n '''\\n This class provides general mathematical operations that are not directly available through numpy \\n '''\\n \\n @staticmethod\\n def deg_sph2cart(spherical_vec):\\n ''' Converts SimSpark's spherical coordinates in degrees to cartesian coordinates '''\\n r = spherical_vec[0]\\n h = spherical_vec[1] * pi / 180\\n v = spherical_vec[2] * pi / 180\\n return np.array([r * cos(v) * cos(h), r * cos(v) * sin(h), r * sin(v)])\\n\\n @staticmethod\\n def deg_sin(deg_angle):\\n ''' Returns sin of degrees '''\\n return sin(deg_angle * pi / 180)\\n\\n @staticmethod\\n def deg_cos(deg_angle):\\n ''' Returns cos of degrees '''\\n return cos(deg_angle * pi / 180)\\n\\n @staticmethod\\n def to_3d(vec_2d, value=0) -> np.ndarray:\\n ''' Returns new 3d vector from 2d vector '''\\n return np.append(vec_2d,value)\\n\\n @staticmethod\\n def to_2d_as_3d(vec_3d) -> np.ndarray:\\n ''' Returns new 3d vector where the 3rd dimension is zero '''\\n vec_2d_as_3d = np.copy(vec_3d)\\n vec_2d_as_3d[2] = 0\\n return vec_2d_as_3d\\n\\n @staticmethod\\n def normalize_vec(vec) -> np.ndarray:\\n ''' Divides vector by its length '''\\n size = np.linalg.norm(vec)\\n if size == 0: return vec\\n return vec / size\\n\\n @staticmethod\\n def get_active_directory(dir:str) -> str:\\n global GLOBAL_DIR\\n return GLOBAL_DIR + dir\\n\\n @staticmethod\\n def acos(val):\\n ''' arccosine function that limits input '''\\n return acos( np.clip(val,-1,1) )\\n \\n @staticmethod\\n def asin(val):\\n ''' arcsine function that limits input '''\\n return asin( np.clip(val,-1,1) )\\n\\n @staticmethod\\n def normalize_deg(val):\\n ''' normalize val in range [-180,180[ '''\\n return (val + 180.0) % 360 - 180\\n\\n @staticmethod\\n def normalize_rad(val):\\n ''' normalize val in range [-pi,pi[ '''\\n return (val + pi) % (2*pi) - pi\\n\\n @staticmethod\\n def deg_to_rad(val):\\n ''' convert degrees to radians '''\\n return val * 0.01745329251994330\\n\\n @staticmethod\\n def rad_to_deg(val):\\n ''' convert radians to degrees '''\\n return val * 57.29577951308232\\n\\n @staticmethod\\n def vector_angle(vector, is_rad=False):\\n ''' angle (degrees or radians) of 2D vector '''\\n if is_rad:\\n return atan2(vector[1], vector[0])\\n else:\\n return atan2(vector[1], vector[0]) * 180 / pi\\n\\n @staticmethod\\n def vectors_angle(vec1, vec2, is_rad=False):\\n ''' get angle between vectors (degrees or radians) '''\\n ang_rad = acos(np.dot(Math_Ops.normalize_vec(vec1),Math_Ops.normalize_vec(vec2)))\\n return ang_rad if is_rad else ang_rad * 180 / pi\\n\\n @staticmethod\\n def vector_from_angle(angle, is_rad=False):\\n ''' unit vector with direction given by `angle` '''\\n if is_rad:\\n return np.array([cos(angle), sin(angle)], float)\\n else:\\n return np.array([Math_Ops.deg_cos(angle), Math_Ops.deg_sin(angle)], float)\\n\\n @staticmethod\\n def target_abs_angle(pos2d, target, is_rad=False):\\n ''' angle (degrees or radians) of vector (target-pos2d) '''\\n if is_rad:\\n return atan2(target[1]-pos2d[1], target[0]-pos2d[0])\\n else:\\n return atan2(target[1]-pos2d[1], target[0]-pos2d[0]) * 180 / pi\\n\\n @staticmethod\\n def target_rel_angle(pos2d, ori, target, is_rad=False):\\n ''' relative angle (degrees or radians) of target if we're located at 'pos2d' with orientation 'ori' (degrees or radians) '''\\n if is_rad:\\n return Math_Ops.normalize_rad( atan2(target[1]-pos2d[1], target[0]-pos2d[0]) - ori )\\n else:\\n return Math_Ops.normalize_deg( atan2(target[1]-pos2d[1], target[0]-pos2d[0]) * 180 / pi - ori )\\n\\n @staticmethod\\n def rotate_2d_vec(vec, angle, is_rad=False):\\n ''' rotate 2D vector anticlockwise around the origin by `angle` '''\\n cos_ang = cos(angle) if is_rad else cos(angle * pi / 180)\\n sin_ang = sin(angle) if is_rad else sin(angle * pi / 180)\\n return np.array([cos_ang*vec[0]-sin_ang*vec[1], sin_ang*vec[0]+cos_ang*vec[1]])\\n\\n @staticmethod\\n def distance_point_to_line(p:np.ndarray, a:np.ndarray, b:np.ndarray):\\n ''' \\n Distance between point p and 2d line 'ab' (and side where p is)\\n\\n Parameters\\n ----------\\n a : ndarray\\n 2D point that defines line\\n b : ndarray\\n 2D point that defines line\\n p : ndarray\\n 2D point\\n\\n Returns\\n -------\\n distance : float\\n distance between line and point\\n side : str\\n if we are at a, looking at b, p may be at our \\\"left\\\" or \\\"right\\\"\\n '''\\n line_len = np.linalg.norm(b-a)\\n\\n if line_len == 0: # assumes vertical line\\n dist = sdist = np.linalg.norm(p-a)\\n else:\\n sdist = np.cross(b-a,p-a)/line_len\\n dist = abs(sdist)\\n\\n return dist, \\\"left\\\" if sdist>0 else \\\"right\\\"\\n\\n @staticmethod\\n def distance_point_to_segment(p:np.ndarray, a:np.ndarray, b:np.ndarray):\\n ''' Distance from point p to 2d line segment 'ab' '''\\n \\n ap = p-a\\n ab = b-a\\n\\n ad = Math_Ops.vector_projection(ap,ab)\\n\\n # Is d in ab? We can find k in (ad = k * ab) without computing any norm\\n # we use the largest dimension of ab to avoid division by 0\\n k = ad[0]/ab[0] if abs(ab[0])>abs(ab[1]) else ad[1]/ab[1]\\n\\n if k <= 0: return np.linalg.norm(ap)\\n elif k >= 1: return np.linalg.norm(p-b)\\n else: return np.linalg.norm(p-(ad + a)) # p-d\\n\\n @staticmethod\\n def distance_point_to_ray(p:np.ndarray, ray_start:np.ndarray, ray_direction:np.ndarray):\\n ''' Distance from point p to 2d ray '''\\n \\n rp = p-ray_start\\n rd = Math_Ops.vector_projection(rp,ray_direction)\\n\\n # Is d in ray? We can find k in (rd = k * ray_direction) without computing any norm\\n # we use the largest dimension of ray_direction to avoid division by 0\\n k = rd[0]/ray_direction[0] if abs(ray_direction[0])>abs(ray_direction[1]) else rd[1]/ray_direction[1]\\n\\n if k <= 0: return np.linalg.norm(rp)\\n else: return np.linalg.norm(p-(rd + ray_start)) # p-d\\n\\n @staticmethod\\n def closest_point_on_ray_to_point(p:np.ndarray, ray_start:np.ndarray, ray_direction:np.ndarray):\\n ''' Point on ray closest to point p '''\\n \\n rp = p-ray_start\\n rd = Math_Ops.vector_projection(rp,ray_direction)\\n\\n # Is d in ray? We can find k in (rd = k * ray_direction) without computing any norm\\n # we use the largest dimension of ray_direction to avoid division by 0\\n k = rd[0]/ray_direction[0] if abs(ray_direction[0])>abs(ray_direction[1]) else rd[1]/ray_direction[1]\\n\\n if k <= 0: return ray_start\\n else: return rd + ray_start\\n\\n @staticmethod\\n def does_circle_intersect_segment(p:np.ndarray, r, a:np.ndarray, b:np.ndarray):\\n ''' Returns true if circle (center p, radius r) intersect 2d line segment '''\\n\\n ap = p-a\\n ab = b-a\\n\\n ad = Math_Ops.vector_projection(ap,ab)\\n\\n # Is d in ab? We can find k in (ad = k * ab) without computing any norm\\n # we use the largest dimension of ab to avoid division by 0\\n k = ad[0]/ab[0] if abs(ab[0])>abs(ab[1]) else ad[1]/ab[1]\\n\\n if k <= 0: return np.dot(ap,ap) <= r*r\\n elif k >= 1: return np.dot(p-b,p-b) <= r*r\\n \\n dp = p-(ad + a)\\n return np.dot(dp,dp) <= r*r\\n\\n @staticmethod\\n def vector_projection(a:np.ndarray, b:np.ndarray):\\n ''' Vector projection of a onto b '''\\n b_dot = np.dot(b,b)\\n return b * np.dot(a,b) / b_dot if b_dot != 0 else b\\n\\n @staticmethod\\n def do_noncollinear_segments_intersect(a,b,c,d):\\n ''' \\n Check if 2d line segment 'ab' intersects with noncollinear 2d line segment 'cd' \\n Explanation: https://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/ \\n '''\\n\\n ccw = lambda a,b,c: (c[1]-a[1]) * (b[0]-a[0]) > (b[1]-a[1]) * (c[0]-a[0])\\n return ccw(a,c,d) != ccw(b,c,d) and ccw(a,b,c) != ccw(a,b,d)\\n\\n @staticmethod\\n def intersection_segment_opp_goal(a:np.ndarray, b:np.ndarray):\\n ''' Computes the intersection point of 2d segment 'ab' and the opponents' goal (front line) '''\\n vec_x = b[0]-a[0]\\n\\n # Collinear intersections are not accepted\\n if vec_x == 0: return None\\n \\n k = (15.01-a[0])/vec_x\\n\\n # No collision\\n if k < 0 or k > 1: return None\\n\\n intersection_pt = a + (b-a) * k\\n\\n if -1.01 <= intersection_pt[1] <= 1.01:\\n return intersection_pt\\n else:\\n return None\\n\\n @staticmethod\\n def intersection_circle_opp_goal(p:np.ndarray, r):\\n ''' \\n Computes the intersection segment of circle (center p, radius r) and the opponents' goal (front line)\\n Only the y coordinates are returned since the x coordinates are always equal to 15\\n '''\\n\\n x_dev = abs(15-p[0])\\n\\n if x_dev > r:\\n return None # no intersection with x=15\\n\\n y_dev = sqrt(r*r - x_dev*x_dev)\\n\\n p1 = max(p[1] - y_dev, -1.01)\\n p2 = min(p[1] + y_dev, 1.01)\\n\\n if p1 == p2:\\n return p1 # return the y coordinate of a single intersection point\\n elif p2 < p1:\\n return None # no intersection\\n else:\\n return p1, p2 # return the y coordinates of the intersection segment\\n\\n\\n @staticmethod\\n def distance_point_to_opp_goal(p:np.ndarray):\\n ''' Distance between point 'p' and the opponents' goal (front line) '''\\n\\n if p[1] < -1.01:\\n return np.linalg.norm( p-(15,-1.01) )\\n elif p[1] > 1.01:\\n return np.linalg.norm( p-(15, 1.01) )\\n else:\\n return abs(15-p[0])\\n\\n\\n @staticmethod\\n def circle_line_segment_intersection(circle_center, circle_radius, pt1, pt2, full_line=True, tangent_tol=1e-9):\\n \\\"\\\"\\\" Find the points at which a circle intersects a line-segment. This can happen at 0, 1, or 2 points.\\n\\n :param circle_center: The (x, y) location of the circle center\\n :param circle_radius: The radius of the circle\\n :param pt1: The (x, y) location of the first point of the segment\\n :param pt2: The (x, y) location of the second point of the segment\\n :param full_line: True to find intersections along full line - not just in the segment. False will just return intersections within the segment.\\n :param tangent_tol: Numerical tolerance at which we decide the intersections are close enough to consider it a tangent\\n :return Sequence[Tuple[float, float]]: A list of length 0, 1, or 2, where each element is a point at which the circle intercepts a line segment.\\n\\n Note: We follow: http://mathworld.wolfram.com/Circle-LineIntersection.html\\n \\\"\\\"\\\"\\n\\n (p1x, p1y), (p2x, p2y), (cx, cy) = pt1, pt2, circle_center\\n (x1, y1), (x2, y2) = (p1x - cx, p1y - cy), (p2x - cx, p2y - cy)\\n dx, dy = (x2 - x1), (y2 - y1)\\n dr = (dx ** 2 + dy ** 2)**.5\\n big_d = x1 * y2 - x2 * y1\\n discriminant = circle_radius ** 2 * dr ** 2 - big_d ** 2\\n\\n if discriminant < 0: # No intersection between circle and line\\n return []\\n else: # There may be 0, 1, or 2 intersections with the segment\\n intersections = [\\n (cx + (big_d * dy + sign * (-1 if dy < 0 else 1) * dx * discriminant**.5) / dr ** 2,\\n cy + (-big_d * dx + sign * abs(dy) * discriminant**.5) / dr ** 2)\\n for sign in ((1, -1) if dy < 0 else (-1, 1))] # This makes sure the order along the segment is correct\\n if not full_line: # If only considering the segment, filter out intersections that do not fall within the segment\\n fraction_along_segment = [\\n (xi - p1x) / dx if abs(dx) > abs(dy) else (yi - p1y) / dy for xi, yi in intersections]\\n intersections = [pt for pt, frac in zip(\\n intersections, fraction_along_segment) if 0 <= frac <= 1]\\n # If line is tangent to circle, return just one point (as both intersections have same location)\\n if len(intersections) == 2 and abs(discriminant) <= tangent_tol:\\n return [intersections[0]]\\n else:\\n return intersections\\n\\n\\n\\n\\n # adapted from https://stackoverflow.com/questions/3252194/numpy-and-line-intersections\\n @staticmethod\\n def get_line_intersection(a1, a2, b1, b2):\\n \\\"\\\"\\\" \\n Returns the point of intersection of the lines passing through a2,a1 and b2,b1.\\n a1: [x, y] a point on the first line\\n a2: [x, y] another point on the first line\\n b1: [x, y] a point on the second line\\n b2: [x, y] another point on the second line\\n \\\"\\\"\\\"\\n s = np.vstack([a1,a2,b1,b2]) # s for stacked\\n h = np.hstack((s, np.ones((4, 1)))) # h for homogeneous\\n l1 = np.cross(h[0], h[1]) # get first line\\n l2 = np.cross(h[2], h[3]) # get second line\\n x, y, z = np.cross(l1, l2) # point of intersection\\n if z == 0: # lines are parallel\\n return np.array([float('inf'), float('inf')])\\n return np.array([x/z, y/z],float)\"\n },\n {\n \"identifier\": \"Script\",\n \"path\": \"scripts/commons/Script.py\",\n \"snippet\": \"class Script():\\n ROOT_DIR = path.dirname(path.dirname(realpath( join(getcwd(), dirname(__file__))) )) # project root directory\\n\\n def __init__(self, cpp_builder_unum=0) -> None:\\n\\n '''\\n Arguments specification\\n -----------------------\\n - To add new arguments, edit the information below\\n - After changing information below, the config.json file must be manually deleted\\n - In other modules, these arguments can be accessed by their 1-letter ID\\n '''\\n # list of arguments: 1-letter ID, Description, Hardcoded default\\n self.options = {'i': ('Server Hostname/IP', 'localhost'),\\n 'p': ('Agent Port', '3100'),\\n 'm': ('Monitor Port', '3200'),\\n 't': ('Team Name', 'FCPortugal'),\\n 'u': ('Uniform Number', '1'),\\n 'r': ('Robot Type', '1'),\\n 'P': ('Penalty Shootout', '0'),\\n 'F': ('magmaFatProxy', '0'),\\n 'D': ('Debug Mode', '1')}\\n\\n # list of arguments: 1-letter ID, data type, choices \\n self.op_types = {'i': (str, None),\\n 'p': (int, None),\\n 'm': (int, None),\\n 't': (str, None),\\n 'u': (int, range(1,12)),\\n 'r': (int, [0,1,2,3,4]),\\n 'P': (int, [0,1]),\\n 'F': (int, [0,1]),\\n 'D': (int, [0,1])}\\n \\n '''\\n End of arguments specification\\n '''\\n\\n self.read_or_create_config()\\n\\n #advance help text position\\n formatter = lambda prog: argparse.HelpFormatter(prog,max_help_position=52)\\n parser = argparse.ArgumentParser(formatter_class=formatter)\\n\\n o = self.options\\n t = self.op_types\\n\\n for id in self.options: # shorter metavar for aesthetic reasons\\n parser.add_argument(f\\\"-{id}\\\", help=f\\\"{o[id][0]:30}[{o[id][1]:20}]\\\", type=t[id][0], nargs='?', default=o[id][1], metavar='X', choices=t[id][1])\\n \\n self.args = parser.parse_args()\\n\\n if getattr(sys, 'frozen', False): # disable debug mode when running from binary\\n self.args.D = 0\\n\\n self.players = [] # list of created players\\n\\n Script.build_cpp_modules(exit_on_build = (cpp_builder_unum != 0 and cpp_builder_unum != self.args.u))\\n\\n if self.args.D:\\n try:\\n print(f\\\"\\\\nNOTE: for help run \\\\\\\"python {__main__.__file__} -h\\\\\\\"\\\")\\n except:\\n pass\\n\\n columns = [[],[],[]]\\n for key, value in vars(self.args).items():\\n columns[0].append(o[key][0])\\n columns[1].append(o[key][1])\\n columns[2].append(value)\\n\\n UI.print_table(columns, [\\\"Argument\\\",\\\"Default at /config.json\\\",\\\"Active\\\"], alignment=[\\\"<\\\",\\\"^\\\",\\\"^\\\"])\\n\\n\\n def read_or_create_config(self) -> None:\\n\\n if not path.isfile('config.json'): # save hardcoded default values if file does not exist\\n with open(\\\"config.json\\\", \\\"w\\\") as f:\\n json.dump(self.options, f, indent=4)\\n else: # load user-defined values (that can be overwritten by command-line arguments)\\n if path.getsize(\\\"config.json\\\") == 0: # wait for possible write operation when launching multiple agents\\n from time import sleep\\n sleep(1)\\n if path.getsize(\\\"config.json\\\") == 0: # abort after 1 second\\n print(\\\"Aborting: 'config.json' is empty. Manually verify and delete if still empty.\\\")\\n exit()\\n \\n with open(\\\"config.json\\\", \\\"r\\\") as f:\\n self.options = json.loads(f.read())\\n\\n\\n @staticmethod\\n def build_cpp_modules(special_environment_prefix=[], exit_on_build=False):\\n '''\\n Build C++ modules in folder /cpp using Pybind11\\n \\n Parameters\\n ----------\\n special_environment_prefix : `list`\\n command prefix to run a given command in the desired environment\\n useful to compile C++ modules for different python interpreter versions (other than default version)\\n Conda Env. example: ['conda', 'run', '-n', 'myEnv']\\n If [] the default python interpreter is used as compilation target\\n exit_on_build : bool\\n exit if there is something to build (so that only 1 player per team builds c++ modules)\\n '''\\n cpp_path = Script.ROOT_DIR + \\\"/cpp/\\\"\\n exclusions = [\\\"__pycache__\\\"]\\n\\n cpp_modules = [d for d in listdir(cpp_path) if isdir(join(cpp_path, d)) and d not in exclusions]\\n\\n if not cpp_modules: return #no modules to build\\n\\n python_cmd = f\\\"python{sys.version_info.major}.{sys.version_info.minor}\\\" # \\\"python3\\\" can select the wrong version, this prevents that\\n\\n def init():\\n print(\\\"--------------------------\\\\nC++ modules:\\\",cpp_modules)\\n\\n try:\\n process = subprocess.Popen(special_environment_prefix+[python_cmd, \\\"-m\\\", \\\"pybind11\\\", \\\"--includes\\\"], stdout=subprocess.PIPE)\\n (includes, err) = process.communicate()\\n process.wait()\\n except:\\n print(f\\\"Error while executing child program: '{python_cmd} -m pybind11 --includes'\\\")\\n exit()\\n\\n includes = includes.decode().rstrip() # strip trailing newlines (and other whitespace chars)\\n print(\\\"Using Pybind11 includes: '\\\",includes,\\\"'\\\",sep=\\\"\\\")\\n return includes\\n\\n nproc = str(cpu_count())\\n zero_modules = True\\n\\n for module in cpp_modules:\\n module_path = join(cpp_path, module)\\n\\n # skip module if there is no Makefile (typical distribution case)\\n if not isfile(join(module_path, \\\"Makefile\\\")):\\n continue\\n\\n # skip module in certain conditions\\n if isfile(join(module_path, module+\\\".so\\\")) and isfile(join(module_path, module+\\\".c_info\\\")):\\n with open(join(module_path, module+\\\".c_info\\\"), 'rb') as f:\\n info = pickle.load(f)\\n if info == python_cmd:\\n code_mod_time = max(getmtime(join(module_path, f)) for f in listdir(module_path) if f.endswith(\\\".cpp\\\") or f.endswith(\\\".h\\\"))\\n bin_mod_time = getmtime(join(module_path, module+\\\".so\\\"))\\n if bin_mod_time + 30 > code_mod_time: # favor not building with a margin of 30s (scenario: we unzip the fcpy project, including the binaries, the modification times are all similar)\\n continue\\n\\n # init: print stuff & get Pybind11 includes\\n if zero_modules:\\n if exit_on_build:\\n print(\\\"There are C++ modules to build. This player is not allowed to build. Aborting.\\\")\\n exit()\\n zero_modules = False\\n includes = init()\\n\\n # build module\\n print(f'{f\\\"Building: {module}... \\\":40}',end='',flush=True)\\n process = subprocess.Popen(['make', '-j'+nproc, 'PYBIND_INCLUDES='+includes], stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=module_path)\\n (output, err) = process.communicate()\\n exit_code = process.wait()\\n if exit_code == 0:\\n print(\\\"success!\\\")\\n with open(join(module_path, module+\\\".c_info\\\"),\\\"wb\\\") as f: # save python version\\n pickle.dump(python_cmd, f, protocol=4) # protocol 4 is backward compatible with Python 3.4\\n else:\\n print(\\\"Aborting! Building errors:\\\")\\n print(output.decode(), err.decode())\\n exit() \\n\\n if not zero_modules:\\n print(\\\"All modules were built successfully!\\\\n--------------------------\\\")\\n\\n\\n def batch_create(self, agent_cls, args_per_player): \\n ''' Creates batch of agents '''\\n\\n for a in args_per_player:\\n self.players.append( agent_cls(*a) )\\n\\n def batch_execute_agent(self, index : slice = slice(None)): \\n ''' \\n Executes agent normally (including commit & send)\\n\\n Parameters\\n ----------\\n index : slice\\n subset of agents\\n (e.g. index=slice(1,2) will select the second agent)\\n (e.g. index=slice(1,3) will select the second and third agents)\\n by default, all agents are selected\\n ''' \\n for p in self.players[index]:\\n p.think_and_send()\\n\\n def batch_execute_behavior(self, behavior, index : slice = slice(None)):\\n '''\\n Executes behavior\\n\\n Parameters\\n ----------\\n behavior : str\\n name of behavior to execute\\n index : slice\\n subset of agents\\n (e.g. index=slice(1,2) will select the second agent)\\n (e.g. index=slice(1,3) will select the second and third agents)\\n by default, all agents are selected\\n '''\\n for p in self.players[index]:\\n p.behavior.execute(behavior)\\n\\n def batch_commit_and_send(self, index : slice = slice(None)):\\n '''\\n Commits & sends data to server\\n\\n Parameters\\n ----------\\n index : slice\\n subset of agents\\n (e.g. index=slice(1,2) will select the second agent)\\n (e.g. index=slice(1,3) will select the second and third agents)\\n by default, all agents are selected\\n '''\\n for p in self.players[index]:\\n p.scom.commit_and_send( p.world.robot.get_command() ) \\n\\n def batch_receive(self, index : slice = slice(None), update=True):\\n ''' \\n Waits for server messages\\n\\n Parameters\\n ----------\\n index : slice\\n subset of agents\\n (e.g. index=slice(1,2) will select the second agent)\\n (e.g. index=slice(1,3) will select the second and third agents)\\n by default, all agents are selected\\n update : bool\\n update world state based on information received from server\\n if False, the agent becomes unaware of itself and its surroundings\\n which is useful for reducing cpu resources for dummy agents in demonstrations\\n '''\\n for p in self.players[index]:\\n p.scom.receive(update)\\n\\n def batch_commit_beam(self, pos2d_and_rotation, index : slice = slice(None)):\\n '''\\n Beam all player to 2D position with a given rotation\\n\\n Parameters\\n ----------\\n pos2d_and_rotation : `list`\\n iterable of 2D positions and rotations e.g. [(0,0,45),(-5,0,90)]\\n index : slice\\n subset of agents\\n (e.g. index=slice(1,2) will select the second agent)\\n (e.g. index=slice(1,3) will select the second and third agents)\\n by default, all agents are selected\\n ''' \\n for p, pos_rot in zip(self.players[index], pos2d_and_rotation): \\n p.scom.commit_beam(pos_rot[0:2],pos_rot[2])\\n\\n def batch_unofficial_beam(self, pos3d_and_rotation, index : slice = slice(None)):\\n '''\\n Beam all player to 3D position with a given rotation\\n\\n Parameters\\n ----------\\n pos3d_and_rotation : `list`\\n iterable of 3D positions and rotations e.g. [(0,0,0.5,45),(-5,0,0.5,90)]\\n index : slice\\n subset of agents\\n (e.g. index=slice(1,2) will select the second agent)\\n (e.g. index=slice(1,3) will select the second and third agents)\\n by default, all agents are selected\\n ''' \\n for p, pos_rot in zip(self.players[index], pos3d_and_rotation): \\n p.scom.unofficial_beam(pos_rot[0:3],pos_rot[3])\\n\\n def batch_terminate(self, index : slice = slice(None)):\\n '''\\n Close all sockets connected to the agent port\\n For scripts where the agent lives until the application ends, this is not needed\\n\\n Parameters\\n ----------\\n index : slice\\n subset of agents\\n (e.g. index=slice(1,2) will select the second agent)\\n (e.g. index=slice(1,3) will select the second and third agents)\\n by default, all agents are selected\\n '''\\n for p in self.players[index]:\\n p.terminate()\\n del self.players[index] # delete selection\"\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]","isConversational":false},"import_statement":{"kind":"string","value":"from agent.Agent import Agent as Agent\nfrom cpp.localization import localization\nfrom math_ops.Math_Ops import Math_Ops as M\nfrom scripts.commons.Script import Script\nfrom world.commons.Draw import Draw\nfrom world.commons.Other_Robot import Other_Robot"},"token_num":{"kind":"number","value":16305,"string":"16,305"},"cropped_code":{"kind":"string","value":"\n\nclass Localization():\n\n def __init__(self,script:Script) -> None:\n self.script = script\n \n \n def execute(self):\n\n a = self.script.args\n d = self.draw = Draw(True, 0, a.i, 32769) # using independent draw object so that the internal agent drawings can be disabled\n\n # Args: Server IP, Agent Port, Monitor Port, Uniform No., Team name, Enable Log, Enable Draw\n self.script.batch_create(Agent, ((a.i,a.p,a.m,1,a.t,False,False),)) # one teammate (dummy goalkeeper without communication)\n self.script.batch_create(Agent, ((a.i,a.p,a.m,5,\"Opponent\",False,False),)) # one opponent\n self.script.batch_create(Agent, ((a.i,a.p,a.m,9,a.t,False,False),)) # one main agent (the one who draws its world)\n\n # Beam dummy goalkeeper\n self.script.batch_unofficial_beam( ((-14,0,0.5,0),), slice(0,1))\n\n p : Agent = self.script.players[-1] # p identifies the main agent\n p.scom.unofficial_set_play_mode(\"PlayOn\")\n \n # Execute\n while True:\n self.script.batch_commit_and_send(slice(0,1)) # dummy agent does not think\n self.script.batch_execute_agent(slice(1,None)) # execute normal agents\n self.script.batch_receive(slice(0,1), False) # receive & don't update dummy's world state (to save cpu resources)\n self.script.batch_receive(slice(1,None)) # receive & update world state\n \n if p.world.vision_is_up_to_date:\n if p.world.robot.loc_is_up_to_date: # localization will draw the world of the last agent to be executed\n localization.print_python_data() # print data received by the localization module\n localization.draw_visible_elements(not p.world.team_side_is_left) # draw visible elements\n localization.print_report() # print report with stats\n print(\"\\nPress ctrl+c to return.\")\n d.circle( p.world.ball_abs_pos, 0.1,6,Draw.Color.purple_magenta,\"world\", False)\n else:\n d.annotation( p.world.robot.cheat_abs_pos, \"Not enough visual data!\", Draw.Color.red,\"world\", False)\n \n for o in p.world.teammates:\n if o.state_last_update != 0 and not o.is_self: # skip if other robot was not yet seen\n self._draw_other_robot(p, o, Draw.Color.white)\n \n for o in p.world.opponents:\n if o.state_last_update != 0: # skip if other robot was not yet seen\n self._draw_other_robot(p, o, Draw.Color.red)\n\n d.flush(\"world\")\n\n\n\n def _draw_other_robot(self, p:Agent, o:Other_Robot, team_color):\n #p - player that sees\n #o - other robot (player that is seen)\n\n d = self.draw\n white = Draw.Color.white\n green = Draw.Color.green_light\n gray = Draw.Color.gray_20\n\n time_diff = p.world.time_local_ms - o.state_last_update\n if time_diff > 0:\n white = Draw.Color.gray_40\n green = Draw.Color.get(107, 139, 107)\n gray = Draw.Color.gray_50\n\n #orientation\n if len(o.state_abs_pos)==3:\n"},"all_code":{"kind":"string","value":"\n\nclass Localization():\n\n def __init__(self,script:Script) -> None:\n self.script = script\n \n \n def execute(self):\n\n a = self.script.args\n d = self.draw = Draw(True, 0, a.i, 32769) # using independent draw object so that the internal agent drawings can be disabled\n\n # Args: Server IP, Agent Port, Monitor Port, Uniform No., Team name, Enable Log, Enable Draw\n self.script.batch_create(Agent, ((a.i,a.p,a.m,1,a.t,False,False),)) # one teammate (dummy goalkeeper without communication)\n self.script.batch_create(Agent, ((a.i,a.p,a.m,5,\"Opponent\",False,False),)) # one opponent\n self.script.batch_create(Agent, ((a.i,a.p,a.m,9,a.t,False,False),)) # one main agent (the one who draws its world)\n\n # Beam dummy goalkeeper\n self.script.batch_unofficial_beam( ((-14,0,0.5,0),), slice(0,1))\n\n p : Agent = self.script.players[-1] # p identifies the main agent\n p.scom.unofficial_set_play_mode(\"PlayOn\")\n \n # Execute\n while True:\n self.script.batch_commit_and_send(slice(0,1)) # dummy agent does not think\n self.script.batch_execute_agent(slice(1,None)) # execute normal agents\n self.script.batch_receive(slice(0,1), False) # receive & don't update dummy's world state (to save cpu resources)\n self.script.batch_receive(slice(1,None)) # receive & update world state\n \n if p.world.vision_is_up_to_date:\n if p.world.robot.loc_is_up_to_date: # localization will draw the world of the last agent to be executed\n localization.print_python_data() # print data received by the localization module\n localization.draw_visible_elements(not p.world.team_side_is_left) # draw visible elements\n localization.print_report() # print report with stats\n print(\"\\nPress ctrl+c to return.\")\n d.circle( p.world.ball_abs_pos, 0.1,6,Draw.Color.purple_magenta,\"world\", False)\n else:\n d.annotation( p.world.robot.cheat_abs_pos, \"Not enough visual data!\", Draw.Color.red,\"world\", False)\n \n for o in p.world.teammates:\n if o.state_last_update != 0 and not o.is_self: # skip if other robot was not yet seen\n self._draw_other_robot(p, o, Draw.Color.white)\n \n for o in p.world.opponents:\n if o.state_last_update != 0: # skip if other robot was not yet seen\n self._draw_other_robot(p, o, Draw.Color.red)\n\n d.flush(\"world\")\n\n\n\n def _draw_other_robot(self, p:Agent, o:Other_Robot, team_color):\n #p - player that sees\n #o - other robot (player that is seen)\n\n d = self.draw\n white = Draw.Color.white\n green = Draw.Color.green_light\n gray = Draw.Color.gray_20\n\n time_diff = p.world.time_local_ms - o.state_last_update\n if time_diff > 0:\n white = Draw.Color.gray_40\n green = Draw.Color.get(107, 139, 107)\n gray = Draw.Color.gray_50\n\n #orientation\n if len(o.state_abs_pos)==3:"},"next_line":{"kind":"string","value":" line_tip = o.state_abs_pos + (0.5*M.deg_cos(o.state_orientation),0.5*M.deg_sin(o.state_orientation),0)"},"gold_snippet_index":{"kind":"number","value":0,"string":"0"},"created_at":{"kind":"string","value":"2023-12-16 23:40:23+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5991,"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":19440,"string":"19,440"},"cropped_code":{"kind":"string","value":" indices = (im * (self.lattice.size(0) - 1)).clamp(0, self.lattice.size(0) - 1)\n\n im_out = trilinear_interpolation(self.lattice, indices)\n return im_out\n\n @classmethod\n def get_linear(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:\n \"\"\"\n Returns linear LUT. Has no effect: when applied, output matches input ([0, 1] range).\n\n :param size: Size of the LUT.\n :param lut_format: Format of the LUT.\n \"\"\"\n if lut_format == LUTFormat.CUBE_3D:\n assert cls.__min_size <= size <= cls.__max_size, f\"LUT size must be between {cls.__min_size} and {cls.__max_size}\"\n variant = LUTFormat.CUBE_3D\n lattice = _generate_linear_cube_lut(size)\n else:\n raise Exception(f\"Backpropagation not implemented for: {lut_format.name}\")\n\n return cls(size, lattice, variant)\n\n @classmethod\n def get_negative(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:\n \"\"\"\n Returns negative LUT. Output is inverted ([0, 1] range).\n\n :param size: Size of the LUT.\n :param lut_format: Format of the LUT.\n \"\"\"\n lut = cls.get_linear(size, lut_format)\n lut.lattice = 1. - lut.lattice\n return lut\n\n @classmethod\n def get_random(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:\n \"\"\"\n Returns random LUT. Everything mapped to random values ([0, 1] range).\n\n :param size: Size of the LUT.\n :param lut_format: Format of the LUT.\n \"\"\"\n lut = cls.get_linear(size, lut_format)\n lut.lattice = torch.randn_like(lut.lattice)\n return lut\n\n @classmethod\n def get_empty(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:\n \"\"\"\n Returns empty LUT. All values mapped to 0.\n\n :param size: Size of the LUT.\n :param lut_format: Format of the LUT.\n \"\"\"\n lut = cls.get_linear(size, lut_format)\n lut.lattice = lut.lattice * 0.\n return lut\n\n def fit_to_image(self, \n im_source:Union[torch.Tensor, ColorImage], \n im_target:Union[torch.Tensor, ColorImage], \n steps:int=500, \n learning_rate:float=0.003,\n strength:float=1.,\n fit_height:int=512,\n fit_width:int=512,\n device:str='cuda',\n context:callable=None\n ) -> bool:\n \"\"\"\n Perform gradient descent on the lattice, so that the appearance of the source image matches the target.\n\n :param im_source: Source image tensor. Values must be in range [0, 1].\n :type im_source: torch.Tensor | ColorImage\n :param im_target: Target image tensor.\n :type im_target: torch.Tensor | ColorImage\n :param steps: Number of optimization steps.\n :param learning_rate: Learning rate for gradient descent.\n :param strength: Strength of the effect in range [0, 1].\n :param fit_height: Image tensors will be interpolated to this height for evaluation.\n :param fit_width: Image tensors will be interpolated to this width for evaluation.\n :param device: Device for gradient descent (if None will use input tensor device).\n :return: True when completed\n \"\"\"\n assert 0. <= strength <= 1., \"strength must be in range [0, 1]\"\n im_source = im_source.clone()\n device = torch.device(device.strip().lower()) if device is not None else im_source.device\n im_source = F.interpolate(\n im_source.unsqueeze(0), \n size=[fit_height, fit_width], \n mode='bicubic', \n align_corners=False).squeeze(0).clamp(0.,1.).to(device)\n \n im_target = F.interpolate(\n im_target.unsqueeze(0), \n size=[fit_height, fit_width], \n mode='bicubic', \n align_corners=False).squeeze(0).clamp(0.,1.).to(device)\n\n __ctx = context if context is not None and callable(context) else nullcontext\n with __ctx() as ctx:\n cb_callable = hasattr(ctx, 'update_fit_status') and callable(ctx.update_fit_status)\n cb = ctx.update_fit_status if cb_callable else lambda a, b, c, d: None\n if self.lut_format == LUTFormat.CUBE_3D:\n lut = torch.nn.Parameter(self.lattice)\n lut.requires_grad_()\n optimizer = optim.Adam([lut], lr=learning_rate)\n indices = (im_source * (lut.size(0) - 1)).clamp(0, lut.size(0) - 1).to(device)\n\n area = fit_height * fit_height\n fm_mean_scale = area\n fm_p2_scale = area / 32.\n fm_p3_scale = area / 64.\n selfsim_scale = area \n sat_scale = area # lut optimization goes a bit wild with this\n for step in range(steps):\n t_source = trilinear_interpolation(lut.to(device), indices).to(device)\n loss = 0.\n\n # Main feature loss\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\n lut_format= LUTFormat.UNKNOWN\n\n __min_size, __max_size = 4, 512\n\n def __init__(self, size:int, lattice:torch.Tensor=None, lut_format:LUTFormat=LUTFormat.CUBE_3D):\n assert self.__min_size <= size <= self.__max_size, f\"LUT size must be between {self.__min_size} and {self.__max_size}\"\n self.size == size\n self.lattice = lattice if lattice is not None else _generate_linear_cube_lut(size)\n self.lut_format = lut_format\n\n @classmethod\n def load(cls, fp:str, lut_format:LUTFormat=LUTFormat.UNKNOWN) -> LookupTable:\n \"\"\"\n Load LUT from file.\n\n :param fp: File path.\n :param lut_format: Format of the LUT.\n \"\"\"\n fp = os.path.realpath(fp)\n fn, fnext = os.path.splitext(fp)\n\n variant = lut_format if lut_format > LUTFormat.UNKNOWN else _infer_lut_file_format(fnext)\n\n assert variant > LUTFormat.UNKNOWN, \"Unrecognized LUT format\"\n\n lattice = load_lut(fp, variant)\n\n return cls(lattice.size(0), lattice, variant)\n\n def save(self, fp:str, lut_format:LUTFormat=LUTFormat.UNKNOWN):\n \"\"\"\n Save LUT to file.\n\n .. warning:: \n \n This will overwrite existing files.\n\n :param fp: File path.\n :param lut_format: Format of the LUT.\n \"\"\"\n fp = os.path.realpath(fp)\n fn, fnext = os.path.splitext(fp)\n\n variant = lut_format if lut_format > LUTFormat.UNKNOWN else _infer_lut_file_format(fnext) or self.variant\n\n assert variant > LUTFormat.UNKNOWN, \"Unrecognized LUT format\"\n\n lattice = save_lut(self.lattice, fp, variant)\n\n return True\n\n def apply(self, im:Union[torch.Tensor, ColorImage]) -> torch.Tensor:\n \"\"\"\n Apply LUT to image tensor.\n\n :param im: Input image tensor\n :type im: torch.Tensor | ColorImage\n :return: Image tensor with LUT applied\n \"\"\"\n assert self.lut_format > LUTFormat.UNKNOWN and self.lattice != None, \"No LUT has been loaded\"\n assert im.size(0) == 3, \"Image should have three color channels (RGB)\"\n assert self.lattice.size(-1) == 3, \"Cube LUT should have three color channels\"\n\n indices = (im * (self.lattice.size(0) - 1)).clamp(0, self.lattice.size(0) - 1)\n\n im_out = trilinear_interpolation(self.lattice, indices)\n return im_out\n\n @classmethod\n def get_linear(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:\n \"\"\"\n Returns linear LUT. Has no effect: when applied, output matches input ([0, 1] range).\n\n :param size: Size of the LUT.\n :param lut_format: Format of the LUT.\n \"\"\"\n if lut_format == LUTFormat.CUBE_3D:\n assert cls.__min_size <= size <= cls.__max_size, f\"LUT size must be between {cls.__min_size} and {cls.__max_size}\"\n variant = LUTFormat.CUBE_3D\n lattice = _generate_linear_cube_lut(size)\n else:\n raise Exception(f\"Backpropagation not implemented for: {lut_format.name}\")\n\n return cls(size, lattice, variant)\n\n @classmethod\n def get_negative(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:\n \"\"\"\n Returns negative LUT. Output is inverted ([0, 1] range).\n\n :param size: Size of the LUT.\n :param lut_format: Format of the LUT.\n \"\"\"\n lut = cls.get_linear(size, lut_format)\n lut.lattice = 1. - lut.lattice\n return lut\n\n @classmethod\n def get_random(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:\n \"\"\"\n Returns random LUT. Everything mapped to random values ([0, 1] range).\n\n :param size: Size of the LUT.\n :param lut_format: Format of the LUT.\n \"\"\"\n lut = cls.get_linear(size, lut_format)\n lut.lattice = torch.randn_like(lut.lattice)\n return lut\n\n @classmethod\n def get_empty(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:\n \"\"\"\n Returns empty LUT. All values mapped to 0.\n\n :param size: Size of the LUT.\n :param lut_format: Format of the LUT.\n \"\"\"\n lut = cls.get_linear(size, lut_format)\n lut.lattice = lut.lattice * 0.\n return lut\n\n def fit_to_image(self, \n im_source:Union[torch.Tensor, ColorImage], \n im_target:Union[torch.Tensor, ColorImage], \n steps:int=500, \n learning_rate:float=0.003,\n strength:float=1.,\n fit_height:int=512,\n fit_width:int=512,\n device:str='cuda',\n context:callable=None\n ) -> bool:\n \"\"\"\n Perform gradient descent on the lattice, so that the appearance of the source image matches the target.\n\n :param im_source: Source image tensor. Values must be in range [0, 1].\n :type im_source: torch.Tensor | ColorImage\n :param im_target: Target image tensor.\n :type im_target: torch.Tensor | ColorImage\n :param steps: Number of optimization steps.\n :param learning_rate: Learning rate for gradient descent.\n :param strength: Strength of the effect in range [0, 1].\n :param fit_height: Image tensors will be interpolated to this height for evaluation.\n :param fit_width: Image tensors will be interpolated to this width for evaluation.\n :param device: Device for gradient descent (if None will use input tensor device).\n :return: True when completed\n \"\"\"\n assert 0. <= strength <= 1., \"strength must be in range [0, 1]\"\n im_source = im_source.clone()\n device = torch.device(device.strip().lower()) if device is not None else im_source.device\n im_source = F.interpolate(\n im_source.unsqueeze(0), \n size=[fit_height, fit_width], \n mode='bicubic', \n align_corners=False).squeeze(0).clamp(0.,1.).to(device)\n \n im_target = F.interpolate(\n im_target.unsqueeze(0), \n size=[fit_height, fit_width], \n mode='bicubic', \n align_corners=False).squeeze(0).clamp(0.,1.).to(device)\n\n __ctx = context if context is not None and callable(context) else nullcontext\n with __ctx() as ctx:\n cb_callable = hasattr(ctx, 'update_fit_status') and callable(ctx.update_fit_status)\n cb = ctx.update_fit_status if cb_callable else lambda a, b, c, d: None\n if self.lut_format == LUTFormat.CUBE_3D:\n lut = torch.nn.Parameter(self.lattice)\n lut.requires_grad_()\n optimizer = optim.Adam([lut], lr=learning_rate)\n indices = (im_source * (lut.size(0) - 1)).clamp(0, lut.size(0) - 1).to(device)\n\n area = fit_height * fit_height\n fm_mean_scale = area\n fm_p2_scale = area / 32.\n fm_p3_scale = area / 64.\n selfsim_scale = area \n sat_scale = area # lut optimization goes a bit wild with this\n for step in range(steps):\n t_source = trilinear_interpolation(lut.to(device), indices).to(device)\n loss = 0.\n\n # Main feature loss"},"next_line":{"kind":"string","value":" feat_source_mean, feat_source_p2, feat_source_p3 = feature_moments_calculation(t_source.view(1,3,-1))"},"gold_snippet_index":{"kind":"number","value":8,"string":"8"},"created_at":{"kind":"string","value":"2023-12-15 15:39:08+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5992,"cells":{"repo_name":{"kind":"string","value":"Azure-Samples/functions-python-web-crawler"},"file_path":{"kind":"string","value":".venv/Lib/site-packages/urllib3/connectionpool.py"},"context":{"kind":"list like","value":[{"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":"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":"RequestMethods","path":".venv/Lib/site-packages/urllib3/_request_methods.py","snippet":"class RequestMethods:\n \"\"\"\n Convenience mixin for classes who implement a :meth:`urlopen` method, such\n as :class:`urllib3.HTTPConnectionPool` and\n :class:`urllib3.PoolManager`.\n\n Provides behavior for making common types of HTTP request methods and\n decides which type of request field encoding to use.\n\n Specifically,\n\n :meth:`.request_encode_url` is for sending requests whose fields are\n encoded in the URL (such as GET, HEAD, DELETE).\n\n :meth:`.request_encode_body` is for sending requests whose fields are\n encoded in the *body* of the request using multipart or www-form-urlencoded\n (such as for POST, PUT, PATCH).\n\n :meth:`.request` is for making any kind of request, it will look up the\n appropriate encoding format and use one of the above two methods to make\n the request.\n\n Initializer parameters:\n\n :param headers:\n Headers to include with all requests, unless other headers are given\n explicitly.\n \"\"\"\n\n _encode_url_methods = {\"DELETE\", \"GET\", \"HEAD\", \"OPTIONS\"}\n\n def __init__(self, headers: typing.Mapping[str, str] | None = None) -> None:\n self.headers = headers or {}\n\n def urlopen(\n self,\n method: str,\n url: str,\n body: _TYPE_BODY | None = None,\n headers: typing.Mapping[str, str] | None = None,\n encode_multipart: bool = True,\n multipart_boundary: str | None = None,\n **kw: typing.Any,\n ) -> BaseHTTPResponse: # Abstract\n raise NotImplementedError(\n \"Classes extending RequestMethods must implement \"\n \"their own ``urlopen`` method.\"\n )\n\n def request(\n self,\n method: str,\n url: str,\n body: _TYPE_BODY | None = None,\n fields: _TYPE_FIELDS | None = None,\n headers: typing.Mapping[str, str] | None = None,\n json: typing.Any | None = None,\n **urlopen_kw: typing.Any,\n ) -> BaseHTTPResponse:\n \"\"\"\n Make a request using :meth:`urlopen` with the appropriate encoding of\n ``fields`` based on the ``method`` used.\n\n This is a convenience method that requires the least amount of manual\n effort. It can be used in most situations, while still having the\n option to drop down to more specific methods when necessary, such as\n :meth:`request_encode_url`, :meth:`request_encode_body`,\n or even the lowest level :meth:`urlopen`.\n \"\"\"\n method = method.upper()\n\n if json is not None and body is not None:\n raise TypeError(\n \"request got values for both 'body' and 'json' parameters which are mutually exclusive\"\n )\n\n if json is not None:\n if headers is None:\n headers = self.headers.copy() # type: ignore\n if not (\"content-type\" in map(str.lower, headers.keys())):\n headers[\"Content-Type\"] = \"application/json\" # type: ignore\n\n body = _json.dumps(json, separators=(\",\", \":\"), ensure_ascii=False).encode(\n \"utf-8\"\n )\n\n if body is not None:\n urlopen_kw[\"body\"] = body\n\n if method in self._encode_url_methods:\n return self.request_encode_url(\n method,\n url,\n fields=fields, # type: ignore[arg-type]\n headers=headers,\n **urlopen_kw,\n )\n else:\n return self.request_encode_body(\n method, url, fields=fields, headers=headers, **urlopen_kw\n )\n\n def request_encode_url(\n self,\n method: str,\n url: str,\n fields: _TYPE_ENCODE_URL_FIELDS | None = None,\n headers: typing.Mapping[str, str] | None = None,\n **urlopen_kw: str,\n ) -> BaseHTTPResponse:\n \"\"\"\n Make a request using :meth:`urlopen` with the ``fields`` encoded in\n the url. This is useful for request methods like GET, HEAD, DELETE, etc.\n \"\"\"\n if headers is None:\n headers = self.headers\n\n extra_kw: dict[str, typing.Any] = {\"headers\": headers}\n extra_kw.update(urlopen_kw)\n\n if fields:\n url += \"?\" + urlencode(fields)\n\n return self.urlopen(method, url, **extra_kw)\n\n def request_encode_body(\n self,\n method: str,\n url: str,\n fields: _TYPE_FIELDS | None = None,\n headers: typing.Mapping[str, str] | None = None,\n encode_multipart: bool = True,\n multipart_boundary: str | None = None,\n **urlopen_kw: str,\n ) -> BaseHTTPResponse:\n \"\"\"\n Make a request using :meth:`urlopen` with the ``fields`` encoded in\n the body. This is useful for request methods like POST, PUT, PATCH, etc.\n\n When ``encode_multipart=True`` (default), then\n :func:`urllib3.encode_multipart_formdata` is used to encode\n the payload with the appropriate content type. Otherwise\n :func:`urllib.parse.urlencode` is used with the\n 'application/x-www-form-urlencoded' content type.\n\n Multipart encoding must be used when posting files, and it's reasonably\n safe to use it in other times too. However, it may break request\n signing, such as with OAuth.\n\n Supports an optional ``fields`` parameter of key/value strings AND\n key/filetuple. A filetuple is a (filename, data, MIME type) tuple where\n the MIME type is optional. For example::\n\n fields = {\n 'foo': 'bar',\n 'fakefile': ('foofile.txt', 'contents of foofile'),\n 'realfile': ('barfile.txt', open('realfile').read()),\n 'typedfile': ('bazfile.bin', open('bazfile').read(),\n 'image/jpeg'),\n 'nonamefile': 'contents of nonamefile field',\n }\n\n When uploading a file, providing a filename (the first parameter of the\n tuple) is optional but recommended to best mimic behavior of browsers.\n\n Note that if ``headers`` are supplied, the 'Content-Type' header will\n be overwritten because it depends on the dynamic random boundary string\n which is used to compose the body of the request. The random boundary\n string can be explicitly set with the ``multipart_boundary`` parameter.\n \"\"\"\n if headers is None:\n headers = self.headers\n\n extra_kw: dict[str, typing.Any] = {\"headers\": HTTPHeaderDict(headers)}\n body: bytes | str\n\n if fields:\n if \"body\" in urlopen_kw:\n raise TypeError(\n \"request got values for both 'fields' and 'body', can only specify one.\"\n )\n\n if encode_multipart:\n body, content_type = encode_multipart_formdata(\n fields, boundary=multipart_boundary\n )\n else:\n body, content_type = (\n urlencode(fields), # type: ignore[arg-type]\n \"application/x-www-form-urlencoded\",\n )\n\n extra_kw[\"body\"] = body\n extra_kw[\"headers\"].setdefault(\"Content-Type\", content_type)\n\n extra_kw.update(urlopen_kw)\n\n return self.urlopen(method, url, **extra_kw)"},{"identifier":"BaseSSLError","path":".venv/Lib/site-packages/urllib3/connection.py","snippet":" class BaseSSLError(BaseException): # type: ignore[no-redef]\nclass HTTPConnection(_HTTPConnection):\nclass HTTPSConnection(HTTPConnection):\nclass _WrappedAndVerifiedSocket(typing.NamedTuple):\nclass DummyConnection:\nRECENT_DATE = datetime.date(2022, 1, 1)\n_CONTAINS_CONTROL_CHAR_RE = re.compile(r\"[^-!#$%&'*+.^_`|~0-9a-zA-Z]\")\n_HAS_SYS_AUDIT = hasattr(sys, \"audit\")\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 def host(self) -> str:\n def host(self, value: str) -> None:\n def _new_conn(self) -> socket.socket:\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 def connect(self) -> None:\n def is_closed(self) -> bool:\n def is_connected(self) -> bool:\n def has_connected_to_proxy(self) -> bool:\n def close(self) -> None:\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 def putheader(self, header: str, *values: str) -> None:\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 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 def getresponse( # type: ignore[override]\n self,\n ) -> HTTPResponse:\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 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 def connect(self) -> None:\n def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket:\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:\ndef _match_hostname(\n cert: _TYPE_PEER_CERT_RET_DICT | None,\n asserted_hostname: str,\n hostname_checks_common_name: bool = False,\n) -> None:\ndef _wrap_proxy_error(err: Exception, proxy_scheme: str | None) -> ProxyError:\ndef _get_default_user_agent() -> str:\ndef _url_from_connection(\n conn: HTTPConnection | HTTPSConnection, path: str | None = None\n) -> str:"},{"identifier":"port_by_scheme","path":".venv/Lib/site-packages/urllib3/connection.py","snippet":" class BaseSSLError(BaseException): # type: ignore[no-redef]\nclass HTTPConnection(_HTTPConnection):\nclass HTTPSConnection(HTTPConnection):\nclass _WrappedAndVerifiedSocket(typing.NamedTuple):\nclass DummyConnection:\nRECENT_DATE = datetime.date(2022, 1, 1)\n_CONTAINS_CONTROL_CHAR_RE = re.compile(r\"[^-!#$%&'*+.^_`|~0-9a-zA-Z]\")\n_HAS_SYS_AUDIT = hasattr(sys, \"audit\")\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 def host(self) -> str:\n def host(self, value: str) -> None:\n def _new_conn(self) -> socket.socket:\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 def connect(self) -> None:\n def is_closed(self) -> bool:\n def is_connected(self) -> bool:\n def has_connected_to_proxy(self) -> bool:\n def close(self) -> None:\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 def putheader(self, header: str, *values: str) -> None:\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 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 def getresponse( # type: ignore[override]\n self,\n ) -> HTTPResponse:\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 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 def connect(self) -> None:\n def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket:\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:\ndef _match_hostname(\n cert: _TYPE_PEER_CERT_RET_DICT | None,\n asserted_hostname: str,\n hostname_checks_common_name: bool = False,\n) -> None:\ndef _wrap_proxy_error(err: Exception, proxy_scheme: str | None) -> ProxyError:\ndef _get_default_user_agent() -> str:\ndef _url_from_connection(\n conn: HTTPConnection | HTTPSConnection, path: str | None = None\n) -> str:"},{"identifier":"ClosedPoolError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class ClosedPoolError(PoolError):\n \"\"\"Raised when a request enters a pool after the pool has been closed.\"\"\""},{"identifier":"EmptyPoolError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class EmptyPoolError(PoolError):\n \"\"\"Raised when a pool runs out of connections and no more are allowed.\"\"\""},{"identifier":"FullPoolError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class FullPoolError(PoolError):\n \"\"\"Raised when we try to add a connection to a full pool in blocking mode.\"\"\""},{"identifier":"HostChangedError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class HostChangedError(RequestError):\n \"\"\"Raised when an existing pool gets a request for a foreign host.\"\"\"\n\n def __init__(\n self, pool: ConnectionPool, url: str, retries: Retry | int = 3\n ) -> None:\n message = f\"Tried to open a foreign host with url: {url}\"\n super().__init__(pool, url, message)\n self.retries = retries"},{"identifier":"InsecureRequestWarning","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class InsecureRequestWarning(SecurityWarning):\n \"\"\"Warned when making an unverified HTTPS request.\"\"\""},{"identifier":"LocationValueError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class LocationValueError(ValueError, HTTPError):\n \"\"\"Raised when there is something wrong with a given URL input.\"\"\""},{"identifier":"MaxRetryError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class MaxRetryError(RequestError):\n \"\"\"Raised when the maximum number of retries is exceeded.\n\n :param pool: The connection pool\n :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool`\n :param str url: The requested Url\n :param reason: The underlying error\n :type reason: :class:`Exception`\n\n \"\"\"\n\n def __init__(\n self, pool: ConnectionPool, url: str, reason: Exception | None = None\n ) -> None:\n self.reason = reason\n\n message = f\"Max retries exceeded with url: {url} (Caused by {reason!r})\"\n\n super().__init__(pool, url, 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":"ProtocolError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class ProtocolError(HTTPError):\n \"\"\"Raised when something unexpected happens mid-request/response.\"\"\""},{"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":"ReadTimeoutError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class ReadTimeoutError(TimeoutError, RequestError):\n \"\"\"Raised when a socket timeout occurs while receiving data from a server\"\"\""},{"identifier":"SSLError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class SSLError(HTTPError):\n \"\"\"Raised when SSL certificate fails in an HTTPS connection.\"\"\""},{"identifier":"TimeoutError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class TimeoutError(HTTPError):\n \"\"\"Raised when a socket timeout error occurs.\n\n Catching this error will catch both :exc:`ReadTimeoutErrors\n <ReadTimeoutError>` and :exc:`ConnectTimeoutErrors <ConnectTimeoutError>`.\n \"\"\""},{"identifier":"BaseHTTPResponse","path":".venv/Lib/site-packages/urllib3/response.py","snippet":"class BaseHTTPResponse(io.IOBase):\n CONTENT_DECODERS = [\"gzip\", \"x-gzip\", \"deflate\"]\n if brotli is not None:\n CONTENT_DECODERS += [\"br\"]\n if zstd is not None:\n CONTENT_DECODERS += [\"zstd\"]\n REDIRECT_STATUSES = [301, 302, 303, 307, 308]\n\n DECODER_ERROR_CLASSES: tuple[type[Exception], ...] = (IOError, zlib.error)\n if brotli is not None:\n DECODER_ERROR_CLASSES += (brotli.error,)\n\n if zstd is not None:\n DECODER_ERROR_CLASSES += (zstd.ZstdError,)\n\n def __init__(\n self,\n *,\n headers: typing.Mapping[str, str] | typing.Mapping[bytes, bytes] | None = None,\n status: int,\n version: int,\n reason: str | None,\n decode_content: bool,\n request_url: str | None,\n retries: Retry | None = None,\n ) -> None:\n if isinstance(headers, HTTPHeaderDict):\n self.headers = headers\n else:\n self.headers = HTTPHeaderDict(headers) # type: ignore[arg-type]\n self.status = status\n self.version = version\n self.reason = reason\n self.decode_content = decode_content\n self._has_decoded_content = False\n self._request_url: str | None = request_url\n self.retries = retries\n\n self.chunked = False\n tr_enc = self.headers.get(\"transfer-encoding\", \"\").lower()\n # Don't incur the penalty of creating a list and then discarding it\n encodings = (enc.strip() for enc in tr_enc.split(\",\"))\n if \"chunked\" in encodings:\n self.chunked = True\n\n self._decoder: ContentDecoder | None = None\n\n def get_redirect_location(self) -> str | None | Literal[False]:\n \"\"\"\n Should we redirect and where to?\n\n :returns: Truthy redirect location string if we got a redirect status\n code and valid location. ``None`` if redirect status and no\n location. ``False`` if not a redirect status code.\n \"\"\"\n if self.status in self.REDIRECT_STATUSES:\n return self.headers.get(\"location\")\n return False\n\n @property\n def data(self) -> bytes:\n raise NotImplementedError()\n\n def json(self) -> typing.Any:\n \"\"\"\n Parses the body of the HTTP response as JSON.\n\n To use a custom JSON decoder pass the result of :attr:`HTTPResponse.data` to the decoder.\n\n This method can raise either `UnicodeDecodeError` or `json.JSONDecodeError`.\n\n Read more :ref:`here <json>`.\n \"\"\"\n data = self.data.decode(\"utf-8\")\n return _json.loads(data)\n\n @property\n def url(self) -> str | None:\n raise NotImplementedError()\n\n @url.setter\n def url(self, url: str | None) -> None:\n raise NotImplementedError()\n\n @property\n def connection(self) -> HTTPConnection | None:\n raise NotImplementedError()\n\n @property\n def retries(self) -> Retry | None:\n return self._retries\n\n @retries.setter\n def retries(self, retries: Retry | None) -> None:\n # Override the request_url if retries has a redirect location.\n if retries is not None and retries.history:\n self.url = retries.history[-1].redirect_location\n self._retries = retries\n\n def stream(\n self, amt: int | None = 2**16, decode_content: bool | None = None\n ) -> typing.Iterator[bytes]:\n raise NotImplementedError()\n\n def read(\n self,\n amt: int | None = None,\n decode_content: bool | None = None,\n cache_content: bool = False,\n ) -> bytes:\n raise NotImplementedError()\n\n def read_chunked(\n self,\n amt: int | None = None,\n decode_content: bool | None = None,\n ) -> typing.Iterator[bytes]:\n raise NotImplementedError()\n\n def release_conn(self) -> None:\n raise NotImplementedError()\n\n def drain_conn(self) -> None:\n raise NotImplementedError()\n\n def close(self) -> None:\n raise NotImplementedError()\n\n def _init_decoder(self) -> None:\n \"\"\"\n Set-up the _decoder attribute if necessary.\n \"\"\"\n # Note: content-encoding value should be case-insensitive, per RFC 7230\n # Section 3.2\n content_encoding = self.headers.get(\"content-encoding\", \"\").lower()\n if self._decoder is None:\n if content_encoding in self.CONTENT_DECODERS:\n self._decoder = _get_decoder(content_encoding)\n elif \",\" in content_encoding:\n encodings = [\n e.strip()\n for e in content_encoding.split(\",\")\n if e.strip() in self.CONTENT_DECODERS\n ]\n if encodings:\n self._decoder = _get_decoder(content_encoding)\n\n def _decode(\n self, data: bytes, decode_content: bool | None, flush_decoder: bool\n ) -> bytes:\n \"\"\"\n Decode the data passed in and potentially flush the decoder.\n \"\"\"\n if not decode_content:\n if self._has_decoded_content:\n raise RuntimeError(\n \"Calling read(decode_content=False) is not supported after \"\n \"read(decode_content=True) was called.\"\n )\n return data\n\n try:\n if self._decoder:\n data = self._decoder.decompress(data)\n self._has_decoded_content = True\n except self.DECODER_ERROR_CLASSES as e:\n content_encoding = self.headers.get(\"content-encoding\", \"\").lower()\n raise DecodeError(\n \"Received response with content-encoding: %s, but \"\n \"failed to decode it.\" % content_encoding,\n e,\n ) from e\n if flush_decoder:\n data += self._flush_decoder()\n\n return data\n\n def _flush_decoder(self) -> bytes:\n \"\"\"\n Flushes the decoder. Should only be called if the decoder is actually\n being used.\n \"\"\"\n if self._decoder:\n return self._decoder.decompress(b\"\") + self._decoder.flush()\n return b\"\"\n\n # Compatibility methods for `io` module\n def readinto(self, b: bytearray) -> int:\n temp = self.read(len(b))\n if len(temp) == 0:\n return 0\n else:\n b[: len(temp)] = temp\n return len(temp)\n\n # Compatibility methods for http.client.HTTPResponse\n def getheaders(self) -> HTTPHeaderDict:\n warnings.warn(\n \"HTTPResponse.getheaders() is deprecated and will be removed \"\n \"in urllib3 v2.1.0. Instead access HTTPResponse.headers directly.\",\n category=DeprecationWarning,\n stacklevel=2,\n )\n return self.headers\n\n def getheader(self, name: str, default: str | None = None) -> str | None:\n warnings.warn(\n \"HTTPResponse.getheader() is deprecated and will be removed \"\n \"in urllib3 v2.1.0. Instead use HTTPResponse.headers.get(name, default).\",\n category=DeprecationWarning,\n stacklevel=2,\n )\n return self.headers.get(name, default)\n\n # Compatibility method for http.cookiejar\n def info(self) -> HTTPHeaderDict:\n return self.headers\n\n def geturl(self) -> str | None:\n return self.url"},{"identifier":"is_connection_dropped","path":".venv/Lib/site-packages/urllib3/util/connection.py","snippet":"def is_connection_dropped(conn: BaseHTTPConnection) -> bool: # Platform-specific\n \"\"\"\n Returns True if the connection is dropped and should be closed.\n :param conn: :class:`urllib3.connection.HTTPConnection` object.\n \"\"\"\n return not conn.is_connected"},{"identifier":"connection_requires_http_tunnel","path":".venv/Lib/site-packages/urllib3/util/proxy.py","snippet":"def connection_requires_http_tunnel(\n proxy_url: Url | None = None,\n proxy_config: ProxyConfig | None = None,\n destination_scheme: str | None = None,\n) -> bool:\n \"\"\"\n Returns True if the connection requires an HTTP CONNECT through the proxy.\n\n :param URL proxy_url:\n URL of the proxy.\n :param ProxyConfig proxy_config:\n Proxy configuration from poolmanager.py\n :param str destination_scheme:\n The scheme of the destination. (i.e https, http, etc)\n \"\"\"\n # If we're not using a proxy, no way to use a tunnel.\n if proxy_url is None:\n return False\n\n # HTTP destinations never require tunneling, we always forward.\n if destination_scheme == \"http\":\n return False\n\n # Support for forwarding with HTTPS proxies and HTTPS destinations.\n if (\n proxy_url.scheme == \"https\"\n and proxy_config\n and proxy_config.use_forwarding_for_https\n ):\n return False\n\n # Otherwise always use a tunnel.\n return True"},{"identifier":"_TYPE_BODY_POSITION","path":".venv/Lib/site-packages/urllib3/util/request.py","snippet":"_TYPE_BODY_POSITION = typing.Union[int, _TYPE_FAILEDTELL]"},{"identifier":"set_file_position","path":".venv/Lib/site-packages/urllib3/util/request.py","snippet":"def set_file_position(\n body: typing.Any, pos: _TYPE_BODY_POSITION | None\n) -> _TYPE_BODY_POSITION | None:\n \"\"\"\n If a position is provided, move file to that point.\n Otherwise, we'll attempt to record a position for future use.\n \"\"\"\n if pos is not None:\n rewind_body(body, pos)\n elif getattr(body, \"tell\", None) is not None:\n try:\n pos = body.tell()\n except OSError:\n # This differentiates from None, allowing us to catch\n # a failed `tell()` later when trying to rewind the body.\n pos = _FAILEDTELL\n\n return pos"},{"identifier":"Retry","path":".venv/Lib/site-packages/urllib3/util/retry.py","snippet":"class Retry:\n \"\"\"Retry configuration.\n\n Each retry attempt will create a new Retry object with updated values, so\n they can be safely reused.\n\n Retries can be defined as a default for a pool:\n\n .. code-block:: python\n\n retries = Retry(connect=5, read=2, redirect=5)\n http = PoolManager(retries=retries)\n response = http.request(\"GET\", \"https://example.com/\")\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/\", retries=Retry(10))\n\n Retries can be disabled by passing ``False``:\n\n .. code-block:: python\n\n response = http.request(\"GET\", \"https://example.com/\", retries=False)\n\n Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless\n retries are disabled, in which case the causing exception will be raised.\n\n :param int total:\n Total number of retries to allow. Takes precedence over other counts.\n\n Set to ``None`` to remove this constraint and fall back on other\n counts.\n\n Set to ``0`` to fail on the first retry.\n\n Set to ``False`` to disable and imply ``raise_on_redirect=False``.\n\n :param int connect:\n How many connection-related errors to retry on.\n\n These are errors raised before the request is sent to the remote server,\n which we assume has not triggered the server to process the request.\n\n Set to ``0`` to fail on the first retry of this type.\n\n :param int read:\n How many times to retry on read errors.\n\n These errors are raised after the request was sent to the server, so the\n request may have side-effects.\n\n Set to ``0`` to fail on the first retry of this type.\n\n :param int redirect:\n How many redirects to perform. Limit this to avoid infinite redirect\n loops.\n\n A redirect is a HTTP response with a status code 301, 302, 303, 307 or\n 308.\n\n Set to ``0`` to fail on the first retry of this type.\n\n Set to ``False`` to disable and imply ``raise_on_redirect=False``.\n\n :param int status:\n How many times to retry on bad status codes.\n\n These are retries made on responses, where status code matches\n ``status_forcelist``.\n\n Set to ``0`` to fail on the first retry of this type.\n\n :param int other:\n How many times to retry on other errors.\n\n Other errors are errors that are not connect, read, redirect or status errors.\n These errors might be raised after the request was sent to the server, so the\n request might have side-effects.\n\n Set to ``0`` to fail on the first retry of this type.\n\n If ``total`` is not set, it's a good idea to set this to 0 to account\n for unexpected edge cases and avoid infinite retry loops.\n\n :param Collection allowed_methods:\n Set of uppercased HTTP method verbs that we should retry on.\n\n By default, we only retry on methods which are considered to be\n idempotent (multiple requests with the same parameters end with the\n same state). See :attr:`Retry.DEFAULT_ALLOWED_METHODS`.\n\n Set to a ``None`` value to retry on any verb.\n\n :param Collection status_forcelist:\n A set of integer HTTP status codes that we should force a retry on.\n A retry is initiated if the request method is in ``allowed_methods``\n and the response status code is in ``status_forcelist``.\n\n By default, this is disabled with ``None``.\n\n :param float backoff_factor:\n A backoff factor to apply between attempts after the second try\n (most errors are resolved immediately by a second try without a\n delay). urllib3 will sleep for::\n\n {backoff factor} * (2 ** ({number of previous retries}))\n\n seconds. If `backoff_jitter` is non-zero, this sleep is extended by::\n\n random.uniform(0, {backoff jitter})\n\n seconds. For example, if the backoff_factor is 0.1, then :func:`Retry.sleep` will\n sleep for [0.0s, 0.2s, 0.4s, 0.8s, ...] between retries. No backoff will ever\n be longer than `backoff_max`.\n\n By default, backoff is disabled (factor set to 0).\n\n :param bool raise_on_redirect: Whether, if the number of redirects is\n exhausted, to raise a MaxRetryError, or to return a response with a\n response code in the 3xx range.\n\n :param bool raise_on_status: Similar meaning to ``raise_on_redirect``:\n whether we should raise an exception, or return a response,\n if status falls in ``status_forcelist`` range and retries have\n been exhausted.\n\n :param tuple history: The history of the request encountered during\n each call to :meth:`~Retry.increment`. The list is in the order\n the requests occurred. Each list item is of class :class:`RequestHistory`.\n\n :param bool respect_retry_after_header:\n Whether to respect Retry-After header on status codes defined as\n :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not.\n\n :param Collection remove_headers_on_redirect:\n Sequence of headers to remove from the request when a response\n indicating a redirect is returned before firing off the redirected\n request.\n \"\"\"\n\n #: Default methods to be used for ``allowed_methods``\n DEFAULT_ALLOWED_METHODS = frozenset(\n [\"HEAD\", \"GET\", \"PUT\", \"DELETE\", \"OPTIONS\", \"TRACE\"]\n )\n\n #: Default status codes to be used for ``status_forcelist``\n RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503])\n\n #: Default headers to be used for ``remove_headers_on_redirect``\n DEFAULT_REMOVE_HEADERS_ON_REDIRECT = frozenset([\"Cookie\", \"Authorization\"])\n\n #: Default maximum backoff time.\n DEFAULT_BACKOFF_MAX = 120\n\n # Backward compatibility; assigned outside of the class.\n DEFAULT: typing.ClassVar[Retry]\n\n def __init__(\n self,\n total: bool | int | None = 10,\n connect: int | None = None,\n read: int | None = None,\n redirect: bool | int | None = None,\n status: int | None = None,\n other: int | None = None,\n allowed_methods: typing.Collection[str] | None = DEFAULT_ALLOWED_METHODS,\n status_forcelist: typing.Collection[int] | None = None,\n backoff_factor: float = 0,\n backoff_max: float = DEFAULT_BACKOFF_MAX,\n raise_on_redirect: bool = True,\n raise_on_status: bool = True,\n history: tuple[RequestHistory, ...] | None = None,\n respect_retry_after_header: bool = True,\n remove_headers_on_redirect: typing.Collection[\n str\n ] = DEFAULT_REMOVE_HEADERS_ON_REDIRECT,\n backoff_jitter: float = 0.0,\n ) -> None:\n self.total = total\n self.connect = connect\n self.read = read\n self.status = status\n self.other = other\n\n if redirect is False or total is False:\n redirect = 0\n raise_on_redirect = False\n\n self.redirect = redirect\n self.status_forcelist = status_forcelist or set()\n self.allowed_methods = allowed_methods\n self.backoff_factor = backoff_factor\n self.backoff_max = backoff_max\n self.raise_on_redirect = raise_on_redirect\n self.raise_on_status = raise_on_status\n self.history = history or ()\n self.respect_retry_after_header = respect_retry_after_header\n self.remove_headers_on_redirect = frozenset(\n h.lower() for h in remove_headers_on_redirect\n )\n self.backoff_jitter = backoff_jitter\n\n def new(self, **kw: typing.Any) -> Retry:\n params = dict(\n total=self.total,\n connect=self.connect,\n read=self.read,\n redirect=self.redirect,\n status=self.status,\n other=self.other,\n allowed_methods=self.allowed_methods,\n status_forcelist=self.status_forcelist,\n backoff_factor=self.backoff_factor,\n backoff_max=self.backoff_max,\n raise_on_redirect=self.raise_on_redirect,\n raise_on_status=self.raise_on_status,\n history=self.history,\n remove_headers_on_redirect=self.remove_headers_on_redirect,\n respect_retry_after_header=self.respect_retry_after_header,\n backoff_jitter=self.backoff_jitter,\n )\n\n params.update(kw)\n return type(self)(**params) # type: ignore[arg-type]\n\n @classmethod\n def from_int(\n cls,\n retries: Retry | bool | int | None,\n redirect: bool | int | None = True,\n default: Retry | bool | int | None = None,\n ) -> Retry:\n \"\"\"Backwards-compatibility for the old retries format.\"\"\"\n if retries is None:\n retries = default if default is not None else cls.DEFAULT\n\n if isinstance(retries, Retry):\n return retries\n\n redirect = bool(redirect) and None\n new_retries = cls(retries, redirect=redirect)\n log.debug(\"Converted retries value: %r -> %r\", retries, new_retries)\n return new_retries\n\n def get_backoff_time(self) -> float:\n \"\"\"Formula for computing the current backoff\n\n :rtype: float\n \"\"\"\n # We want to consider only the last consecutive errors sequence (Ignore redirects).\n consecutive_errors_len = len(\n list(\n takewhile(lambda x: x.redirect_location is None, reversed(self.history))\n )\n )\n if consecutive_errors_len <= 1:\n return 0\n\n backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1))\n if self.backoff_jitter != 0.0:\n backoff_value += random.random() * self.backoff_jitter\n return float(max(0, min(self.backoff_max, backoff_value)))\n\n def parse_retry_after(self, retry_after: str) -> float:\n seconds: float\n # Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4\n if re.match(r\"^\\s*[0-9]+\\s*$\", retry_after):\n seconds = int(retry_after)\n else:\n retry_date_tuple = email.utils.parsedate_tz(retry_after)\n if retry_date_tuple is None:\n raise InvalidHeader(f\"Invalid Retry-After header: {retry_after}\")\n\n retry_date = email.utils.mktime_tz(retry_date_tuple)\n seconds = retry_date - time.time()\n\n seconds = max(seconds, 0)\n\n return seconds\n\n def get_retry_after(self, response: BaseHTTPResponse) -> float | None:\n \"\"\"Get the value of Retry-After in seconds.\"\"\"\n\n retry_after = response.headers.get(\"Retry-After\")\n\n if retry_after is None:\n return None\n\n return self.parse_retry_after(retry_after)\n\n def sleep_for_retry(self, response: BaseHTTPResponse) -> bool:\n retry_after = self.get_retry_after(response)\n if retry_after:\n time.sleep(retry_after)\n return True\n\n return False\n\n def _sleep_backoff(self) -> None:\n backoff = self.get_backoff_time()\n if backoff <= 0:\n return\n time.sleep(backoff)\n\n def sleep(self, response: BaseHTTPResponse | None = None) -> None:\n \"\"\"Sleep between retry attempts.\n\n This method will respect a server's ``Retry-After`` response header\n and sleep the duration of the time requested. If that is not present, it\n will use an exponential backoff. By default, the backoff factor is 0 and\n this method will return immediately.\n \"\"\"\n\n if self.respect_retry_after_header and response:\n slept = self.sleep_for_retry(response)\n if slept:\n return\n\n self._sleep_backoff()\n\n def _is_connection_error(self, err: Exception) -> bool:\n \"\"\"Errors when we're fairly sure that the server did not receive the\n request, so it should be safe to retry.\n \"\"\"\n if isinstance(err, ProxyError):\n err = err.original_error\n return isinstance(err, ConnectTimeoutError)\n\n def _is_read_error(self, err: Exception) -> bool:\n \"\"\"Errors that occur after the request has been started, so we should\n assume that the server began processing it.\n \"\"\"\n return isinstance(err, (ReadTimeoutError, ProtocolError))\n\n def _is_method_retryable(self, method: str) -> bool:\n \"\"\"Checks if a given HTTP method should be retried upon, depending if\n it is included in the allowed_methods\n \"\"\"\n if self.allowed_methods and method.upper() not in self.allowed_methods:\n return False\n return True\n\n def is_retry(\n self, method: str, status_code: int, has_retry_after: bool = False\n ) -> bool:\n \"\"\"Is this method/status code retryable? (Based on allowlists and control\n variables such as the number of total retries to allow, whether to\n respect the Retry-After header, whether this header is present, and\n whether the returned status code is on the list of status codes to\n be retried upon on the presence of the aforementioned header)\n \"\"\"\n if not self._is_method_retryable(method):\n return False\n\n if self.status_forcelist and status_code in self.status_forcelist:\n return True\n\n return bool(\n self.total\n and self.respect_retry_after_header\n and has_retry_after\n and (status_code in self.RETRY_AFTER_STATUS_CODES)\n )\n\n def is_exhausted(self) -> bool:\n \"\"\"Are we out of retries?\"\"\"\n retry_counts = [\n x\n for x in (\n self.total,\n self.connect,\n self.read,\n self.redirect,\n self.status,\n self.other,\n )\n if x\n ]\n if not retry_counts:\n return False\n\n return min(retry_counts) < 0\n\n def increment(\n self,\n method: str | None = None,\n url: str | None = None,\n response: BaseHTTPResponse | None = None,\n error: Exception | None = None,\n _pool: ConnectionPool | None = None,\n _stacktrace: TracebackType | None = None,\n ) -> Retry:\n \"\"\"Return a new Retry object with incremented retry counters.\n\n :param response: A response object, or None, if the server did not\n return a response.\n :type response: :class:`~urllib3.response.BaseHTTPResponse`\n :param Exception error: An error encountered during the request, or\n None if the response was received successfully.\n\n :return: A new ``Retry`` object.\n \"\"\"\n if self.total is False and error:\n # Disabled, indicate to re-raise the error.\n raise reraise(type(error), error, _stacktrace)\n\n total = self.total\n if total is not None:\n total -= 1\n\n connect = self.connect\n read = self.read\n redirect = self.redirect\n status_count = self.status\n other = self.other\n cause = \"unknown\"\n status = None\n redirect_location = None\n\n if error and self._is_connection_error(error):\n # Connect retry?\n if connect is False:\n raise reraise(type(error), error, _stacktrace)\n elif connect is not None:\n connect -= 1\n\n elif error and self._is_read_error(error):\n # Read retry?\n if read is False or method is None or not self._is_method_retryable(method):\n raise reraise(type(error), error, _stacktrace)\n elif read is not None:\n read -= 1\n\n elif error:\n # Other retry?\n if other is not None:\n other -= 1\n\n elif response and response.get_redirect_location():\n # Redirect retry?\n if redirect is not None:\n redirect -= 1\n cause = \"too many redirects\"\n response_redirect_location = response.get_redirect_location()\n if response_redirect_location:\n redirect_location = response_redirect_location\n status = response.status\n\n else:\n # Incrementing because of a server error like a 500 in\n # status_forcelist and the given method is in the allowed_methods\n cause = ResponseError.GENERIC_ERROR\n if response and response.status:\n if status_count is not None:\n status_count -= 1\n cause = ResponseError.SPECIFIC_ERROR.format(status_code=response.status)\n status = response.status\n\n history = self.history + (\n RequestHistory(method, url, error, status, redirect_location),\n )\n\n new_retry = self.new(\n total=total,\n connect=connect,\n read=read,\n redirect=redirect,\n status=status_count,\n other=other,\n history=history,\n )\n\n if new_retry.is_exhausted():\n reason = error or ResponseError(cause)\n raise MaxRetryError(_pool, url, reason) from reason # type: ignore[arg-type]\n\n log.debug(\"Incremented Retry for (url='%s'): %r\", url, new_retry)\n\n return new_retry\n\n def __repr__(self) -> str:\n return (\n f\"{type(self).__name__}(total={self.total}, connect={self.connect}, \"\n f\"read={self.read}, redirect={self.redirect}, status={self.status})\"\n )"},{"identifier":"CertificateError","path":".venv/Lib/site-packages/urllib3/util/ssl_match_hostname.py","snippet":"class CertificateError(ValueError):\n pass"},{"identifier":"_DEFAULT_TIMEOUT","path":".venv/Lib/site-packages/urllib3/util/timeout.py","snippet":"_DEFAULT_TIMEOUT: Final[_TYPE_DEFAULT] = _TYPE_DEFAULT.token"},{"identifier":"_TYPE_DEFAULT","path":".venv/Lib/site-packages/urllib3/util/timeout.py","snippet":"class _TYPE_DEFAULT(Enum):\n # This value should never be passed to socket.settimeout() so for safety we use a -1.\n # socket.settimout() raises a ValueError for negative values.\n token = -1"},{"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":"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"},{"identifier":"_encode_target","path":".venv/Lib/site-packages/urllib3/util/url.py","snippet":"def _encode_target(target: str) -> str:\n \"\"\"Percent-encodes a request target so that there are no invalid characters\n\n Pre-condition for this function is that 'target' must start with '/'.\n If that is the case then _TARGET_RE will always produce a match.\n \"\"\"\n match = _TARGET_RE.match(target)\n if not match: # Defensive:\n raise LocationParseError(f\"{target!r} is not a valid request URI\")\n\n path, query = match.groups()\n encoded_target = _encode_invalid_chars(path, _PATH_CHARS)\n if query is not None:\n query = _encode_invalid_chars(query, _QUERY_CHARS)\n encoded_target += \"?\" + query\n return encoded_target"},{"identifier":"_normalize_host","path":".venv/Lib/site-packages/urllib3/util/url.py","snippet":"@typing.overload\ndef _normalize_host(host: None, scheme: str | None) -> None:\n ..."},{"identifier":"parse_url","path":".venv/Lib/site-packages/urllib3/util/url.py","snippet":"def parse_url(url: str) -> Url:\n \"\"\"\n Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is\n performed to parse incomplete urls. Fields not provided will be None.\n This parser is RFC 3986 and RFC 6874 compliant.\n\n The parser logic and helper functions are based heavily on\n work done in the ``rfc3986`` module.\n\n :param str url: URL to parse into a :class:`.Url` namedtuple.\n\n Partly backwards-compatible with :mod:`urllib.parse`.\n\n Example:\n\n .. code-block:: python\n\n import urllib3\n\n print( urllib3.util.parse_url('http://google.com/mail/'))\n # Url(scheme='http', host='google.com', port=None, path='/mail/', ...)\n\n print( urllib3.util.parse_url('google.com:80'))\n # Url(scheme=None, host='google.com', port=80, path=None, ...)\n\n print( urllib3.util.parse_url('/foo?bar'))\n # Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)\n \"\"\"\n if not url:\n # Empty\n return Url()\n\n source_url = url\n if not _SCHEME_RE.search(url):\n url = \"//\" + url\n\n scheme: str | None\n authority: str | None\n auth: str | None\n host: str | None\n port: str | None\n port_int: int | None\n path: str | None\n query: str | None\n fragment: str | None\n\n try:\n scheme, authority, path, query, fragment = _URI_RE.match(url).groups() # type: ignore[union-attr]\n normalize_uri = scheme is None or scheme.lower() in _NORMALIZABLE_SCHEMES\n\n if scheme:\n scheme = scheme.lower()\n\n if authority:\n auth, _, host_port = authority.rpartition(\"@\")\n auth = auth or None\n host, port = _HOST_PORT_RE.match(host_port).groups() # type: ignore[union-attr]\n if auth and normalize_uri:\n auth = _encode_invalid_chars(auth, _USERINFO_CHARS)\n if port == \"\":\n port = None\n else:\n auth, host, port = None, None, None\n\n if port is not None:\n port_int = int(port)\n if not (0 <= port_int <= 65535):\n raise LocationParseError(url)\n else:\n port_int = None\n\n host = _normalize_host(host, scheme)\n\n if normalize_uri and path:\n path = _remove_path_dot_segments(path)\n path = _encode_invalid_chars(path, _PATH_CHARS)\n if normalize_uri and query:\n query = _encode_invalid_chars(query, _QUERY_CHARS)\n if normalize_uri and fragment:\n fragment = _encode_invalid_chars(fragment, _FRAGMENT_CHARS)\n\n except (ValueError, AttributeError) as e:\n raise LocationParseError(source_url) from e\n\n # For the sake of backwards compatibility we put empty\n # string values for path if there are any defined values\n # beyond the path in the URL.\n # TODO: Remove this when we break backwards compatibility.\n if not path:\n if query is not None or fragment is not None:\n path = \"\"\n else:\n path = None\n\n return Url(\n scheme=scheme,\n auth=auth,\n host=host,\n port=port_int,\n path=path,\n query=query,\n fragment=fragment,\n )"},{"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()"}],"string":"[\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\": \"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\": \"RequestMethods\",\n \"path\": \".venv/Lib/site-packages/urllib3/_request_methods.py\",\n \"snippet\": \"class RequestMethods:\\n \\\"\\\"\\\"\\n Convenience mixin for classes who implement a :meth:`urlopen` method, such\\n as :class:`urllib3.HTTPConnectionPool` and\\n :class:`urllib3.PoolManager`.\\n\\n Provides behavior for making common types of HTTP request methods and\\n decides which type of request field encoding to use.\\n\\n Specifically,\\n\\n :meth:`.request_encode_url` is for sending requests whose fields are\\n encoded in the URL (such as GET, HEAD, DELETE).\\n\\n :meth:`.request_encode_body` is for sending requests whose fields are\\n encoded in the *body* of the request using multipart or www-form-urlencoded\\n (such as for POST, PUT, PATCH).\\n\\n :meth:`.request` is for making any kind of request, it will look up the\\n appropriate encoding format and use one of the above two methods to make\\n the request.\\n\\n Initializer parameters:\\n\\n :param headers:\\n Headers to include with all requests, unless other headers are given\\n explicitly.\\n \\\"\\\"\\\"\\n\\n _encode_url_methods = {\\\"DELETE\\\", \\\"GET\\\", \\\"HEAD\\\", \\\"OPTIONS\\\"}\\n\\n def __init__(self, headers: typing.Mapping[str, str] | None = None) -> None:\\n self.headers = headers or {}\\n\\n def urlopen(\\n self,\\n method: str,\\n url: str,\\n body: _TYPE_BODY | None = None,\\n headers: typing.Mapping[str, str] | None = None,\\n encode_multipart: bool = True,\\n multipart_boundary: str | None = None,\\n **kw: typing.Any,\\n ) -> BaseHTTPResponse: # Abstract\\n raise NotImplementedError(\\n \\\"Classes extending RequestMethods must implement \\\"\\n \\\"their own ``urlopen`` method.\\\"\\n )\\n\\n def request(\\n self,\\n method: str,\\n url: str,\\n body: _TYPE_BODY | None = None,\\n fields: _TYPE_FIELDS | None = None,\\n headers: typing.Mapping[str, str] | None = None,\\n json: typing.Any | None = None,\\n **urlopen_kw: typing.Any,\\n ) -> BaseHTTPResponse:\\n \\\"\\\"\\\"\\n Make a request using :meth:`urlopen` with the appropriate encoding of\\n ``fields`` based on the ``method`` used.\\n\\n This is a convenience method that requires the least amount of manual\\n effort. It can be used in most situations, while still having the\\n option to drop down to more specific methods when necessary, such as\\n :meth:`request_encode_url`, :meth:`request_encode_body`,\\n or even the lowest level :meth:`urlopen`.\\n \\\"\\\"\\\"\\n method = method.upper()\\n\\n if json is not None and body is not None:\\n raise TypeError(\\n \\\"request got values for both 'body' and 'json' parameters which are mutually exclusive\\\"\\n )\\n\\n if json is not None:\\n if headers is None:\\n headers = self.headers.copy() # type: ignore\\n if not (\\\"content-type\\\" in map(str.lower, headers.keys())):\\n headers[\\\"Content-Type\\\"] = \\\"application/json\\\" # type: ignore\\n\\n body = _json.dumps(json, separators=(\\\",\\\", \\\":\\\"), ensure_ascii=False).encode(\\n \\\"utf-8\\\"\\n )\\n\\n if body is not None:\\n urlopen_kw[\\\"body\\\"] = body\\n\\n if method in self._encode_url_methods:\\n return self.request_encode_url(\\n method,\\n url,\\n fields=fields, # type: ignore[arg-type]\\n headers=headers,\\n **urlopen_kw,\\n )\\n else:\\n return self.request_encode_body(\\n method, url, fields=fields, headers=headers, **urlopen_kw\\n )\\n\\n def request_encode_url(\\n self,\\n method: str,\\n url: str,\\n fields: _TYPE_ENCODE_URL_FIELDS | None = None,\\n headers: typing.Mapping[str, str] | None = None,\\n **urlopen_kw: str,\\n ) -> BaseHTTPResponse:\\n \\\"\\\"\\\"\\n Make a request using :meth:`urlopen` with the ``fields`` encoded in\\n the url. This is useful for request methods like GET, HEAD, DELETE, etc.\\n \\\"\\\"\\\"\\n if headers is None:\\n headers = self.headers\\n\\n extra_kw: dict[str, typing.Any] = {\\\"headers\\\": headers}\\n extra_kw.update(urlopen_kw)\\n\\n if fields:\\n url += \\\"?\\\" + urlencode(fields)\\n\\n return self.urlopen(method, url, **extra_kw)\\n\\n def request_encode_body(\\n self,\\n method: str,\\n url: str,\\n fields: _TYPE_FIELDS | None = None,\\n headers: typing.Mapping[str, str] | None = None,\\n encode_multipart: bool = True,\\n multipart_boundary: str | None = None,\\n **urlopen_kw: str,\\n ) -> BaseHTTPResponse:\\n \\\"\\\"\\\"\\n Make a request using :meth:`urlopen` with the ``fields`` encoded in\\n the body. This is useful for request methods like POST, PUT, PATCH, etc.\\n\\n When ``encode_multipart=True`` (default), then\\n :func:`urllib3.encode_multipart_formdata` is used to encode\\n the payload with the appropriate content type. Otherwise\\n :func:`urllib.parse.urlencode` is used with the\\n 'application/x-www-form-urlencoded' content type.\\n\\n Multipart encoding must be used when posting files, and it's reasonably\\n safe to use it in other times too. However, it may break request\\n signing, such as with OAuth.\\n\\n Supports an optional ``fields`` parameter of key/value strings AND\\n key/filetuple. A filetuple is a (filename, data, MIME type) tuple where\\n the MIME type is optional. For example::\\n\\n fields = {\\n 'foo': 'bar',\\n 'fakefile': ('foofile.txt', 'contents of foofile'),\\n 'realfile': ('barfile.txt', open('realfile').read()),\\n 'typedfile': ('bazfile.bin', open('bazfile').read(),\\n 'image/jpeg'),\\n 'nonamefile': 'contents of nonamefile field',\\n }\\n\\n When uploading a file, providing a filename (the first parameter of the\\n tuple) is optional but recommended to best mimic behavior of browsers.\\n\\n Note that if ``headers`` are supplied, the 'Content-Type' header will\\n be overwritten because it depends on the dynamic random boundary string\\n which is used to compose the body of the request. The random boundary\\n string can be explicitly set with the ``multipart_boundary`` parameter.\\n \\\"\\\"\\\"\\n if headers is None:\\n headers = self.headers\\n\\n extra_kw: dict[str, typing.Any] = {\\\"headers\\\": HTTPHeaderDict(headers)}\\n body: bytes | str\\n\\n if fields:\\n if \\\"body\\\" in urlopen_kw:\\n raise TypeError(\\n \\\"request got values for both 'fields' and 'body', can only specify one.\\\"\\n )\\n\\n if encode_multipart:\\n body, content_type = encode_multipart_formdata(\\n fields, boundary=multipart_boundary\\n )\\n else:\\n body, content_type = (\\n urlencode(fields), # type: ignore[arg-type]\\n \\\"application/x-www-form-urlencoded\\\",\\n )\\n\\n extra_kw[\\\"body\\\"] = body\\n extra_kw[\\\"headers\\\"].setdefault(\\\"Content-Type\\\", content_type)\\n\\n extra_kw.update(urlopen_kw)\\n\\n return self.urlopen(method, url, **extra_kw)\"\n },\n {\n \"identifier\": \"BaseSSLError\",\n \"path\": \".venv/Lib/site-packages/urllib3/connection.py\",\n \"snippet\": \" class BaseSSLError(BaseException): # type: ignore[no-redef]\\nclass HTTPConnection(_HTTPConnection):\\nclass HTTPSConnection(HTTPConnection):\\nclass _WrappedAndVerifiedSocket(typing.NamedTuple):\\nclass DummyConnection:\\nRECENT_DATE = datetime.date(2022, 1, 1)\\n_CONTAINS_CONTROL_CHAR_RE = re.compile(r\\\"[^-!#$%&'*+.^_`|~0-9a-zA-Z]\\\")\\n_HAS_SYS_AUDIT = hasattr(sys, \\\"audit\\\")\\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 def host(self) -> str:\\n def host(self, value: str) -> None:\\n def _new_conn(self) -> socket.socket:\\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 def connect(self) -> None:\\n def is_closed(self) -> bool:\\n def is_connected(self) -> bool:\\n def has_connected_to_proxy(self) -> bool:\\n def close(self) -> None:\\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 def putheader(self, header: str, *values: str) -> None:\\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 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 def getresponse( # type: ignore[override]\\n self,\\n ) -> HTTPResponse:\\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 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 def connect(self) -> None:\\n def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket:\\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:\\ndef _match_hostname(\\n cert: _TYPE_PEER_CERT_RET_DICT | None,\\n asserted_hostname: str,\\n hostname_checks_common_name: bool = False,\\n) -> None:\\ndef _wrap_proxy_error(err: Exception, proxy_scheme: str | None) -> ProxyError:\\ndef _get_default_user_agent() -> str:\\ndef _url_from_connection(\\n conn: HTTPConnection | HTTPSConnection, path: str | None = None\\n) -> str:\"\n },\n {\n \"identifier\": \"port_by_scheme\",\n \"path\": \".venv/Lib/site-packages/urllib3/connection.py\",\n \"snippet\": \" class BaseSSLError(BaseException): # type: ignore[no-redef]\\nclass HTTPConnection(_HTTPConnection):\\nclass HTTPSConnection(HTTPConnection):\\nclass _WrappedAndVerifiedSocket(typing.NamedTuple):\\nclass DummyConnection:\\nRECENT_DATE = datetime.date(2022, 1, 1)\\n_CONTAINS_CONTROL_CHAR_RE = re.compile(r\\\"[^-!#$%&'*+.^_`|~0-9a-zA-Z]\\\")\\n_HAS_SYS_AUDIT = hasattr(sys, \\\"audit\\\")\\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 def host(self) -> str:\\n def host(self, value: str) -> None:\\n def _new_conn(self) -> socket.socket:\\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 def connect(self) -> None:\\n def is_closed(self) -> bool:\\n def is_connected(self) -> bool:\\n def has_connected_to_proxy(self) -> bool:\\n def close(self) -> None:\\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 def putheader(self, header: str, *values: str) -> None:\\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 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 def getresponse( # type: ignore[override]\\n self,\\n ) -> HTTPResponse:\\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 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 def connect(self) -> None:\\n def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket:\\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:\\ndef _match_hostname(\\n cert: _TYPE_PEER_CERT_RET_DICT | None,\\n asserted_hostname: str,\\n hostname_checks_common_name: bool = False,\\n) -> None:\\ndef _wrap_proxy_error(err: Exception, proxy_scheme: str | None) -> ProxyError:\\ndef _get_default_user_agent() -> str:\\ndef _url_from_connection(\\n conn: HTTPConnection | HTTPSConnection, path: str | None = None\\n) -> str:\"\n },\n {\n \"identifier\": \"ClosedPoolError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class ClosedPoolError(PoolError):\\n \\\"\\\"\\\"Raised when a request enters a pool after the pool has been closed.\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"EmptyPoolError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class EmptyPoolError(PoolError):\\n \\\"\\\"\\\"Raised when a pool runs out of connections and no more are allowed.\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"FullPoolError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class FullPoolError(PoolError):\\n \\\"\\\"\\\"Raised when we try to add a connection to a full pool in blocking mode.\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"HostChangedError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class HostChangedError(RequestError):\\n \\\"\\\"\\\"Raised when an existing pool gets a request for a foreign host.\\\"\\\"\\\"\\n\\n def __init__(\\n self, pool: ConnectionPool, url: str, retries: Retry | int = 3\\n ) -> None:\\n message = f\\\"Tried to open a foreign host with url: {url}\\\"\\n super().__init__(pool, url, message)\\n self.retries = retries\"\n },\n {\n \"identifier\": \"InsecureRequestWarning\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class InsecureRequestWarning(SecurityWarning):\\n \\\"\\\"\\\"Warned when making an unverified HTTPS request.\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"LocationValueError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class LocationValueError(ValueError, HTTPError):\\n \\\"\\\"\\\"Raised when there is something wrong with a given URL input.\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"MaxRetryError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class MaxRetryError(RequestError):\\n \\\"\\\"\\\"Raised when the maximum number of retries is exceeded.\\n\\n :param pool: The connection pool\\n :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool`\\n :param str url: The requested Url\\n :param reason: The underlying error\\n :type reason: :class:`Exception`\\n\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self, pool: ConnectionPool, url: str, reason: Exception | None = None\\n ) -> None:\\n self.reason = reason\\n\\n message = f\\\"Max retries exceeded with url: {url} (Caused by {reason!r})\\\"\\n\\n super().__init__(pool, url, 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\": \"ProtocolError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class ProtocolError(HTTPError):\\n \\\"\\\"\\\"Raised when something unexpected happens mid-request/response.\\\"\\\"\\\"\"\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\": \"ReadTimeoutError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class ReadTimeoutError(TimeoutError, RequestError):\\n \\\"\\\"\\\"Raised when a socket timeout occurs while receiving data from a server\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"SSLError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class SSLError(HTTPError):\\n \\\"\\\"\\\"Raised when SSL certificate fails in an HTTPS connection.\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"TimeoutError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class TimeoutError(HTTPError):\\n \\\"\\\"\\\"Raised when a socket timeout error occurs.\\n\\n Catching this error will catch both :exc:`ReadTimeoutErrors\\n <ReadTimeoutError>` and :exc:`ConnectTimeoutErrors <ConnectTimeoutError>`.\\n \\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"BaseHTTPResponse\",\n \"path\": \".venv/Lib/site-packages/urllib3/response.py\",\n \"snippet\": \"class BaseHTTPResponse(io.IOBase):\\n CONTENT_DECODERS = [\\\"gzip\\\", \\\"x-gzip\\\", \\\"deflate\\\"]\\n if brotli is not None:\\n CONTENT_DECODERS += [\\\"br\\\"]\\n if zstd is not None:\\n CONTENT_DECODERS += [\\\"zstd\\\"]\\n REDIRECT_STATUSES = [301, 302, 303, 307, 308]\\n\\n DECODER_ERROR_CLASSES: tuple[type[Exception], ...] = (IOError, zlib.error)\\n if brotli is not None:\\n DECODER_ERROR_CLASSES += (brotli.error,)\\n\\n if zstd is not None:\\n DECODER_ERROR_CLASSES += (zstd.ZstdError,)\\n\\n def __init__(\\n self,\\n *,\\n headers: typing.Mapping[str, str] | typing.Mapping[bytes, bytes] | None = None,\\n status: int,\\n version: int,\\n reason: str | None,\\n decode_content: bool,\\n request_url: str | None,\\n retries: Retry | None = None,\\n ) -> None:\\n if isinstance(headers, HTTPHeaderDict):\\n self.headers = headers\\n else:\\n self.headers = HTTPHeaderDict(headers) # type: ignore[arg-type]\\n self.status = status\\n self.version = version\\n self.reason = reason\\n self.decode_content = decode_content\\n self._has_decoded_content = False\\n self._request_url: str | None = request_url\\n self.retries = retries\\n\\n self.chunked = False\\n tr_enc = self.headers.get(\\\"transfer-encoding\\\", \\\"\\\").lower()\\n # Don't incur the penalty of creating a list and then discarding it\\n encodings = (enc.strip() for enc in tr_enc.split(\\\",\\\"))\\n if \\\"chunked\\\" in encodings:\\n self.chunked = True\\n\\n self._decoder: ContentDecoder | None = None\\n\\n def get_redirect_location(self) -> str | None | Literal[False]:\\n \\\"\\\"\\\"\\n Should we redirect and where to?\\n\\n :returns: Truthy redirect location string if we got a redirect status\\n code and valid location. ``None`` if redirect status and no\\n location. ``False`` if not a redirect status code.\\n \\\"\\\"\\\"\\n if self.status in self.REDIRECT_STATUSES:\\n return self.headers.get(\\\"location\\\")\\n return False\\n\\n @property\\n def data(self) -> bytes:\\n raise NotImplementedError()\\n\\n def json(self) -> typing.Any:\\n \\\"\\\"\\\"\\n Parses the body of the HTTP response as JSON.\\n\\n To use a custom JSON decoder pass the result of :attr:`HTTPResponse.data` to the decoder.\\n\\n This method can raise either `UnicodeDecodeError` or `json.JSONDecodeError`.\\n\\n Read more :ref:`here <json>`.\\n \\\"\\\"\\\"\\n data = self.data.decode(\\\"utf-8\\\")\\n return _json.loads(data)\\n\\n @property\\n def url(self) -> str | None:\\n raise NotImplementedError()\\n\\n @url.setter\\n def url(self, url: str | None) -> None:\\n raise NotImplementedError()\\n\\n @property\\n def connection(self) -> HTTPConnection | None:\\n raise NotImplementedError()\\n\\n @property\\n def retries(self) -> Retry | None:\\n return self._retries\\n\\n @retries.setter\\n def retries(self, retries: Retry | None) -> None:\\n # Override the request_url if retries has a redirect location.\\n if retries is not None and retries.history:\\n self.url = retries.history[-1].redirect_location\\n self._retries = retries\\n\\n def stream(\\n self, amt: int | None = 2**16, decode_content: bool | None = None\\n ) -> typing.Iterator[bytes]:\\n raise NotImplementedError()\\n\\n def read(\\n self,\\n amt: int | None = None,\\n decode_content: bool | None = None,\\n cache_content: bool = False,\\n ) -> bytes:\\n raise NotImplementedError()\\n\\n def read_chunked(\\n self,\\n amt: int | None = None,\\n decode_content: bool | None = None,\\n ) -> typing.Iterator[bytes]:\\n raise NotImplementedError()\\n\\n def release_conn(self) -> None:\\n raise NotImplementedError()\\n\\n def drain_conn(self) -> None:\\n raise NotImplementedError()\\n\\n def close(self) -> None:\\n raise NotImplementedError()\\n\\n def _init_decoder(self) -> None:\\n \\\"\\\"\\\"\\n Set-up the _decoder attribute if necessary.\\n \\\"\\\"\\\"\\n # Note: content-encoding value should be case-insensitive, per RFC 7230\\n # Section 3.2\\n content_encoding = self.headers.get(\\\"content-encoding\\\", \\\"\\\").lower()\\n if self._decoder is None:\\n if content_encoding in self.CONTENT_DECODERS:\\n self._decoder = _get_decoder(content_encoding)\\n elif \\\",\\\" in content_encoding:\\n encodings = [\\n e.strip()\\n for e in content_encoding.split(\\\",\\\")\\n if e.strip() in self.CONTENT_DECODERS\\n ]\\n if encodings:\\n self._decoder = _get_decoder(content_encoding)\\n\\n def _decode(\\n self, data: bytes, decode_content: bool | None, flush_decoder: bool\\n ) -> bytes:\\n \\\"\\\"\\\"\\n Decode the data passed in and potentially flush the decoder.\\n \\\"\\\"\\\"\\n if not decode_content:\\n if self._has_decoded_content:\\n raise RuntimeError(\\n \\\"Calling read(decode_content=False) is not supported after \\\"\\n \\\"read(decode_content=True) was called.\\\"\\n )\\n return data\\n\\n try:\\n if self._decoder:\\n data = self._decoder.decompress(data)\\n self._has_decoded_content = True\\n except self.DECODER_ERROR_CLASSES as e:\\n content_encoding = self.headers.get(\\\"content-encoding\\\", \\\"\\\").lower()\\n raise DecodeError(\\n \\\"Received response with content-encoding: %s, but \\\"\\n \\\"failed to decode it.\\\" % content_encoding,\\n e,\\n ) from e\\n if flush_decoder:\\n data += self._flush_decoder()\\n\\n return data\\n\\n def _flush_decoder(self) -> bytes:\\n \\\"\\\"\\\"\\n Flushes the decoder. Should only be called if the decoder is actually\\n being used.\\n \\\"\\\"\\\"\\n if self._decoder:\\n return self._decoder.decompress(b\\\"\\\") + self._decoder.flush()\\n return b\\\"\\\"\\n\\n # Compatibility methods for `io` module\\n def readinto(self, b: bytearray) -> int:\\n temp = self.read(len(b))\\n if len(temp) == 0:\\n return 0\\n else:\\n b[: len(temp)] = temp\\n return len(temp)\\n\\n # Compatibility methods for http.client.HTTPResponse\\n def getheaders(self) -> HTTPHeaderDict:\\n warnings.warn(\\n \\\"HTTPResponse.getheaders() is deprecated and will be removed \\\"\\n \\\"in urllib3 v2.1.0. Instead access HTTPResponse.headers directly.\\\",\\n category=DeprecationWarning,\\n stacklevel=2,\\n )\\n return self.headers\\n\\n def getheader(self, name: str, default: str | None = None) -> str | None:\\n warnings.warn(\\n \\\"HTTPResponse.getheader() is deprecated and will be removed \\\"\\n \\\"in urllib3 v2.1.0. Instead use HTTPResponse.headers.get(name, default).\\\",\\n category=DeprecationWarning,\\n stacklevel=2,\\n )\\n return self.headers.get(name, default)\\n\\n # Compatibility method for http.cookiejar\\n def info(self) -> HTTPHeaderDict:\\n return self.headers\\n\\n def geturl(self) -> str | None:\\n return self.url\"\n },\n {\n \"identifier\": \"is_connection_dropped\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/connection.py\",\n \"snippet\": \"def is_connection_dropped(conn: BaseHTTPConnection) -> bool: # Platform-specific\\n \\\"\\\"\\\"\\n Returns True if the connection is dropped and should be closed.\\n :param conn: :class:`urllib3.connection.HTTPConnection` object.\\n \\\"\\\"\\\"\\n return not conn.is_connected\"\n },\n {\n \"identifier\": \"connection_requires_http_tunnel\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/proxy.py\",\n \"snippet\": \"def connection_requires_http_tunnel(\\n proxy_url: Url | None = None,\\n proxy_config: ProxyConfig | None = None,\\n destination_scheme: str | None = None,\\n) -> bool:\\n \\\"\\\"\\\"\\n Returns True if the connection requires an HTTP CONNECT through the proxy.\\n\\n :param URL proxy_url:\\n URL of the proxy.\\n :param ProxyConfig proxy_config:\\n Proxy configuration from poolmanager.py\\n :param str destination_scheme:\\n The scheme of the destination. (i.e https, http, etc)\\n \\\"\\\"\\\"\\n # If we're not using a proxy, no way to use a tunnel.\\n if proxy_url is None:\\n return False\\n\\n # HTTP destinations never require tunneling, we always forward.\\n if destination_scheme == \\\"http\\\":\\n return False\\n\\n # Support for forwarding with HTTPS proxies and HTTPS destinations.\\n if (\\n proxy_url.scheme == \\\"https\\\"\\n and proxy_config\\n and proxy_config.use_forwarding_for_https\\n ):\\n return False\\n\\n # Otherwise always use a tunnel.\\n return True\"\n },\n {\n \"identifier\": \"_TYPE_BODY_POSITION\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/request.py\",\n \"snippet\": \"_TYPE_BODY_POSITION = typing.Union[int, _TYPE_FAILEDTELL]\"\n },\n {\n \"identifier\": \"set_file_position\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/request.py\",\n \"snippet\": \"def set_file_position(\\n body: typing.Any, pos: _TYPE_BODY_POSITION | None\\n) -> _TYPE_BODY_POSITION | None:\\n \\\"\\\"\\\"\\n If a position is provided, move file to that point.\\n Otherwise, we'll attempt to record a position for future use.\\n \\\"\\\"\\\"\\n if pos is not None:\\n rewind_body(body, pos)\\n elif getattr(body, \\\"tell\\\", None) is not None:\\n try:\\n pos = body.tell()\\n except OSError:\\n # This differentiates from None, allowing us to catch\\n # a failed `tell()` later when trying to rewind the body.\\n pos = _FAILEDTELL\\n\\n return pos\"\n },\n {\n \"identifier\": \"Retry\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/retry.py\",\n \"snippet\": \"class Retry:\\n \\\"\\\"\\\"Retry configuration.\\n\\n Each retry attempt will create a new Retry object with updated values, so\\n they can be safely reused.\\n\\n Retries can be defined as a default for a pool:\\n\\n .. code-block:: python\\n\\n retries = Retry(connect=5, read=2, redirect=5)\\n http = PoolManager(retries=retries)\\n response = http.request(\\\"GET\\\", \\\"https://example.com/\\\")\\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/\\\", retries=Retry(10))\\n\\n Retries can be disabled by passing ``False``:\\n\\n .. code-block:: python\\n\\n response = http.request(\\\"GET\\\", \\\"https://example.com/\\\", retries=False)\\n\\n Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless\\n retries are disabled, in which case the causing exception will be raised.\\n\\n :param int total:\\n Total number of retries to allow. Takes precedence over other counts.\\n\\n Set to ``None`` to remove this constraint and fall back on other\\n counts.\\n\\n Set to ``0`` to fail on the first retry.\\n\\n Set to ``False`` to disable and imply ``raise_on_redirect=False``.\\n\\n :param int connect:\\n How many connection-related errors to retry on.\\n\\n These are errors raised before the request is sent to the remote server,\\n which we assume has not triggered the server to process the request.\\n\\n Set to ``0`` to fail on the first retry of this type.\\n\\n :param int read:\\n How many times to retry on read errors.\\n\\n These errors are raised after the request was sent to the server, so the\\n request may have side-effects.\\n\\n Set to ``0`` to fail on the first retry of this type.\\n\\n :param int redirect:\\n How many redirects to perform. Limit this to avoid infinite redirect\\n loops.\\n\\n A redirect is a HTTP response with a status code 301, 302, 303, 307 or\\n 308.\\n\\n Set to ``0`` to fail on the first retry of this type.\\n\\n Set to ``False`` to disable and imply ``raise_on_redirect=False``.\\n\\n :param int status:\\n How many times to retry on bad status codes.\\n\\n These are retries made on responses, where status code matches\\n ``status_forcelist``.\\n\\n Set to ``0`` to fail on the first retry of this type.\\n\\n :param int other:\\n How many times to retry on other errors.\\n\\n Other errors are errors that are not connect, read, redirect or status errors.\\n These errors might be raised after the request was sent to the server, so the\\n request might have side-effects.\\n\\n Set to ``0`` to fail on the first retry of this type.\\n\\n If ``total`` is not set, it's a good idea to set this to 0 to account\\n for unexpected edge cases and avoid infinite retry loops.\\n\\n :param Collection allowed_methods:\\n Set of uppercased HTTP method verbs that we should retry on.\\n\\n By default, we only retry on methods which are considered to be\\n idempotent (multiple requests with the same parameters end with the\\n same state). See :attr:`Retry.DEFAULT_ALLOWED_METHODS`.\\n\\n Set to a ``None`` value to retry on any verb.\\n\\n :param Collection status_forcelist:\\n A set of integer HTTP status codes that we should force a retry on.\\n A retry is initiated if the request method is in ``allowed_methods``\\n and the response status code is in ``status_forcelist``.\\n\\n By default, this is disabled with ``None``.\\n\\n :param float backoff_factor:\\n A backoff factor to apply between attempts after the second try\\n (most errors are resolved immediately by a second try without a\\n delay). urllib3 will sleep for::\\n\\n {backoff factor} * (2 ** ({number of previous retries}))\\n\\n seconds. If `backoff_jitter` is non-zero, this sleep is extended by::\\n\\n random.uniform(0, {backoff jitter})\\n\\n seconds. For example, if the backoff_factor is 0.1, then :func:`Retry.sleep` will\\n sleep for [0.0s, 0.2s, 0.4s, 0.8s, ...] between retries. No backoff will ever\\n be longer than `backoff_max`.\\n\\n By default, backoff is disabled (factor set to 0).\\n\\n :param bool raise_on_redirect: Whether, if the number of redirects is\\n exhausted, to raise a MaxRetryError, or to return a response with a\\n response code in the 3xx range.\\n\\n :param bool raise_on_status: Similar meaning to ``raise_on_redirect``:\\n whether we should raise an exception, or return a response,\\n if status falls in ``status_forcelist`` range and retries have\\n been exhausted.\\n\\n :param tuple history: The history of the request encountered during\\n each call to :meth:`~Retry.increment`. The list is in the order\\n the requests occurred. Each list item is of class :class:`RequestHistory`.\\n\\n :param bool respect_retry_after_header:\\n Whether to respect Retry-After header on status codes defined as\\n :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not.\\n\\n :param Collection remove_headers_on_redirect:\\n Sequence of headers to remove from the request when a response\\n indicating a redirect is returned before firing off the redirected\\n request.\\n \\\"\\\"\\\"\\n\\n #: Default methods to be used for ``allowed_methods``\\n DEFAULT_ALLOWED_METHODS = frozenset(\\n [\\\"HEAD\\\", \\\"GET\\\", \\\"PUT\\\", \\\"DELETE\\\", \\\"OPTIONS\\\", \\\"TRACE\\\"]\\n )\\n\\n #: Default status codes to be used for ``status_forcelist``\\n RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503])\\n\\n #: Default headers to be used for ``remove_headers_on_redirect``\\n DEFAULT_REMOVE_HEADERS_ON_REDIRECT = frozenset([\\\"Cookie\\\", \\\"Authorization\\\"])\\n\\n #: Default maximum backoff time.\\n DEFAULT_BACKOFF_MAX = 120\\n\\n # Backward compatibility; assigned outside of the class.\\n DEFAULT: typing.ClassVar[Retry]\\n\\n def __init__(\\n self,\\n total: bool | int | None = 10,\\n connect: int | None = None,\\n read: int | None = None,\\n redirect: bool | int | None = None,\\n status: int | None = None,\\n other: int | None = None,\\n allowed_methods: typing.Collection[str] | None = DEFAULT_ALLOWED_METHODS,\\n status_forcelist: typing.Collection[int] | None = None,\\n backoff_factor: float = 0,\\n backoff_max: float = DEFAULT_BACKOFF_MAX,\\n raise_on_redirect: bool = True,\\n raise_on_status: bool = True,\\n history: tuple[RequestHistory, ...] | None = None,\\n respect_retry_after_header: bool = True,\\n remove_headers_on_redirect: typing.Collection[\\n str\\n ] = DEFAULT_REMOVE_HEADERS_ON_REDIRECT,\\n backoff_jitter: float = 0.0,\\n ) -> None:\\n self.total = total\\n self.connect = connect\\n self.read = read\\n self.status = status\\n self.other = other\\n\\n if redirect is False or total is False:\\n redirect = 0\\n raise_on_redirect = False\\n\\n self.redirect = redirect\\n self.status_forcelist = status_forcelist or set()\\n self.allowed_methods = allowed_methods\\n self.backoff_factor = backoff_factor\\n self.backoff_max = backoff_max\\n self.raise_on_redirect = raise_on_redirect\\n self.raise_on_status = raise_on_status\\n self.history = history or ()\\n self.respect_retry_after_header = respect_retry_after_header\\n self.remove_headers_on_redirect = frozenset(\\n h.lower() for h in remove_headers_on_redirect\\n )\\n self.backoff_jitter = backoff_jitter\\n\\n def new(self, **kw: typing.Any) -> Retry:\\n params = dict(\\n total=self.total,\\n connect=self.connect,\\n read=self.read,\\n redirect=self.redirect,\\n status=self.status,\\n other=self.other,\\n allowed_methods=self.allowed_methods,\\n status_forcelist=self.status_forcelist,\\n backoff_factor=self.backoff_factor,\\n backoff_max=self.backoff_max,\\n raise_on_redirect=self.raise_on_redirect,\\n raise_on_status=self.raise_on_status,\\n history=self.history,\\n remove_headers_on_redirect=self.remove_headers_on_redirect,\\n respect_retry_after_header=self.respect_retry_after_header,\\n backoff_jitter=self.backoff_jitter,\\n )\\n\\n params.update(kw)\\n return type(self)(**params) # type: ignore[arg-type]\\n\\n @classmethod\\n def from_int(\\n cls,\\n retries: Retry | bool | int | None,\\n redirect: bool | int | None = True,\\n default: Retry | bool | int | None = None,\\n ) -> Retry:\\n \\\"\\\"\\\"Backwards-compatibility for the old retries format.\\\"\\\"\\\"\\n if retries is None:\\n retries = default if default is not None else cls.DEFAULT\\n\\n if isinstance(retries, Retry):\\n return retries\\n\\n redirect = bool(redirect) and None\\n new_retries = cls(retries, redirect=redirect)\\n log.debug(\\\"Converted retries value: %r -> %r\\\", retries, new_retries)\\n return new_retries\\n\\n def get_backoff_time(self) -> float:\\n \\\"\\\"\\\"Formula for computing the current backoff\\n\\n :rtype: float\\n \\\"\\\"\\\"\\n # We want to consider only the last consecutive errors sequence (Ignore redirects).\\n consecutive_errors_len = len(\\n list(\\n takewhile(lambda x: x.redirect_location is None, reversed(self.history))\\n )\\n )\\n if consecutive_errors_len <= 1:\\n return 0\\n\\n backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1))\\n if self.backoff_jitter != 0.0:\\n backoff_value += random.random() * self.backoff_jitter\\n return float(max(0, min(self.backoff_max, backoff_value)))\\n\\n def parse_retry_after(self, retry_after: str) -> float:\\n seconds: float\\n # Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4\\n if re.match(r\\\"^\\\\s*[0-9]+\\\\s*$\\\", retry_after):\\n seconds = int(retry_after)\\n else:\\n retry_date_tuple = email.utils.parsedate_tz(retry_after)\\n if retry_date_tuple is None:\\n raise InvalidHeader(f\\\"Invalid Retry-After header: {retry_after}\\\")\\n\\n retry_date = email.utils.mktime_tz(retry_date_tuple)\\n seconds = retry_date - time.time()\\n\\n seconds = max(seconds, 0)\\n\\n return seconds\\n\\n def get_retry_after(self, response: BaseHTTPResponse) -> float | None:\\n \\\"\\\"\\\"Get the value of Retry-After in seconds.\\\"\\\"\\\"\\n\\n retry_after = response.headers.get(\\\"Retry-After\\\")\\n\\n if retry_after is None:\\n return None\\n\\n return self.parse_retry_after(retry_after)\\n\\n def sleep_for_retry(self, response: BaseHTTPResponse) -> bool:\\n retry_after = self.get_retry_after(response)\\n if retry_after:\\n time.sleep(retry_after)\\n return True\\n\\n return False\\n\\n def _sleep_backoff(self) -> None:\\n backoff = self.get_backoff_time()\\n if backoff <= 0:\\n return\\n time.sleep(backoff)\\n\\n def sleep(self, response: BaseHTTPResponse | None = None) -> None:\\n \\\"\\\"\\\"Sleep between retry attempts.\\n\\n This method will respect a server's ``Retry-After`` response header\\n and sleep the duration of the time requested. If that is not present, it\\n will use an exponential backoff. By default, the backoff factor is 0 and\\n this method will return immediately.\\n \\\"\\\"\\\"\\n\\n if self.respect_retry_after_header and response:\\n slept = self.sleep_for_retry(response)\\n if slept:\\n return\\n\\n self._sleep_backoff()\\n\\n def _is_connection_error(self, err: Exception) -> bool:\\n \\\"\\\"\\\"Errors when we're fairly sure that the server did not receive the\\n request, so it should be safe to retry.\\n \\\"\\\"\\\"\\n if isinstance(err, ProxyError):\\n err = err.original_error\\n return isinstance(err, ConnectTimeoutError)\\n\\n def _is_read_error(self, err: Exception) -> bool:\\n \\\"\\\"\\\"Errors that occur after the request has been started, so we should\\n assume that the server began processing it.\\n \\\"\\\"\\\"\\n return isinstance(err, (ReadTimeoutError, ProtocolError))\\n\\n def _is_method_retryable(self, method: str) -> bool:\\n \\\"\\\"\\\"Checks if a given HTTP method should be retried upon, depending if\\n it is included in the allowed_methods\\n \\\"\\\"\\\"\\n if self.allowed_methods and method.upper() not in self.allowed_methods:\\n return False\\n return True\\n\\n def is_retry(\\n self, method: str, status_code: int, has_retry_after: bool = False\\n ) -> bool:\\n \\\"\\\"\\\"Is this method/status code retryable? (Based on allowlists and control\\n variables such as the number of total retries to allow, whether to\\n respect the Retry-After header, whether this header is present, and\\n whether the returned status code is on the list of status codes to\\n be retried upon on the presence of the aforementioned header)\\n \\\"\\\"\\\"\\n if not self._is_method_retryable(method):\\n return False\\n\\n if self.status_forcelist and status_code in self.status_forcelist:\\n return True\\n\\n return bool(\\n self.total\\n and self.respect_retry_after_header\\n and has_retry_after\\n and (status_code in self.RETRY_AFTER_STATUS_CODES)\\n )\\n\\n def is_exhausted(self) -> bool:\\n \\\"\\\"\\\"Are we out of retries?\\\"\\\"\\\"\\n retry_counts = [\\n x\\n for x in (\\n self.total,\\n self.connect,\\n self.read,\\n self.redirect,\\n self.status,\\n self.other,\\n )\\n if x\\n ]\\n if not retry_counts:\\n return False\\n\\n return min(retry_counts) < 0\\n\\n def increment(\\n self,\\n method: str | None = None,\\n url: str | None = None,\\n response: BaseHTTPResponse | None = None,\\n error: Exception | None = None,\\n _pool: ConnectionPool | None = None,\\n _stacktrace: TracebackType | None = None,\\n ) -> Retry:\\n \\\"\\\"\\\"Return a new Retry object with incremented retry counters.\\n\\n :param response: A response object, or None, if the server did not\\n return a response.\\n :type response: :class:`~urllib3.response.BaseHTTPResponse`\\n :param Exception error: An error encountered during the request, or\\n None if the response was received successfully.\\n\\n :return: A new ``Retry`` object.\\n \\\"\\\"\\\"\\n if self.total is False and error:\\n # Disabled, indicate to re-raise the error.\\n raise reraise(type(error), error, _stacktrace)\\n\\n total = self.total\\n if total is not None:\\n total -= 1\\n\\n connect = self.connect\\n read = self.read\\n redirect = self.redirect\\n status_count = self.status\\n other = self.other\\n cause = \\\"unknown\\\"\\n status = None\\n redirect_location = None\\n\\n if error and self._is_connection_error(error):\\n # Connect retry?\\n if connect is False:\\n raise reraise(type(error), error, _stacktrace)\\n elif connect is not None:\\n connect -= 1\\n\\n elif error and self._is_read_error(error):\\n # Read retry?\\n if read is False or method is None or not self._is_method_retryable(method):\\n raise reraise(type(error), error, _stacktrace)\\n elif read is not None:\\n read -= 1\\n\\n elif error:\\n # Other retry?\\n if other is not None:\\n other -= 1\\n\\n elif response and response.get_redirect_location():\\n # Redirect retry?\\n if redirect is not None:\\n redirect -= 1\\n cause = \\\"too many redirects\\\"\\n response_redirect_location = response.get_redirect_location()\\n if response_redirect_location:\\n redirect_location = response_redirect_location\\n status = response.status\\n\\n else:\\n # Incrementing because of a server error like a 500 in\\n # status_forcelist and the given method is in the allowed_methods\\n cause = ResponseError.GENERIC_ERROR\\n if response and response.status:\\n if status_count is not None:\\n status_count -= 1\\n cause = ResponseError.SPECIFIC_ERROR.format(status_code=response.status)\\n status = response.status\\n\\n history = self.history + (\\n RequestHistory(method, url, error, status, redirect_location),\\n )\\n\\n new_retry = self.new(\\n total=total,\\n connect=connect,\\n read=read,\\n redirect=redirect,\\n status=status_count,\\n other=other,\\n history=history,\\n )\\n\\n if new_retry.is_exhausted():\\n reason = error or ResponseError(cause)\\n raise MaxRetryError(_pool, url, reason) from reason # type: ignore[arg-type]\\n\\n log.debug(\\\"Incremented Retry for (url='%s'): %r\\\", url, new_retry)\\n\\n return new_retry\\n\\n def __repr__(self) -> str:\\n return (\\n f\\\"{type(self).__name__}(total={self.total}, connect={self.connect}, \\\"\\n f\\\"read={self.read}, redirect={self.redirect}, status={self.status})\\\"\\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\": \"_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_DEFAULT\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/timeout.py\",\n \"snippet\": \"class _TYPE_DEFAULT(Enum):\\n # This value should never be passed to socket.settimeout() so for safety we use a -1.\\n # socket.settimout() raises a ValueError for negative values.\\n token = -1\"\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\": \"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 {\n \"identifier\": \"_encode_target\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/url.py\",\n \"snippet\": \"def _encode_target(target: str) -> str:\\n \\\"\\\"\\\"Percent-encodes a request target so that there are no invalid characters\\n\\n Pre-condition for this function is that 'target' must start with '/'.\\n If that is the case then _TARGET_RE will always produce a match.\\n \\\"\\\"\\\"\\n match = _TARGET_RE.match(target)\\n if not match: # Defensive:\\n raise LocationParseError(f\\\"{target!r} is not a valid request URI\\\")\\n\\n path, query = match.groups()\\n encoded_target = _encode_invalid_chars(path, _PATH_CHARS)\\n if query is not None:\\n query = _encode_invalid_chars(query, _QUERY_CHARS)\\n encoded_target += \\\"?\\\" + query\\n return encoded_target\"\n },\n {\n \"identifier\": \"_normalize_host\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/url.py\",\n \"snippet\": \"@typing.overload\\ndef _normalize_host(host: None, scheme: str | None) -> None:\\n ...\"\n },\n {\n \"identifier\": \"parse_url\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/url.py\",\n \"snippet\": \"def parse_url(url: str) -> Url:\\n \\\"\\\"\\\"\\n Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is\\n performed to parse incomplete urls. Fields not provided will be None.\\n This parser is RFC 3986 and RFC 6874 compliant.\\n\\n The parser logic and helper functions are based heavily on\\n work done in the ``rfc3986`` module.\\n\\n :param str url: URL to parse into a :class:`.Url` namedtuple.\\n\\n Partly backwards-compatible with :mod:`urllib.parse`.\\n\\n Example:\\n\\n .. code-block:: python\\n\\n import urllib3\\n\\n print( urllib3.util.parse_url('http://google.com/mail/'))\\n # Url(scheme='http', host='google.com', port=None, path='/mail/', ...)\\n\\n print( urllib3.util.parse_url('google.com:80'))\\n # Url(scheme=None, host='google.com', port=80, path=None, ...)\\n\\n print( urllib3.util.parse_url('/foo?bar'))\\n # Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)\\n \\\"\\\"\\\"\\n if not url:\\n # Empty\\n return Url()\\n\\n source_url = url\\n if not _SCHEME_RE.search(url):\\n url = \\\"//\\\" + url\\n\\n scheme: str | None\\n authority: str | None\\n auth: str | None\\n host: str | None\\n port: str | None\\n port_int: int | None\\n path: str | None\\n query: str | None\\n fragment: str | None\\n\\n try:\\n scheme, authority, path, query, fragment = _URI_RE.match(url).groups() # type: ignore[union-attr]\\n normalize_uri = scheme is None or scheme.lower() in _NORMALIZABLE_SCHEMES\\n\\n if scheme:\\n scheme = scheme.lower()\\n\\n if authority:\\n auth, _, host_port = authority.rpartition(\\\"@\\\")\\n auth = auth or None\\n host, port = _HOST_PORT_RE.match(host_port).groups() # type: ignore[union-attr]\\n if auth and normalize_uri:\\n auth = _encode_invalid_chars(auth, _USERINFO_CHARS)\\n if port == \\\"\\\":\\n port = None\\n else:\\n auth, host, port = None, None, None\\n\\n if port is not None:\\n port_int = int(port)\\n if not (0 <= port_int <= 65535):\\n raise LocationParseError(url)\\n else:\\n port_int = None\\n\\n host = _normalize_host(host, scheme)\\n\\n if normalize_uri and path:\\n path = _remove_path_dot_segments(path)\\n path = _encode_invalid_chars(path, _PATH_CHARS)\\n if normalize_uri and query:\\n query = _encode_invalid_chars(query, _QUERY_CHARS)\\n if normalize_uri and fragment:\\n fragment = _encode_invalid_chars(fragment, _FRAGMENT_CHARS)\\n\\n except (ValueError, AttributeError) as e:\\n raise LocationParseError(source_url) from e\\n\\n # For the sake of backwards compatibility we put empty\\n # string values for path if there are any defined values\\n # beyond the path in the URL.\\n # TODO: Remove this when we break backwards compatibility.\\n if not path:\\n if query is not None or fragment is not None:\\n path = \\\"\\\"\\n else:\\n path = None\\n\\n return Url(\\n scheme=scheme,\\n auth=auth,\\n host=host,\\n port=port_int,\\n path=path,\\n query=query,\\n fragment=fragment,\\n )\"\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]","isConversational":false},"import_statement":{"kind":"string","value":"import errno\nimport logging\nimport queue\nimport sys\nimport typing\nimport warnings\nimport weakref\n import ssl\nfrom socket import timeout as SocketTimeout\nfrom types import TracebackType\nfrom ._base_connection import _TYPE_BODY\nfrom ._collections import HTTPHeaderDict\nfrom ._request_methods import RequestMethods\nfrom .connection import (\n BaseSSLError,\n BrokenPipeError,\n DummyConnection,\n HTTPConnection,\n HTTPException,\n HTTPSConnection,\n ProxyConfig,\n _wrap_proxy_error,\n)\nfrom .connection import port_by_scheme as port_by_scheme\nfrom .exceptions import (\n ClosedPoolError,\n EmptyPoolError,\n FullPoolError,\n HostChangedError,\n InsecureRequestWarning,\n LocationValueError,\n MaxRetryError,\n NewConnectionError,\n ProtocolError,\n ProxyError,\n ReadTimeoutError,\n SSLError,\n TimeoutError,\n)\nfrom .response import BaseHTTPResponse\nfrom .util.connection import is_connection_dropped\nfrom .util.proxy import connection_requires_http_tunnel\nfrom .util.request import _TYPE_BODY_POSITION, set_file_position\nfrom .util.retry import Retry\nfrom .util.ssl_match_hostname import CertificateError\nfrom .util.timeout import _DEFAULT_TIMEOUT, _TYPE_DEFAULT, Timeout\nfrom .util.url import Url, _encode_target\nfrom .util.url import _normalize_host as normalize_host\nfrom .util.url import parse_url\nfrom .util.util import to_str\n from typing import Literal\n from ._base_connection import BaseHTTPConnection, BaseHTTPSConnection"},"token_num":{"kind":"number","value":20866,"string":"20,866"},"cropped_code":{"kind":"string","value":"from __future__ import annotations\n\n\n\nif typing.TYPE_CHECKING:\n\n\nlog = logging.getLogger(__name__)\n\n_TYPE_TIMEOUT = typing.Union[Timeout, float, _TYPE_DEFAULT, None]\n\n_SelfT = typing.TypeVar(\"_SelfT\")\n\n\n# Pool objects\nclass ConnectionPool:\n \"\"\"\n Base class for all connection pools, such as\n :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.\n\n .. note::\n ConnectionPool.urlopen() does not normalize or percent-encode target URIs\n which is useful if your target server doesn't support percent-encoded\n target URIs.\n \"\"\"\n\n scheme: str | None = None\n QueueCls = queue.LifoQueue\n\n def __init__(self, host: str, port: int | None = None) -> None:\n if not host:\n raise LocationValueError(\"No host specified.\")\n\n self.host = _normalize_host(host, scheme=self.scheme)\n self.port = port\n\n # This property uses 'normalize_host()' (not '_normalize_host()')\n # to avoid removing square braces around IPv6 addresses.\n # This value is sent to `HTTPConnection.set_tunnel()` if called\n # because square braces are required for HTTP CONNECT tunneling.\n self._tunnel_host = normalize_host(host, scheme=self.scheme).lower()\n\n def __str__(self) -> str:\n return f\"{type(self).__name__}(host={self.host!r}, port={self.port!r})\"\n\n def __enter__(self: _SelfT) -> _SelfT:\n return self\n\n def __exit__(\n self,\n exc_type: type[BaseException] | None,\n exc_val: BaseException | None,\n exc_tb: TracebackType | None,\n ) -> Literal[False]:\n self.close()\n # Return False to re-raise any potential exceptions\n return False\n\n def close(self) -> None:\n \"\"\"\n Close all pooled connections and disable the pool.\n \"\"\"\n\n\n# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252\n_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK}\n\n\n"},"all_code":{"kind":"string","value":"from __future__ import annotations\n\n\n\nif typing.TYPE_CHECKING:\n\n\nlog = logging.getLogger(__name__)\n\n_TYPE_TIMEOUT = typing.Union[Timeout, float, _TYPE_DEFAULT, None]\n\n_SelfT = typing.TypeVar(\"_SelfT\")\n\n\n# Pool objects\nclass ConnectionPool:\n \"\"\"\n Base class for all connection pools, such as\n :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.\n\n .. note::\n ConnectionPool.urlopen() does not normalize or percent-encode target URIs\n which is useful if your target server doesn't support percent-encoded\n target URIs.\n \"\"\"\n\n scheme: str | None = None\n QueueCls = queue.LifoQueue\n\n def __init__(self, host: str, port: int | None = None) -> None:\n if not host:\n raise LocationValueError(\"No host specified.\")\n\n self.host = _normalize_host(host, scheme=self.scheme)\n self.port = port\n\n # This property uses 'normalize_host()' (not '_normalize_host()')\n # to avoid removing square braces around IPv6 addresses.\n # This value is sent to `HTTPConnection.set_tunnel()` if called\n # because square braces are required for HTTP CONNECT tunneling.\n self._tunnel_host = normalize_host(host, scheme=self.scheme).lower()\n\n def __str__(self) -> str:\n return f\"{type(self).__name__}(host={self.host!r}, port={self.port!r})\"\n\n def __enter__(self: _SelfT) -> _SelfT:\n return self\n\n def __exit__(\n self,\n exc_type: type[BaseException] | None,\n exc_val: BaseException | None,\n exc_tb: TracebackType | None,\n ) -> Literal[False]:\n self.close()\n # Return False to re-raise any potential exceptions\n return False\n\n def close(self) -> None:\n \"\"\"\n Close all pooled connections and disable the pool.\n \"\"\"\n\n\n# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252\n_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK}\n\n"},"next_line":{"kind":"string","value":"class HTTPConnectionPool(ConnectionPool, RequestMethods):"},"gold_snippet_index":{"kind":"number","value":2,"string":"2"},"created_at":{"kind":"string","value":"2023-12-16 04:12:01+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5993,"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":14678,"string":"14,678"},"cropped_code":{"kind":"string","value":"\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"},"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:"},"next_line":{"kind":"string","value":" progress_bar = tqdm(total=len(scene_list) * num_images, unit='images', dynamic_ncols=True)"},"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":5994,"cells":{"repo_name":{"kind":"string","value":"EulerSearch/embedding_studio"},"file_path":{"kind":"string","value":"embedding_studio/embeddings/training/embeddings_finetuner.py"},"context":{"kind":"list like","value":[{"identifier":"QueryRetriever","path":"embedding_studio/embeddings/data/clickstream/query_retriever.py","snippet":"class QueryRetriever(object):\n \"\"\"As we can't exactly predict a schema of storing queries:\n 1. As text exceptly in clickstream service\n 2. As ID of a record with a text\n 3. As a path to an image\n\n We provide an ability to use any query item. So, a user can specify any.\n\n \"\"\"\n\n def setup(self, clickstream_sessions: List[ClickstreamSession]):\n pass\n\n def __call__(self, query: QueryItem):\n return query"},{"identifier":"ClickstreamSession","path":"embedding_studio/embeddings/data/clickstream/raw_session.py","snippet":"class RawClickstreamSession(BaseModel):\n class Config:\n def __init__(self, **data):\n def __len__(self) -> int:\n def from_mongo(\n cls,\n session: SessionWithEvents,\n query_item_type: type,\n search_result_type: type,\n item_type: type,\n event_type: type,\n ) -> \"RawClickstreamSession\":\n def from_dict(\n cls,\n data: dict,\n query_item_type: type,\n search_result_type: type,\n item_type: type,\n event_type: type,\n ) -> \"RawClickstreamSession\":\n def get_session(self) -> ClickstreamSession:"},{"identifier":"dummy_confidences","path":"embedding_studio/embeddings/features/event_confidences.py","snippet":"@torch.no_grad()\ndef dummy_confidences(\n ranks: FloatTensor, events: Tensor\n) -> Union[Tensor, FloatTensor]:\n \"\"\"Confidence = 1.0\n\n :param ranks: list of ranks from search results\n :param events: list of 0 if it's not an event, 1 if it's an event\n :return: list of confidences\n \"\"\"\n return torch.ones(len(events))"},{"identifier":"COSINE_SIMILARITY","path":"embedding_studio/embeddings/features/extractor.py","snippet":"COSINE_SIMILARITY = torch.nn.CosineSimilarity(dim=1, eps=1e-6)"},{"identifier":"FeaturesExtractor","path":"embedding_studio/embeddings/features/extractor.py","snippet":"class FeaturesExtractor(pl.LightningModule):\n def __init__(\n self,\n model: EmbeddingsModelInterface,\n ranker: Optional[\n Callable[[FloatTensor, FloatTensor], FloatTensor]\n ] = COSINE_SIMILARITY,\n is_similarity: Optional[bool] = True,\n not_irrelevant_only: Optional[bool] = True,\n negative_downsampling_factor: Optional[float] = 1.0,\n min_abs_difference_threshold: Optional[float] = 0.0,\n max_abs_difference_threshold: Optional[float] = 1.0,\n confidence_calculator: Optional[Callable] = dummy_confidences,\n exmaples_order: Optional[List[ExamplesType]] = None,\n ):\n \"\"\"Logic of extracting features:\n 1. Positive and negative examples ranks\n 2. Event confidences\n 3. Target: 1 if is_similarity else -1\n\n and pack it in SessionFeatures object.\n\n :param model: embedding model itself\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 not_irrelevant_only: use only not irrelevant sessions (default: True)\n True - Triplet loss\n False - Contrastive-like loss\n :param negative_downsampling_factor: in real tasks amount of results is much larger than not-results,\n use this parameters to fix a balance (default: 0.5)\n :param min_abs_difference_threshold: filter out soft pairs abs(neg_dist - pos_dist) < small value\n :param max_abs_difference_threshold: filter out hard pairs abs(neg_dist - pos_dist) > huge value\n :param confidence_calculator: function to calculate results confidences (default: dummy_confidences)\n :param examples_order: order of passing examples to a trainer (default: None)\n \"\"\"\n super(FeaturesExtractor, self).__init__()\n # Check model type\n if not isinstance(model, EmbeddingsModelInterface):\n raise ValueError(\n \"Model must be an instance of EmbeddingsModelInterface.\"\n )\n self.model = model\n\n # Check ranker type and value\n if not callable(ranker):\n raise ValueError(\"Ranker must be a callable function.\")\n self.ranker = ranker\n\n # Check is_similarity type\n if not isinstance(is_similarity, bool):\n raise ValueError(\"is_similarity must be a boolean.\")\n self.is_similarity = is_similarity\n\n # Check not_irrelevant_only type\n if not isinstance(not_irrelevant_only, bool):\n raise ValueError(\"not_irrelevant_only must be a boolean.\")\n self.not_irrelevant_only = not_irrelevant_only\n\n # TODO: use pydantic models here\n if (\n not isinstance(negative_downsampling_factor, float)\n or negative_downsampling_factor < 0.0\n or negative_downsampling_factor >= 1\n ):\n raise ValueError(\n \"negative downsampling factor should be un range (0.0, 1.0)\"\n )\n self.negative_donwsampling_factor = negative_downsampling_factor\n\n if (\n not isinstance(min_abs_difference_threshold, float)\n or min_abs_difference_threshold < 0.0\n ):\n raise ValueError(\n \"min_abs_difference_threshold should be positive numeric\"\n )\n self.min_abs_difference_threshold = min_abs_difference_threshold\n if (\n not isinstance(max_abs_difference_threshold, float)\n or max_abs_difference_threshold <= 0.0\n ):\n raise ValueError(\n \"max_abs_difference_threshold should be positive numeric\"\n )\n self.max_abs_difference_threshold = max_abs_difference_threshold\n self.confidence_calculator = confidence_calculator\n\n if not exmaples_order:\n exmaples_order = [ExamplesType.all_examples]\n logger.debug(\"All types of examples will be used in training\")\n\n if len({isinstance(e, ExamplesType) for e in exmaples_order}) > 1:\n raise ValueError(\n \"Some of exmaple types are not instances of ExampleType\"\n )\n self.exmaples_order = (\n exmaples_order # TODO: use different examples order\n )\n\n def _confidences(\n self, session: ClickstreamSession, not_events: List[str]\n ) -> Tuple[Tensor, Tensor]:\n \"\"\"Calculate confidences for a given clickstream session items.\n\n :param session: provided clickstream session\n :param not_events: not-results (negatives) used for ranks prediction\n :return: positive (results) confidences, negative (not-results) confidences\n \"\"\"\n only_used: List[bool] = [\n (id_ in session.events or id_ in not_events)\n for id_ in session.results\n ]\n only_used_ids: List[str] = [\n id_\n for id_ in session.results\n if (id_ in session.events or id_ in not_events)\n ]\n ranks: FloatTensor = FloatTensor(\n [session.ranks[i] for i in session.results]\n )\n bin_clicks: FloatTensor = FloatTensor(\n [(1 if i in session.events else 0) for i in session.results]\n )\n confidences: FloatTensor = self.confidence_calculator(\n ranks, bin_clicks\n )[only_used]\n\n # Sort confidences among positive and negative types\n positive_confidences: Tensor = torch.zeros(len(session.events))\n negative_confidences: Tensor = torch.zeros(len(not_events))\n\n for id_index, id_ in enumerate(only_used_ids):\n if id_ in session.events:\n positive_confidences[session.events.index(id_)] = confidences[\n id_index\n ]\n\n elif id_ in not_events:\n negative_confidences[not_events.index(id_)] = confidences[\n id_index\n ]\n\n return positive_confidences.to(self.device), negative_confidences.to(\n self.device\n )\n\n @torch.no_grad()\n def calculate_ranks(\n self,\n session: ClickstreamSession,\n dataset: ItemsStorage,\n query_retriever: QueryRetriever,\n ) -> Dict[str, float]:\n \"\"\"Calculate ranks for a single session\n\n :param session: given session\n :param dataset: items storage related to a given session\n :param query_retriever: object to get item related to query, that can be used in \"forward\"\n :return: provided session's results ranks\n \"\"\"\n query_vector: FloatTensor = self.model.forward_query(\n query_retriever(session.query)\n )\n items_vectors: FloatTensor = self.model.forward_items(\n dataset.items_by_ids(session.results)\n )\n ranks_: FloatTensor = self.ranker(query_vector, items_vectors)\n ranks = dict()\n for id_, rank in zip(session.results, ranks_.cpu().tolist()):\n ranks[id_] = rank\n\n return ranks\n\n def _get_session_features(\n self,\n session: ClickstreamSession,\n dataset: ItemsStorage,\n query_retriever: QueryRetriever,\n ) -> SessionFeatures:\n \"\"\"Calculate features for a single session\n\n :param session: given session\n :param dataset: items storage related to a given session\n :param query_retriever: object to get item related to query, that can be used in \"forward\"\n :return: provided session's features\n \"\"\"\n features = SessionFeatures()\n\n # For keep balance between results and not-results, we decrease a number of not-results\n not_events_count: int = int(\n self.negative_donwsampling_factor * len(session.not_events)\n )\n not_events_indexes: List[int] = random.choices(\n list(range(len(session.not_events))), k=not_events_count\n ) # we use indexes instead of ids to keep order\n not_events: List[str] = [\n session.not_events[i] for i in sorted(not_events_indexes)\n ]\n\n # And calculate confidences for two groups of items\n (\n features.positive_confidences,\n features.negative_confidences,\n ) = self._confidences(session, not_events)\n\n # Then we calculate query and items vectors\n query_vector: FloatTensor = self.model.forward_query(\n query_retriever(session.query)\n )\n items_vectors: FloatTensor = self.model.forward_items(\n dataset.items_by_ids(session.events + not_events)\n )\n\n positive_indexes: List[int] = [i for i in range(len(session.events))]\n negative_indexes: List[int] = [\n i + len(session.events) for i in range(len(not_events))\n ]\n\n # For each group we calculate ranks\n positive_ranks_: FloatTensor = self.ranker(\n query_vector, items_vectors[positive_indexes]\n )\n negative_ranks_: FloatTensor = self.ranker(\n query_vector, items_vectors[negative_indexes]\n )\n\n if len(positive_indexes) > 0:\n positive_idx = []\n negatie_idx = []\n for pos_i_ in positive_indexes:\n for neg_i_ in negative_indexes:\n pos_i = pos_i_\n neg_i = neg_i_ - len(session.events)\n positive_idx.append(pos_i)\n negatie_idx.append(neg_i)\n\n features.positive_ranks = positive_ranks_[positive_idx]\n features.negative_ranks = negative_ranks_[negatie_idx]\n\n features.positive_confidences = features.positive_confidences[\n positive_idx\n ]\n features.negative_confidences = features.negative_confidences[\n negatie_idx\n ]\n\n else:\n features.negative_distances = negative_ranks_\n\n target_value: int = 1 if self.is_similarity else -1\n features.target = target_value * torch.ones(\n features.negative_confidences.shape[0]\n ).to(self.device)\n\n # Filter out noises\n features.clamp_diff_in(\n self.min_abs_difference_threshold,\n self.max_abs_difference_threshold,\n )\n\n return features\n\n def _get_paired_sessions_features(\n self,\n not_irrelevant_session: ClickstreamSession,\n irrelevant_session: ClickstreamSession,\n dataset: ItemsStorage,\n query_retriever: QueryRetriever,\n ) -> SessionFeatures:\n \"\"\"Calculate features for a given pair: irrelevant and not irrelevant sessions\n\n :param not_irrelevant_session: not-irrelevant session\n :param irrelevant_session: irrelevant session\n :param dataset: storage of items related to clickstream sessions\n :param query_retriever: object to get item related to query, that can be used in \"forward\"\n :return: features related for both irrelevant and not irrelevant sessions\n \"\"\"\n not_irrelevant_features: SessionFeatures = self._get_session_features(\n not_irrelevant_session, dataset, query_retriever\n )\n irrelevant_features: SessionFeatures = self._get_session_features(\n irrelevant_session, dataset, query_retriever\n )\n\n irrelevant_features.use_positive_from(not_irrelevant_features)\n\n not_irrelevant_features += irrelevant_features\n\n return not_irrelevant_features\n\n def forward(\n self,\n batch: List[Tuple[ClickstreamSession, ClickstreamSession]],\n dataset: ItemsStorage,\n query_retriever: QueryRetriever,\n ) -> SessionFeatures:\n \"\"\"Calculate features for a given batch of pairs: irrelevant and not irrelevant sessions\n\n :param batch: list of pairs: irrelevant and not irrelevant sessions\n :param dataset: storage of items related to clickstream sessions\n :param query_retriever: object to get item related to query, that can be used in \"forward\"\n :return: session features related to a given batch\n \"\"\"\n features = SessionFeatures()\n\n for not_irrelevant_session, irrelevant_session in batch:\n if len(not_irrelevant_session.events) == 0:\n logger.warning(\"Not irrelevant session has no results\")\n continue\n\n if (\n irrelevant_session is not None and len(irrelevant_session) > 0\n ) and not self.not_irrelevant_only:\n features += self._get_paired_sessions_features(\n not_irrelevant_session,\n irrelevant_session,\n dataset,\n query_retriever,\n )\n\n else:\n features += self._get_session_features(\n not_irrelevant_session, dataset, query_retriever\n )\n\n return features"},{"identifier":"SessionFeatures","path":"embedding_studio/embeddings/features/session_features.py","snippet":"class SessionFeatures:\n def __init__(\n self,\n positive_ranks: Optional[FloatTensor] = None,\n negative_ranks: Optional[FloatTensor] = None,\n target: Optional[Tensor] = None,\n positive_confidences: Optional[FloatTensor] = None,\n negative_confidences: Optional[FloatTensor] = None,\n ):\n \"\"\"Extracted features of clickstream session using embeddings.\n\n :param positive_ranks: ranks of positive results\n :param negative_ranks: ranks of negative results\n :param target: if target == 1 ranks are similarities, if target == -1 ranks are distances\n :param positive_confidences: confidences of positive results (like clicks)\n :param negative_confidences: confidences of not positive results\n \"\"\"\n\n self._positive_ranks = positive_ranks\n self._negative_ranks = negative_ranks\n self._target = target\n self._positive_confidences = positive_confidences\n self._negative_confidences = negative_confidences\n self._check_types()\n self._check_lengths()\n\n def _check_types(self):\n if self.positive_ranks is not None and not isinstance(\n self.positive_ranks, torch.Tensor\n ):\n raise TypeError(\"positive_ranks must be a torch.Tensor or None\")\n if self.negative_ranks is not None and not isinstance(\n self.negative_ranks, torch.Tensor\n ):\n raise TypeError(\"negative_ranks must be a torch.Tensor or None\")\n if self.target is not None and not isinstance(\n self.target, torch.Tensor\n ):\n raise TypeError(\"target must be a torch.Tensor or None\")\n if self.positive_confidences is not None and not isinstance(\n self.positive_confidences, torch.Tensor\n ):\n raise TypeError(\n \"positive_confidences must be a torch.Tensor or None\"\n )\n if self.negative_confidences is not None and not isinstance(\n self.negative_confidences, torch.Tensor\n ):\n raise TypeError(\n \"negative_confidences must be a torch.Tensor or None\"\n )\n\n def _check_lengths(self):\n length_set = {\n len(x)\n for x in [\n self.positive_ranks,\n self.negative_ranks,\n self.target,\n self.positive_confidences,\n self.negative_confidences,\n ]\n if x is not None\n }\n if len(length_set) > 1:\n raise ValueError(\n \"All non-None parameters must have the same length\"\n )\n\n @property\n def positive_ranks(self) -> Optional[FloatTensor]:\n return self._positive_ranks\n\n @positive_ranks.setter\n def positive_ranks(self, value: Optional[FloatTensor]):\n self._positive_ranks = value\n self._check_types()\n\n @property\n def negative_ranks(self) -> Optional[FloatTensor]:\n return self._negative_ranks\n\n @negative_ranks.setter\n def negative_ranks(self, value: Optional[FloatTensor]):\n self._negative_ranks = value\n self._check_types()\n\n @property\n def target(self) -> Optional[Tensor]:\n return self._target\n\n @target.setter\n def target(self, value: Optional[Tensor]):\n self._target = value\n self._check_types()\n\n @property\n def positive_confidences(self) -> Optional[FloatTensor]:\n return self._positive_confidences\n\n @positive_confidences.setter\n def positive_confidences(self, value: Optional[FloatTensor]):\n self._positive_confidences = value\n self._check_types()\n\n @property\n def negative_confidences(self) -> Optional[FloatTensor]:\n return self._negative_confidences\n\n @negative_confidences.setter\n def negative_confidences(self, value: Optional[FloatTensor]):\n self._negative_confidences = value\n self._check_types()\n\n def _accumulate(self_var: Tensor, other_var: Tensor):\n if self_var is not None and other_var is not None:\n return torch.cat([self_var, other_var])\n elif other_var is not None:\n return other_var\n\n def __iadd__(self, other):\n \"\"\"Accumulate features from another session\n\n :param other: other session\n :return: aggregates features\n \"\"\"\n\n self._positive_ranks = SessionFeatures._accumulate(\n self._positive_ranks, other._positive_ranks\n )\n self._negative_ranks = SessionFeatures._accumulate(\n self._negative_ranks, other._negative_ranks\n )\n self._target = SessionFeatures._accumulate(self._target, other._target)\n self._positive_confidences = SessionFeatures._accumulate(\n self._positive_confidences, other._positive_confidences\n )\n self._negative_confidences = SessionFeatures._accumulate(\n self._negative_confidences, other._negative_confidences\n )\n\n self._check_types()\n self._check_lengths()\n return self\n\n def clamp_diff_in(self, min: float, max: float):\n \"\"\"Filter min < |positive_ranks - negative_ranks| < max examples.\n\n :param min: minimal difference between pos and neg ranks\n :param max: maximal difference between pos and neg ranks\n \"\"\"\n if (\n self._positive_ranks is not None\n and self._negative_ranks is not None\n ):\n hard_examples: Tensor = (\n torch.abs(self._positive_ranks - self._negative_ranks) > min\n )\n smooth_examples: Tensor = (\n torch.abs(self._positive_ranks - self._negative_ranks) < max\n )\n examples: Tensor = torch.logical_and(\n hard_examples, smooth_examples\n )\n\n self._positive_ranks = self._positive_ranks[examples]\n self._negative_ranks = self._negative_ranks[examples]\n self._target = self._target[examples]\n self._positive_confidences = self._positive_confidences[examples]\n self._negative_confidences = self._negative_confidences[examples]\n self._check_lengths()\n\n def use_positive_from(self, other):\n \"\"\"If session is fully irrelevant, to use positive pairs from another session.\n This way \"triple loss\" becomes \"contrastive\"\n\n :param other: not irrelevant session with positive evidences\n \"\"\"\n other._check_types()\n other._check_lengths()\n\n if self._negative_ranks.shape[0] < other._positive_ranks.shape[0]:\n positive_ranks_: FloatTensor = other._positive_ranks[\n : self._negative_ranks.shape[0]\n ]\n elif self._negative_ranks.shape[0] > other._positive_ranks.shape[0]:\n self._negative_ranks = self._negative_ranks[\n : other._positive_ranks.shape[0]\n ]\n self._target = self._target[: other._positive_ranks.shape[0]]\n self._negative_confidences = self._negative_confidences[\n : other._positive_ranks.shape[0]\n ]\n positive_ranks_: FloatTensor = other._positive_ranks\n else:\n positive_ranks_: FloatTensor = other._positive_ranks\n\n self._positive_confidences = other._positive_ranks\n self._positive_ranks = positive_ranks_\n\n self._check_types()\n self._check_lengths()"},{"identifier":"RankingLossInterface","path":"embedding_studio/embeddings/losses/ranking_loss_interface.py","snippet":"class RankingLossInterface(pl.LightningModule):\n @abstractmethod\n def __call__(self, features: SessionFeatures) -> FloatTensor:\n raise NotImplemented()"},{"identifier":"DistanceShift","path":"embedding_studio/embeddings/metrics/distance_shift.py","snippet":"class DistanceShift(MetricCalculator):\n def _calc_dist_shift(\n self,\n session: ClickstreamSession,\n extractor: FeaturesExtractor,\n items_storage: ItemsStorage,\n query_retriever: QueryRetriever,\n ) -> float:\n # TODO: encapsulate inference in one class / object\n query_vector: FloatTensor = extractor.model.forward_query(\n query_retriever(session.query)\n )\n items_vectors: FloatTensor = extractor.model.forward_items(\n items_storage.items_by_ids(session.events + session.not_events)\n )\n\n ranks: FloatTensor = (\n extractor.ranker(query_vector, items_vectors).cpu().tolist()\n )\n\n # for similarity ranks should be higher for results of not irrelevant sessions,\n # for distances should be vice versa\n target: int = 1 if extractor.is_similarity else -1\n compare = lambda prev, new: target * float(new - prev)\n results: List[str] = session.events\n if session.is_irrelevant:\n results = session.results\n compare = lambda prev, new: target * float(prev - new)\n\n return float(\n np.mean(\n [\n compare(session.ranks[id_], new_rank)\n for id_, new_rank in zip(results, ranks)\n ]\n )\n )\n\n @torch.no_grad()\n def __call__(\n self,\n batch: List[Tuple[ClickstreamSession, ClickstreamSession]],\n extractor: FeaturesExtractor,\n items_storage: ItemsStorage,\n query_retriever: QueryRetriever,\n ) -> List[MetricValue]:\n \"\"\"Calculate metric, that means how ranks of provided sessions were changed .\n\n :param batch: batch of pairs clickstream sessions (not_irrelevant, irrelevant)\n :param extractor: object to extract SessionFeatures out of provided sessions\n :param items_storage: items dataset\n :param query_retriever: how to retrieve a value related to session query\n :return: list of calculated not_irrelevant_dist_shift and irrelevant_dist_shift metrics\n \"\"\"\n not_irrelevenat_shifts: List[float] = []\n irrelevenat_shifts: List[float] = []\n for index, (not_irrelevenat_session, irrelevant_session) in enumerate(\n batch\n ):\n if not_irrelevenat_session is not None:\n not_irrelevenat_shifts.append(\n self._calc_dist_shift(\n not_irrelevenat_session,\n extractor,\n items_storage,\n query_retriever,\n )\n )\n\n if irrelevant_session is not None:\n irrelevenat_shifts.append(\n self._calc_dist_shift(\n irrelevant_session,\n extractor,\n items_storage,\n query_retriever,\n )\n )\n\n return [\n MetricValue(\n \"not_irrelevant_dist_shift\",\n float(np.mean(not_irrelevenat_shifts))\n if len(not_irrelevenat_shifts) > 0\n else 0.0,\n ),\n MetricValue(\n \"irrelevant_dist_shift\",\n float(np.mean(irrelevenat_shifts))\n if len(irrelevenat_shifts) > 0\n else 0.0,\n ),\n ]"},{"identifier":"MetricCalculator","path":"embedding_studio/embeddings/metrics/metric.py","snippet":"class MetricCalculator(ABC):\n \"\"\"Interface of metrics calculator\"\"\"\n\n @abstractmethod\n @torch.no_grad()\n def __call__(\n self,\n batch: List[Tuple[ClickstreamSession, ClickstreamSession]],\n extractor: FeaturesExtractor,\n items_storage: ItemsStorage,\n query_retriever: QueryRetriever,\n ) -> List[MetricValue]:\n \"\"\"Calculate abstract metric value over provided batch of items.\n\n :param batch: batch of pairs clickstream sessions (not_irrelevant, irrelevant)\n :param extractor: object to extract SessionFeatures out of provided sessions\n :param items_storage: items dataset\n :param query_retriever: how to retrieve a value related to session query\n :return: list of calculated metrics\n \"\"\""},{"identifier":"EmbeddingsModelInterface","path":"embedding_studio/embeddings/models/interface.py","snippet":"class EmbeddingsModelInterface(pl.LightningModule):\n def __init__(self, same_query_and_items: bool = False):\n \"\"\"In search we have two entities, which could be multi domain: query and search result (item).\n This is the interface we used in fine-tuning procedure.\n\n :param same_query_and_items: are query and items models acutally the same model (default: False)\n \"\"\"\n super(EmbeddingsModelInterface, self).__init__()\n self.same_query_and_items = same_query_and_items\n\n @abstractmethod\n def get_query_model_params(self) -> Iterator[Parameter]:\n pass\n\n @abstractmethod\n def get_items_model_params(self) -> Iterator[Parameter]:\n pass\n\n @abstractmethod\n def fix_query_model(self, num_fixed_layers: int):\n \"\"\"One of fine-tuning hyperparams is num of fixed layers at a query model\n\n :param num_fixed_layers: how many layers to fix\n \"\"\"\n\n @abstractmethod\n def unfix_query_model(self):\n \"\"\"Unfix all layers of a query model.\"\"\"\n\n @abstractmethod\n def fix_item_model(self, num_fixed_layers: int):\n \"\"\"One of fine-tuning hyperparams is num of fixed layers at an item model\n\n :param num_fixed_layers: how many layers to fix\n \"\"\"\n\n @abstractmethod\n def unfix_item_model(self):\n \"\"\"Unfix all layers of an item model.\"\"\"\n\n @abstractmethod\n def forward_query(self, query: Any) -> FloatTensor:\n pass\n\n @abstractmethod\n def forward_items(self, items: List[Any]) -> FloatTensor:\n pass"},{"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":"FineTuningParams","path":"embedding_studio/workers/fine_tuning/experiments/finetuning_params.py","snippet":"class FineTuningParams(BaseModel):\n \"\"\"Params of fine-tuning procedure\n\n :param num_fixed_layers: number of fixed embeddings layers\n :param query_lr: learning rate of query model optimizer\n :param items_lr: learning rate of items model optimizer\n :param query_weight_decay: weight decay of query model optimizer\n :param items_weight_decay: weight decay of items model optimizer\n :param margin: margin from MarginRankingLoss\n :param not_irrelevant_only: use only not irrelevant sessions\n :param negative_downsampling: ratio of negative samples to be used\n :param min_abs_difference_threshold: filter out soft pairs abs(neg_dist - pos_dist) < small value (default: 0.0)\n :param max_abs_difference_threshold: filter out hard pairs abs(neg_dist - pos_dist) > huge value (default: 1.0)\n :param examples_order: order of passing examples to a trainer (default: None)\n \"\"\"\n\n num_fixed_layers: int\n query_lr: float\n items_lr: float\n query_weight_decay: float\n items_weight_decay: float\n margin: float\n not_irrelevant_only: bool\n negative_downsampling: float\n min_abs_difference_threshold: float = 0.0\n max_abs_difference_threshold: float = 1.0\n examples_order: List[ExamplesType] = [ExamplesType.all_examples]\n\n class Config:\n arbitrary_types_allowed = True\n\n @validator(\"examples_order\", pre=True, always=True)\n def validate_examples_order(cls, value):\n if isinstance(value, str):\n value = list(map(int, value.split(\",\")))\n elif isinstance(value, tuple):\n value = list(value)\n return [ExamplesType(v) for v in value]\n\n @validator(\"items_lr\", \"query_lr\", pre=True, always=True)\n def validate_positive_float(cls, value):\n if not (isinstance(value, float) and value > 0):\n raise ValueError(f\"{value} must be a positive float\")\n return value\n\n @validator(\n \"items_weight_decay\", \"query_weight_decay\", pre=True, always=True\n )\n def validate_non_negative_float(cls, value):\n if not (isinstance(value, float) and value >= 0):\n raise ValueError(f\"{value} must be a non-negative float\")\n return value\n\n @validator(\"margin\", pre=True, always=True)\n def validate_non_negative_float_margin(cls, value):\n if not (isinstance(value, float) and value >= 0):\n raise ValueError(f\"{value} must be a non-negative float\")\n return value\n\n @validator(\"num_fixed_layers\", pre=True, always=True)\n def validate_non_negative_int(cls, value):\n if not (isinstance(value, int) and value >= 0):\n raise ValueError(f\"{value} must be a non-negative integer\")\n return value\n\n @root_validator(skip_on_failure=True)\n def validate_example_order(cls, values):\n examples_order = values.get(\"examples_order\")\n if examples_order:\n if isinstance(examples_order, str):\n examples_order = list(map(int, examples_order.split(\",\")))\n elif isinstance(examples_order, tuple):\n examples_order = list(examples_order)\n values[\"examples_order\"] = [\n ExamplesType(v) for v in examples_order\n ]\n return values\n\n @property\n def id(self) -> str:\n # Convert the value to bytes (assuming it's a string)\n value_bytes: bytes = str(self).encode(\"utf-8\")\n\n # Create a hash object\n hash_object = hashlib.sha256()\n\n # Update the hash object with the value\n hash_object.update(value_bytes)\n\n # Get the hexadecimal representation of the hash\n unique_id: str = hash_object.hexdigest()\n\n return unique_id\n\n def __str__(self) -> str:\n vals: List[str] = []\n for key, value in sorted(dict(self).items()):\n value = (\n \",\".join(map(str, value)) if isinstance(value, list) else value\n )\n vals.append(f\"{key}: {value}\")\n\n return \" / \".join(vals)"},{"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":"MetricValue","path":"embedding_studio/workers/fine_tuning/experiments/metrics_accumulator.py","snippet":"class MetricValue:\n def __init__(self, name: str, value: float):\n if not isinstance(name, str) or len(name) == 0:\n raise ValueError(\"MetricValue's name should not be empty\")\n self._name = name\n\n if not isinstance(value, float):\n raise ValueError(\"MetricValue's value should not be numeric\")\n self._value = value\n\n @property\n def name(self) -> str:\n return self._name\n\n @property\n def value(self) -> float:\n return self._value\n\n def add_prefix(self, prefix: str):\n self._name = f\"{prefix}_{self._name}\"\n return self"}],"string":"[\n {\n \"identifier\": \"QueryRetriever\",\n \"path\": \"embedding_studio/embeddings/data/clickstream/query_retriever.py\",\n \"snippet\": \"class QueryRetriever(object):\\n \\\"\\\"\\\"As we can't exactly predict a schema of storing queries:\\n 1. As text exceptly in clickstream service\\n 2. As ID of a record with a text\\n 3. As a path to an image\\n\\n We provide an ability to use any query item. So, a user can specify any.\\n\\n \\\"\\\"\\\"\\n\\n def setup(self, clickstream_sessions: List[ClickstreamSession]):\\n pass\\n\\n def __call__(self, query: QueryItem):\\n return query\"\n },\n {\n \"identifier\": \"ClickstreamSession\",\n \"path\": \"embedding_studio/embeddings/data/clickstream/raw_session.py\",\n \"snippet\": \"class RawClickstreamSession(BaseModel):\\n class Config:\\n def __init__(self, **data):\\n def __len__(self) -> int:\\n def from_mongo(\\n cls,\\n session: SessionWithEvents,\\n query_item_type: type,\\n search_result_type: type,\\n item_type: type,\\n event_type: type,\\n ) -> \\\"RawClickstreamSession\\\":\\n def from_dict(\\n cls,\\n data: dict,\\n query_item_type: type,\\n search_result_type: type,\\n item_type: type,\\n event_type: type,\\n ) -> \\\"RawClickstreamSession\\\":\\n def get_session(self) -> ClickstreamSession:\"\n },\n {\n \"identifier\": \"dummy_confidences\",\n \"path\": \"embedding_studio/embeddings/features/event_confidences.py\",\n \"snippet\": \"@torch.no_grad()\\ndef dummy_confidences(\\n ranks: FloatTensor, events: Tensor\\n) -> Union[Tensor, FloatTensor]:\\n \\\"\\\"\\\"Confidence = 1.0\\n\\n :param ranks: list of ranks from search results\\n :param events: list of 0 if it's not an event, 1 if it's an event\\n :return: list of confidences\\n \\\"\\\"\\\"\\n return torch.ones(len(events))\"\n },\n {\n \"identifier\": \"COSINE_SIMILARITY\",\n \"path\": \"embedding_studio/embeddings/features/extractor.py\",\n \"snippet\": \"COSINE_SIMILARITY = torch.nn.CosineSimilarity(dim=1, eps=1e-6)\"\n },\n {\n \"identifier\": \"FeaturesExtractor\",\n \"path\": \"embedding_studio/embeddings/features/extractor.py\",\n \"snippet\": \"class FeaturesExtractor(pl.LightningModule):\\n def __init__(\\n self,\\n model: EmbeddingsModelInterface,\\n ranker: Optional[\\n Callable[[FloatTensor, FloatTensor], FloatTensor]\\n ] = COSINE_SIMILARITY,\\n is_similarity: Optional[bool] = True,\\n not_irrelevant_only: Optional[bool] = True,\\n negative_downsampling_factor: Optional[float] = 1.0,\\n min_abs_difference_threshold: Optional[float] = 0.0,\\n max_abs_difference_threshold: Optional[float] = 1.0,\\n confidence_calculator: Optional[Callable] = dummy_confidences,\\n exmaples_order: Optional[List[ExamplesType]] = None,\\n ):\\n \\\"\\\"\\\"Logic of extracting features:\\n 1. Positive and negative examples ranks\\n 2. Event confidences\\n 3. Target: 1 if is_similarity else -1\\n\\n and pack it in SessionFeatures object.\\n\\n :param model: embedding model itself\\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 not_irrelevant_only: use only not irrelevant sessions (default: True)\\n True - Triplet loss\\n False - Contrastive-like loss\\n :param negative_downsampling_factor: in real tasks amount of results is much larger than not-results,\\n use this parameters to fix a balance (default: 0.5)\\n :param min_abs_difference_threshold: filter out soft pairs abs(neg_dist - pos_dist) < small value\\n :param max_abs_difference_threshold: filter out hard pairs abs(neg_dist - pos_dist) > huge value\\n :param confidence_calculator: function to calculate results confidences (default: dummy_confidences)\\n :param examples_order: order of passing examples to a trainer (default: None)\\n \\\"\\\"\\\"\\n super(FeaturesExtractor, self).__init__()\\n # Check model type\\n if not isinstance(model, EmbeddingsModelInterface):\\n raise ValueError(\\n \\\"Model must be an instance of EmbeddingsModelInterface.\\\"\\n )\\n self.model = model\\n\\n # Check ranker type and value\\n if not callable(ranker):\\n raise ValueError(\\\"Ranker must be a callable function.\\\")\\n self.ranker = ranker\\n\\n # Check is_similarity type\\n if not isinstance(is_similarity, bool):\\n raise ValueError(\\\"is_similarity must be a boolean.\\\")\\n self.is_similarity = is_similarity\\n\\n # Check not_irrelevant_only type\\n if not isinstance(not_irrelevant_only, bool):\\n raise ValueError(\\\"not_irrelevant_only must be a boolean.\\\")\\n self.not_irrelevant_only = not_irrelevant_only\\n\\n # TODO: use pydantic models here\\n if (\\n not isinstance(negative_downsampling_factor, float)\\n or negative_downsampling_factor < 0.0\\n or negative_downsampling_factor >= 1\\n ):\\n raise ValueError(\\n \\\"negative downsampling factor should be un range (0.0, 1.0)\\\"\\n )\\n self.negative_donwsampling_factor = negative_downsampling_factor\\n\\n if (\\n not isinstance(min_abs_difference_threshold, float)\\n or min_abs_difference_threshold < 0.0\\n ):\\n raise ValueError(\\n \\\"min_abs_difference_threshold should be positive numeric\\\"\\n )\\n self.min_abs_difference_threshold = min_abs_difference_threshold\\n if (\\n not isinstance(max_abs_difference_threshold, float)\\n or max_abs_difference_threshold <= 0.0\\n ):\\n raise ValueError(\\n \\\"max_abs_difference_threshold should be positive numeric\\\"\\n )\\n self.max_abs_difference_threshold = max_abs_difference_threshold\\n self.confidence_calculator = confidence_calculator\\n\\n if not exmaples_order:\\n exmaples_order = [ExamplesType.all_examples]\\n logger.debug(\\\"All types of examples will be used in training\\\")\\n\\n if len({isinstance(e, ExamplesType) for e in exmaples_order}) > 1:\\n raise ValueError(\\n \\\"Some of exmaple types are not instances of ExampleType\\\"\\n )\\n self.exmaples_order = (\\n exmaples_order # TODO: use different examples order\\n )\\n\\n def _confidences(\\n self, session: ClickstreamSession, not_events: List[str]\\n ) -> Tuple[Tensor, Tensor]:\\n \\\"\\\"\\\"Calculate confidences for a given clickstream session items.\\n\\n :param session: provided clickstream session\\n :param not_events: not-results (negatives) used for ranks prediction\\n :return: positive (results) confidences, negative (not-results) confidences\\n \\\"\\\"\\\"\\n only_used: List[bool] = [\\n (id_ in session.events or id_ in not_events)\\n for id_ in session.results\\n ]\\n only_used_ids: List[str] = [\\n id_\\n for id_ in session.results\\n if (id_ in session.events or id_ in not_events)\\n ]\\n ranks: FloatTensor = FloatTensor(\\n [session.ranks[i] for i in session.results]\\n )\\n bin_clicks: FloatTensor = FloatTensor(\\n [(1 if i in session.events else 0) for i in session.results]\\n )\\n confidences: FloatTensor = self.confidence_calculator(\\n ranks, bin_clicks\\n )[only_used]\\n\\n # Sort confidences among positive and negative types\\n positive_confidences: Tensor = torch.zeros(len(session.events))\\n negative_confidences: Tensor = torch.zeros(len(not_events))\\n\\n for id_index, id_ in enumerate(only_used_ids):\\n if id_ in session.events:\\n positive_confidences[session.events.index(id_)] = confidences[\\n id_index\\n ]\\n\\n elif id_ in not_events:\\n negative_confidences[not_events.index(id_)] = confidences[\\n id_index\\n ]\\n\\n return positive_confidences.to(self.device), negative_confidences.to(\\n self.device\\n )\\n\\n @torch.no_grad()\\n def calculate_ranks(\\n self,\\n session: ClickstreamSession,\\n dataset: ItemsStorage,\\n query_retriever: QueryRetriever,\\n ) -> Dict[str, float]:\\n \\\"\\\"\\\"Calculate ranks for a single session\\n\\n :param session: given session\\n :param dataset: items storage related to a given session\\n :param query_retriever: object to get item related to query, that can be used in \\\"forward\\\"\\n :return: provided session's results ranks\\n \\\"\\\"\\\"\\n query_vector: FloatTensor = self.model.forward_query(\\n query_retriever(session.query)\\n )\\n items_vectors: FloatTensor = self.model.forward_items(\\n dataset.items_by_ids(session.results)\\n )\\n ranks_: FloatTensor = self.ranker(query_vector, items_vectors)\\n ranks = dict()\\n for id_, rank in zip(session.results, ranks_.cpu().tolist()):\\n ranks[id_] = rank\\n\\n return ranks\\n\\n def _get_session_features(\\n self,\\n session: ClickstreamSession,\\n dataset: ItemsStorage,\\n query_retriever: QueryRetriever,\\n ) -> SessionFeatures:\\n \\\"\\\"\\\"Calculate features for a single session\\n\\n :param session: given session\\n :param dataset: items storage related to a given session\\n :param query_retriever: object to get item related to query, that can be used in \\\"forward\\\"\\n :return: provided session's features\\n \\\"\\\"\\\"\\n features = SessionFeatures()\\n\\n # For keep balance between results and not-results, we decrease a number of not-results\\n not_events_count: int = int(\\n self.negative_donwsampling_factor * len(session.not_events)\\n )\\n not_events_indexes: List[int] = random.choices(\\n list(range(len(session.not_events))), k=not_events_count\\n ) # we use indexes instead of ids to keep order\\n not_events: List[str] = [\\n session.not_events[i] for i in sorted(not_events_indexes)\\n ]\\n\\n # And calculate confidences for two groups of items\\n (\\n features.positive_confidences,\\n features.negative_confidences,\\n ) = self._confidences(session, not_events)\\n\\n # Then we calculate query and items vectors\\n query_vector: FloatTensor = self.model.forward_query(\\n query_retriever(session.query)\\n )\\n items_vectors: FloatTensor = self.model.forward_items(\\n dataset.items_by_ids(session.events + not_events)\\n )\\n\\n positive_indexes: List[int] = [i for i in range(len(session.events))]\\n negative_indexes: List[int] = [\\n i + len(session.events) for i in range(len(not_events))\\n ]\\n\\n # For each group we calculate ranks\\n positive_ranks_: FloatTensor = self.ranker(\\n query_vector, items_vectors[positive_indexes]\\n )\\n negative_ranks_: FloatTensor = self.ranker(\\n query_vector, items_vectors[negative_indexes]\\n )\\n\\n if len(positive_indexes) > 0:\\n positive_idx = []\\n negatie_idx = []\\n for pos_i_ in positive_indexes:\\n for neg_i_ in negative_indexes:\\n pos_i = pos_i_\\n neg_i = neg_i_ - len(session.events)\\n positive_idx.append(pos_i)\\n negatie_idx.append(neg_i)\\n\\n features.positive_ranks = positive_ranks_[positive_idx]\\n features.negative_ranks = negative_ranks_[negatie_idx]\\n\\n features.positive_confidences = features.positive_confidences[\\n positive_idx\\n ]\\n features.negative_confidences = features.negative_confidences[\\n negatie_idx\\n ]\\n\\n else:\\n features.negative_distances = negative_ranks_\\n\\n target_value: int = 1 if self.is_similarity else -1\\n features.target = target_value * torch.ones(\\n features.negative_confidences.shape[0]\\n ).to(self.device)\\n\\n # Filter out noises\\n features.clamp_diff_in(\\n self.min_abs_difference_threshold,\\n self.max_abs_difference_threshold,\\n )\\n\\n return features\\n\\n def _get_paired_sessions_features(\\n self,\\n not_irrelevant_session: ClickstreamSession,\\n irrelevant_session: ClickstreamSession,\\n dataset: ItemsStorage,\\n query_retriever: QueryRetriever,\\n ) -> SessionFeatures:\\n \\\"\\\"\\\"Calculate features for a given pair: irrelevant and not irrelevant sessions\\n\\n :param not_irrelevant_session: not-irrelevant session\\n :param irrelevant_session: irrelevant session\\n :param dataset: storage of items related to clickstream sessions\\n :param query_retriever: object to get item related to query, that can be used in \\\"forward\\\"\\n :return: features related for both irrelevant and not irrelevant sessions\\n \\\"\\\"\\\"\\n not_irrelevant_features: SessionFeatures = self._get_session_features(\\n not_irrelevant_session, dataset, query_retriever\\n )\\n irrelevant_features: SessionFeatures = self._get_session_features(\\n irrelevant_session, dataset, query_retriever\\n )\\n\\n irrelevant_features.use_positive_from(not_irrelevant_features)\\n\\n not_irrelevant_features += irrelevant_features\\n\\n return not_irrelevant_features\\n\\n def forward(\\n self,\\n batch: List[Tuple[ClickstreamSession, ClickstreamSession]],\\n dataset: ItemsStorage,\\n query_retriever: QueryRetriever,\\n ) -> SessionFeatures:\\n \\\"\\\"\\\"Calculate features for a given batch of pairs: irrelevant and not irrelevant sessions\\n\\n :param batch: list of pairs: irrelevant and not irrelevant sessions\\n :param dataset: storage of items related to clickstream sessions\\n :param query_retriever: object to get item related to query, that can be used in \\\"forward\\\"\\n :return: session features related to a given batch\\n \\\"\\\"\\\"\\n features = SessionFeatures()\\n\\n for not_irrelevant_session, irrelevant_session in batch:\\n if len(not_irrelevant_session.events) == 0:\\n logger.warning(\\\"Not irrelevant session has no results\\\")\\n continue\\n\\n if (\\n irrelevant_session is not None and len(irrelevant_session) > 0\\n ) and not self.not_irrelevant_only:\\n features += self._get_paired_sessions_features(\\n not_irrelevant_session,\\n irrelevant_session,\\n dataset,\\n query_retriever,\\n )\\n\\n else:\\n features += self._get_session_features(\\n not_irrelevant_session, dataset, query_retriever\\n )\\n\\n return features\"\n },\n {\n \"identifier\": \"SessionFeatures\",\n \"path\": \"embedding_studio/embeddings/features/session_features.py\",\n \"snippet\": \"class SessionFeatures:\\n def __init__(\\n self,\\n positive_ranks: Optional[FloatTensor] = None,\\n negative_ranks: Optional[FloatTensor] = None,\\n target: Optional[Tensor] = None,\\n positive_confidences: Optional[FloatTensor] = None,\\n negative_confidences: Optional[FloatTensor] = None,\\n ):\\n \\\"\\\"\\\"Extracted features of clickstream session using embeddings.\\n\\n :param positive_ranks: ranks of positive results\\n :param negative_ranks: ranks of negative results\\n :param target: if target == 1 ranks are similarities, if target == -1 ranks are distances\\n :param positive_confidences: confidences of positive results (like clicks)\\n :param negative_confidences: confidences of not positive results\\n \\\"\\\"\\\"\\n\\n self._positive_ranks = positive_ranks\\n self._negative_ranks = negative_ranks\\n self._target = target\\n self._positive_confidences = positive_confidences\\n self._negative_confidences = negative_confidences\\n self._check_types()\\n self._check_lengths()\\n\\n def _check_types(self):\\n if self.positive_ranks is not None and not isinstance(\\n self.positive_ranks, torch.Tensor\\n ):\\n raise TypeError(\\\"positive_ranks must be a torch.Tensor or None\\\")\\n if self.negative_ranks is not None and not isinstance(\\n self.negative_ranks, torch.Tensor\\n ):\\n raise TypeError(\\\"negative_ranks must be a torch.Tensor or None\\\")\\n if self.target is not None and not isinstance(\\n self.target, torch.Tensor\\n ):\\n raise TypeError(\\\"target must be a torch.Tensor or None\\\")\\n if self.positive_confidences is not None and not isinstance(\\n self.positive_confidences, torch.Tensor\\n ):\\n raise TypeError(\\n \\\"positive_confidences must be a torch.Tensor or None\\\"\\n )\\n if self.negative_confidences is not None and not isinstance(\\n self.negative_confidences, torch.Tensor\\n ):\\n raise TypeError(\\n \\\"negative_confidences must be a torch.Tensor or None\\\"\\n )\\n\\n def _check_lengths(self):\\n length_set = {\\n len(x)\\n for x in [\\n self.positive_ranks,\\n self.negative_ranks,\\n self.target,\\n self.positive_confidences,\\n self.negative_confidences,\\n ]\\n if x is not None\\n }\\n if len(length_set) > 1:\\n raise ValueError(\\n \\\"All non-None parameters must have the same length\\\"\\n )\\n\\n @property\\n def positive_ranks(self) -> Optional[FloatTensor]:\\n return self._positive_ranks\\n\\n @positive_ranks.setter\\n def positive_ranks(self, value: Optional[FloatTensor]):\\n self._positive_ranks = value\\n self._check_types()\\n\\n @property\\n def negative_ranks(self) -> Optional[FloatTensor]:\\n return self._negative_ranks\\n\\n @negative_ranks.setter\\n def negative_ranks(self, value: Optional[FloatTensor]):\\n self._negative_ranks = value\\n self._check_types()\\n\\n @property\\n def target(self) -> Optional[Tensor]:\\n return self._target\\n\\n @target.setter\\n def target(self, value: Optional[Tensor]):\\n self._target = value\\n self._check_types()\\n\\n @property\\n def positive_confidences(self) -> Optional[FloatTensor]:\\n return self._positive_confidences\\n\\n @positive_confidences.setter\\n def positive_confidences(self, value: Optional[FloatTensor]):\\n self._positive_confidences = value\\n self._check_types()\\n\\n @property\\n def negative_confidences(self) -> Optional[FloatTensor]:\\n return self._negative_confidences\\n\\n @negative_confidences.setter\\n def negative_confidences(self, value: Optional[FloatTensor]):\\n self._negative_confidences = value\\n self._check_types()\\n\\n def _accumulate(self_var: Tensor, other_var: Tensor):\\n if self_var is not None and other_var is not None:\\n return torch.cat([self_var, other_var])\\n elif other_var is not None:\\n return other_var\\n\\n def __iadd__(self, other):\\n \\\"\\\"\\\"Accumulate features from another session\\n\\n :param other: other session\\n :return: aggregates features\\n \\\"\\\"\\\"\\n\\n self._positive_ranks = SessionFeatures._accumulate(\\n self._positive_ranks, other._positive_ranks\\n )\\n self._negative_ranks = SessionFeatures._accumulate(\\n self._negative_ranks, other._negative_ranks\\n )\\n self._target = SessionFeatures._accumulate(self._target, other._target)\\n self._positive_confidences = SessionFeatures._accumulate(\\n self._positive_confidences, other._positive_confidences\\n )\\n self._negative_confidences = SessionFeatures._accumulate(\\n self._negative_confidences, other._negative_confidences\\n )\\n\\n self._check_types()\\n self._check_lengths()\\n return self\\n\\n def clamp_diff_in(self, min: float, max: float):\\n \\\"\\\"\\\"Filter min < |positive_ranks - negative_ranks| < max examples.\\n\\n :param min: minimal difference between pos and neg ranks\\n :param max: maximal difference between pos and neg ranks\\n \\\"\\\"\\\"\\n if (\\n self._positive_ranks is not None\\n and self._negative_ranks is not None\\n ):\\n hard_examples: Tensor = (\\n torch.abs(self._positive_ranks - self._negative_ranks) > min\\n )\\n smooth_examples: Tensor = (\\n torch.abs(self._positive_ranks - self._negative_ranks) < max\\n )\\n examples: Tensor = torch.logical_and(\\n hard_examples, smooth_examples\\n )\\n\\n self._positive_ranks = self._positive_ranks[examples]\\n self._negative_ranks = self._negative_ranks[examples]\\n self._target = self._target[examples]\\n self._positive_confidences = self._positive_confidences[examples]\\n self._negative_confidences = self._negative_confidences[examples]\\n self._check_lengths()\\n\\n def use_positive_from(self, other):\\n \\\"\\\"\\\"If session is fully irrelevant, to use positive pairs from another session.\\n This way \\\"triple loss\\\" becomes \\\"contrastive\\\"\\n\\n :param other: not irrelevant session with positive evidences\\n \\\"\\\"\\\"\\n other._check_types()\\n other._check_lengths()\\n\\n if self._negative_ranks.shape[0] < other._positive_ranks.shape[0]:\\n positive_ranks_: FloatTensor = other._positive_ranks[\\n : self._negative_ranks.shape[0]\\n ]\\n elif self._negative_ranks.shape[0] > other._positive_ranks.shape[0]:\\n self._negative_ranks = self._negative_ranks[\\n : other._positive_ranks.shape[0]\\n ]\\n self._target = self._target[: other._positive_ranks.shape[0]]\\n self._negative_confidences = self._negative_confidences[\\n : other._positive_ranks.shape[0]\\n ]\\n positive_ranks_: FloatTensor = other._positive_ranks\\n else:\\n positive_ranks_: FloatTensor = other._positive_ranks\\n\\n self._positive_confidences = other._positive_ranks\\n self._positive_ranks = positive_ranks_\\n\\n self._check_types()\\n self._check_lengths()\"\n },\n {\n \"identifier\": \"RankingLossInterface\",\n \"path\": \"embedding_studio/embeddings/losses/ranking_loss_interface.py\",\n \"snippet\": \"class RankingLossInterface(pl.LightningModule):\\n @abstractmethod\\n def __call__(self, features: SessionFeatures) -> FloatTensor:\\n raise NotImplemented()\"\n },\n {\n \"identifier\": \"DistanceShift\",\n \"path\": \"embedding_studio/embeddings/metrics/distance_shift.py\",\n \"snippet\": \"class DistanceShift(MetricCalculator):\\n def _calc_dist_shift(\\n self,\\n session: ClickstreamSession,\\n extractor: FeaturesExtractor,\\n items_storage: ItemsStorage,\\n query_retriever: QueryRetriever,\\n ) -> float:\\n # TODO: encapsulate inference in one class / object\\n query_vector: FloatTensor = extractor.model.forward_query(\\n query_retriever(session.query)\\n )\\n items_vectors: FloatTensor = extractor.model.forward_items(\\n items_storage.items_by_ids(session.events + session.not_events)\\n )\\n\\n ranks: FloatTensor = (\\n extractor.ranker(query_vector, items_vectors).cpu().tolist()\\n )\\n\\n # for similarity ranks should be higher for results of not irrelevant sessions,\\n # for distances should be vice versa\\n target: int = 1 if extractor.is_similarity else -1\\n compare = lambda prev, new: target * float(new - prev)\\n results: List[str] = session.events\\n if session.is_irrelevant:\\n results = session.results\\n compare = lambda prev, new: target * float(prev - new)\\n\\n return float(\\n np.mean(\\n [\\n compare(session.ranks[id_], new_rank)\\n for id_, new_rank in zip(results, ranks)\\n ]\\n )\\n )\\n\\n @torch.no_grad()\\n def __call__(\\n self,\\n batch: List[Tuple[ClickstreamSession, ClickstreamSession]],\\n extractor: FeaturesExtractor,\\n items_storage: ItemsStorage,\\n query_retriever: QueryRetriever,\\n ) -> List[MetricValue]:\\n \\\"\\\"\\\"Calculate metric, that means how ranks of provided sessions were changed .\\n\\n :param batch: batch of pairs clickstream sessions (not_irrelevant, irrelevant)\\n :param extractor: object to extract SessionFeatures out of provided sessions\\n :param items_storage: items dataset\\n :param query_retriever: how to retrieve a value related to session query\\n :return: list of calculated not_irrelevant_dist_shift and irrelevant_dist_shift metrics\\n \\\"\\\"\\\"\\n not_irrelevenat_shifts: List[float] = []\\n irrelevenat_shifts: List[float] = []\\n for index, (not_irrelevenat_session, irrelevant_session) in enumerate(\\n batch\\n ):\\n if not_irrelevenat_session is not None:\\n not_irrelevenat_shifts.append(\\n self._calc_dist_shift(\\n not_irrelevenat_session,\\n extractor,\\n items_storage,\\n query_retriever,\\n )\\n )\\n\\n if irrelevant_session is not None:\\n irrelevenat_shifts.append(\\n self._calc_dist_shift(\\n irrelevant_session,\\n extractor,\\n items_storage,\\n query_retriever,\\n )\\n )\\n\\n return [\\n MetricValue(\\n \\\"not_irrelevant_dist_shift\\\",\\n float(np.mean(not_irrelevenat_shifts))\\n if len(not_irrelevenat_shifts) > 0\\n else 0.0,\\n ),\\n MetricValue(\\n \\\"irrelevant_dist_shift\\\",\\n float(np.mean(irrelevenat_shifts))\\n if len(irrelevenat_shifts) > 0\\n else 0.0,\\n ),\\n ]\"\n },\n {\n \"identifier\": \"MetricCalculator\",\n \"path\": \"embedding_studio/embeddings/metrics/metric.py\",\n \"snippet\": \"class MetricCalculator(ABC):\\n \\\"\\\"\\\"Interface of metrics calculator\\\"\\\"\\\"\\n\\n @abstractmethod\\n @torch.no_grad()\\n def __call__(\\n self,\\n batch: List[Tuple[ClickstreamSession, ClickstreamSession]],\\n extractor: FeaturesExtractor,\\n items_storage: ItemsStorage,\\n query_retriever: QueryRetriever,\\n ) -> List[MetricValue]:\\n \\\"\\\"\\\"Calculate abstract metric value over provided batch of items.\\n\\n :param batch: batch of pairs clickstream sessions (not_irrelevant, irrelevant)\\n :param extractor: object to extract SessionFeatures out of provided sessions\\n :param items_storage: items dataset\\n :param query_retriever: how to retrieve a value related to session query\\n :return: list of calculated metrics\\n \\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"EmbeddingsModelInterface\",\n \"path\": \"embedding_studio/embeddings/models/interface.py\",\n \"snippet\": \"class EmbeddingsModelInterface(pl.LightningModule):\\n def __init__(self, same_query_and_items: bool = False):\\n \\\"\\\"\\\"In search we have two entities, which could be multi domain: query and search result (item).\\n This is the interface we used in fine-tuning procedure.\\n\\n :param same_query_and_items: are query and items models acutally the same model (default: False)\\n \\\"\\\"\\\"\\n super(EmbeddingsModelInterface, self).__init__()\\n self.same_query_and_items = same_query_and_items\\n\\n @abstractmethod\\n def get_query_model_params(self) -> Iterator[Parameter]:\\n pass\\n\\n @abstractmethod\\n def get_items_model_params(self) -> Iterator[Parameter]:\\n pass\\n\\n @abstractmethod\\n def fix_query_model(self, num_fixed_layers: int):\\n \\\"\\\"\\\"One of fine-tuning hyperparams is num of fixed layers at a query model\\n\\n :param num_fixed_layers: how many layers to fix\\n \\\"\\\"\\\"\\n\\n @abstractmethod\\n def unfix_query_model(self):\\n \\\"\\\"\\\"Unfix all layers of a query model.\\\"\\\"\\\"\\n\\n @abstractmethod\\n def fix_item_model(self, num_fixed_layers: int):\\n \\\"\\\"\\\"One of fine-tuning hyperparams is num of fixed layers at an item model\\n\\n :param num_fixed_layers: how many layers to fix\\n \\\"\\\"\\\"\\n\\n @abstractmethod\\n def unfix_item_model(self):\\n \\\"\\\"\\\"Unfix all layers of an item model.\\\"\\\"\\\"\\n\\n @abstractmethod\\n def forward_query(self, query: Any) -> FloatTensor:\\n pass\\n\\n @abstractmethod\\n def forward_items(self, items: List[Any]) -> FloatTensor:\\n pass\"\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\": \"FineTuningParams\",\n \"path\": \"embedding_studio/workers/fine_tuning/experiments/finetuning_params.py\",\n \"snippet\": \"class FineTuningParams(BaseModel):\\n \\\"\\\"\\\"Params of fine-tuning procedure\\n\\n :param num_fixed_layers: number of fixed embeddings layers\\n :param query_lr: learning rate of query model optimizer\\n :param items_lr: learning rate of items model optimizer\\n :param query_weight_decay: weight decay of query model optimizer\\n :param items_weight_decay: weight decay of items model optimizer\\n :param margin: margin from MarginRankingLoss\\n :param not_irrelevant_only: use only not irrelevant sessions\\n :param negative_downsampling: ratio of negative samples to be used\\n :param min_abs_difference_threshold: filter out soft pairs abs(neg_dist - pos_dist) < small value (default: 0.0)\\n :param max_abs_difference_threshold: filter out hard pairs abs(neg_dist - pos_dist) > huge value (default: 1.0)\\n :param examples_order: order of passing examples to a trainer (default: None)\\n \\\"\\\"\\\"\\n\\n num_fixed_layers: int\\n query_lr: float\\n items_lr: float\\n query_weight_decay: float\\n items_weight_decay: float\\n margin: float\\n not_irrelevant_only: bool\\n negative_downsampling: float\\n min_abs_difference_threshold: float = 0.0\\n max_abs_difference_threshold: float = 1.0\\n examples_order: List[ExamplesType] = [ExamplesType.all_examples]\\n\\n class Config:\\n arbitrary_types_allowed = True\\n\\n @validator(\\\"examples_order\\\", pre=True, always=True)\\n def validate_examples_order(cls, value):\\n if isinstance(value, str):\\n value = list(map(int, value.split(\\\",\\\")))\\n elif isinstance(value, tuple):\\n value = list(value)\\n return [ExamplesType(v) for v in value]\\n\\n @validator(\\\"items_lr\\\", \\\"query_lr\\\", pre=True, always=True)\\n def validate_positive_float(cls, value):\\n if not (isinstance(value, float) and value > 0):\\n raise ValueError(f\\\"{value} must be a positive float\\\")\\n return value\\n\\n @validator(\\n \\\"items_weight_decay\\\", \\\"query_weight_decay\\\", pre=True, always=True\\n )\\n def validate_non_negative_float(cls, value):\\n if not (isinstance(value, float) and value >= 0):\\n raise ValueError(f\\\"{value} must be a non-negative float\\\")\\n return value\\n\\n @validator(\\\"margin\\\", pre=True, always=True)\\n def validate_non_negative_float_margin(cls, value):\\n if not (isinstance(value, float) and value >= 0):\\n raise ValueError(f\\\"{value} must be a non-negative float\\\")\\n return value\\n\\n @validator(\\\"num_fixed_layers\\\", pre=True, always=True)\\n def validate_non_negative_int(cls, value):\\n if not (isinstance(value, int) and value >= 0):\\n raise ValueError(f\\\"{value} must be a non-negative integer\\\")\\n return value\\n\\n @root_validator(skip_on_failure=True)\\n def validate_example_order(cls, values):\\n examples_order = values.get(\\\"examples_order\\\")\\n if examples_order:\\n if isinstance(examples_order, str):\\n examples_order = list(map(int, examples_order.split(\\\",\\\")))\\n elif isinstance(examples_order, tuple):\\n examples_order = list(examples_order)\\n values[\\\"examples_order\\\"] = [\\n ExamplesType(v) for v in examples_order\\n ]\\n return values\\n\\n @property\\n def id(self) -> str:\\n # Convert the value to bytes (assuming it's a string)\\n value_bytes: bytes = str(self).encode(\\\"utf-8\\\")\\n\\n # Create a hash object\\n hash_object = hashlib.sha256()\\n\\n # Update the hash object with the value\\n hash_object.update(value_bytes)\\n\\n # Get the hexadecimal representation of the hash\\n unique_id: str = hash_object.hexdigest()\\n\\n return unique_id\\n\\n def __str__(self) -> str:\\n vals: List[str] = []\\n for key, value in sorted(dict(self).items()):\\n value = (\\n \\\",\\\".join(map(str, value)) if isinstance(value, list) else value\\n )\\n vals.append(f\\\"{key}: {value}\\\")\\n\\n return \\\" / \\\".join(vals)\"\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\": \"MetricValue\",\n \"path\": \"embedding_studio/workers/fine_tuning/experiments/metrics_accumulator.py\",\n \"snippet\": \"class MetricValue:\\n def __init__(self, name: str, value: float):\\n if not isinstance(name, str) or len(name) == 0:\\n raise ValueError(\\\"MetricValue's name should not be empty\\\")\\n self._name = name\\n\\n if not isinstance(value, float):\\n raise ValueError(\\\"MetricValue's value should not be numeric\\\")\\n self._value = value\\n\\n @property\\n def name(self) -> str:\\n return self._name\\n\\n @property\\n def value(self) -> float:\\n return self._value\\n\\n def add_prefix(self, prefix: str):\\n self._name = f\\\"{prefix}_{self._name}\\\"\\n return self\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import logging\nimport numpy as np\nimport pytorch_lightning as pl\nimport torch\nfrom collections import defaultdict\nfrom typing import Callable, List, Optional, Tuple, Union\nfrom datasets import DatasetDict\nfrom torch import FloatTensor, Tensor\nfrom torch.optim import SGD, Optimizer\nfrom torch.optim.lr_scheduler import LRScheduler, StepLR\nfrom embedding_studio.embeddings.data.clickstream.query_retriever import (\n QueryRetriever,\n)\nfrom embedding_studio.embeddings.data.clickstream.raw_session import (\n ClickstreamSession,\n)\nfrom embedding_studio.embeddings.features.event_confidences import (\n dummy_confidences,\n)\nfrom embedding_studio.embeddings.features.extractor import (\n COSINE_SIMILARITY,\n FeaturesExtractor,\n)\nfrom embedding_studio.embeddings.features.session_features import (\n SessionFeatures,\n)\nfrom embedding_studio.embeddings.losses.ranking_loss_interface import (\n RankingLossInterface,\n)\nfrom embedding_studio.embeddings.metrics.distance_shift import DistanceShift\nfrom embedding_studio.embeddings.metrics.metric import MetricCalculator\nfrom embedding_studio.embeddings.models.interface import (\n EmbeddingsModelInterface,\n)\nfrom embedding_studio.workers.fine_tuning.experiments.experiments_tracker import (\n ExperimentsManager,\n)\nfrom embedding_studio.workers.fine_tuning.experiments.finetuning_params import (\n FineTuningParams,\n)\nfrom embedding_studio.workers.fine_tuning.experiments.finetuning_settings import (\n FineTuningSettings,\n)\nfrom embedding_studio.workers.fine_tuning.experiments.metrics_accumulator import (\n MetricValue,\n)"},"token_num":{"kind":"number","value":16773,"string":"16,773"},"cropped_code":{"kind":"string","value":" if not isinstance(fine_tuning_params, FineTuningParams):\n raise TypeError(\n \"fine_tuning_params must be an instance of FineTuningParams\"\n )\n\n if not isinstance(tracker, ExperimentsManager):\n raise TypeError(\n \"tracker must be an instance of ExperimentsManager\"\n )\n\n if not isinstance(fine_tuning_params, FineTuningParams):\n raise TypeError(\n \"fine_tuning_params must be an instance of FineTuningParams\"\n )\n\n super(EmbeddingsFineTuner, self).__init__()\n self.features_extractor = FeaturesExtractor(\n model,\n ranker,\n is_similarity,\n fine_tuning_params.not_irrelevant_only,\n fine_tuning_params.negative_downsampling,\n fine_tuning_params.min_abs_difference_threshold,\n fine_tuning_params.max_abs_difference_threshold,\n confidence_calculator,\n )\n self.items_storages = items_storages\n self.query_retriever = query_retriever\n\n if not metric_calculators:\n logger.debug(\n \"metric_calculators list is empty - DistanceShift metric will be used by default.\"\n )\n self.calculators = (\n metric_calculators\n if metric_calculators is not None\n else [DistanceShift()]\n )\n\n self.loss_func = loss_func\n self.loss_func.set_margin(fine_tuning_params.margin)\n self.fine_tuning_params = fine_tuning_params\n self.tracker = tracker\n self.step_size = step_size\n self.gamma = gamma\n self._validation_metrics = defaultdict(list)\n\n # Fix layers\n self.features_extractor.model.fix_item_model(\n fine_tuning_params.num_fixed_layers\n )\n self.features_extractor.model.fix_query_model(\n fine_tuning_params.num_fixed_layers\n )\n\n self.automatic_optimization = False\n\n def preprocess_sessions(self, clickstream_dataset: DatasetDict):\n for key in clickstream_dataset.keys():\n item_storage = self.items_storages[key]\n logger.info(\n f\"Calculate ranks for {key} not irrelevant clickstream sessions\"\n )\n for session in clickstream_dataset[key].not_irrelevant:\n unique_values = set(session.ranks.values())\n if len(unique_values) == 0 or None in unique_values:\n session.ranks = self.features_extractor.calculate_ranks(\n session, item_storage, self.query_retriever\n )\n\n logger.info(\n f\"Calculate ranks for {key} irrelevant clickstream sessions\"\n )\n for session in clickstream_dataset[key].irrelevant:\n unique_values = set(session.ranks.values())\n if len(unique_values) == 0 or None in unique_values:\n session.ranks = self.features_extractor.calculate_ranks(\n session, item_storage, self.query_retriever\n )\n\n # Standart LightningModule methods to be overrided to be used in PytorchLightning Trainer\n # 1. Configure optimizers and schedulers\n def configure_optimizers(\n self,\n ) -> Tuple[List[Optimizer], List[LRScheduler]]:\n if not (isinstance(self.step_size, int) and self.step_size > 0):\n raise ValueError(\"step_size must be a positive integer\")\n\n if not (isinstance(self.gamma, float) and 0 < self.gamma < 1):\n raise ValueError(\"gamma must be a float in the range (0, 1)\")\n\n items_optimizer: SGD = SGD(\n self.features_extractor.model.get_items_model_params(),\n lr=self.fine_tuning_params.items_lr,\n weight_decay=self.fine_tuning_params.items_weight_decay,\n )\n items_scheduler: StepLR = StepLR(\n items_optimizer, step_size=self.step_size, gamma=self.gamma\n )\n\n if self.features_extractor.model.same_query_and_items:\n return [items_optimizer], [items_scheduler]\n\n query_optimizer: SGD = SGD(\n self.features_extractor.model.get_query_model_params(),\n lr=self.fine_tuning_params.query_lr,\n weight_decay=self.fine_tuning_params.query_weight_decay,\n )\n query_scheduler: StepLR = torch.optim.lr_scheduler.StepLR(\n query_optimizer, step_size=self.step_size, gamma=self.gamma\n )\n\n return [items_optimizer, query_optimizer], [\n items_scheduler,\n query_scheduler,\n ]\n\n # 2. Training step code with one batch\n def training_step(\n self,\n"},"all_code":{"kind":"string","value":"\n\n\nlogger = logging.getLogger(__name__)\n\n\nclass EmbeddingsFineTuner(pl.LightningModule):\n def __init__(\n self,\n model: EmbeddingsModelInterface,\n items_storages: DatasetDict,\n query_retriever: QueryRetriever,\n loss_func: RankingLossInterface,\n fine_tuning_params: FineTuningParams,\n tracker: ExperimentsManager,\n metric_calculators: Optional[List[MetricCalculator]] = None,\n ranker: Callable[\n [FloatTensor, FloatTensor], FloatTensor\n ] = COSINE_SIMILARITY,\n is_similarity: bool = True,\n confidence_calculator: Callable = dummy_confidences,\n step_size: int = 500,\n gamma: float = 0.9,\n ):\n \"\"\"This is a class, that represents embeddings fine-tuning logic,\n designed in the way to be use PytorchLightning Trainer.\n\n :param model: embedding model itself\n :param items_storages: items storage related to a given iteration, as a datasetdict with train and test keys\n :param query_retriever: object to get item related to query, that can be used in \"forward\"\n :param loss_func: loss object for a ranking task\n :param fine_tuning_params: hyper params of fine-tuning task\n :param tracker: experiment management object\n :param metric_calculators: list of trackable metrics calculators (default: None)\n by default_params 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 \"\"\"\n if not isinstance(model, EmbeddingsModelInterface):\n raise TypeError(\n \"model must be an instance of EmbeddingsModelInterface\"\n )\n\n if not isinstance(items_storages, DatasetDict):\n raise TypeError(\"items_storages must be a DatasetDict\")\n\n if not isinstance(query_retriever, QueryRetriever):\n raise TypeError(\n \"query_retriever must be an instance of QueryRetriever\"\n )\n\n if not isinstance(loss_func, RankingLossInterface):\n raise TypeError(\n \"loss_func must be an instance of RankingLossInterface\"\n )\n\n if not isinstance(fine_tuning_params, FineTuningParams):\n raise TypeError(\n \"fine_tuning_params must be an instance of FineTuningParams\"\n )\n\n if not isinstance(tracker, ExperimentsManager):\n raise TypeError(\n \"tracker must be an instance of ExperimentsManager\"\n )\n\n if not isinstance(fine_tuning_params, FineTuningParams):\n raise TypeError(\n \"fine_tuning_params must be an instance of FineTuningParams\"\n )\n\n super(EmbeddingsFineTuner, self).__init__()\n self.features_extractor = FeaturesExtractor(\n model,\n ranker,\n is_similarity,\n fine_tuning_params.not_irrelevant_only,\n fine_tuning_params.negative_downsampling,\n fine_tuning_params.min_abs_difference_threshold,\n fine_tuning_params.max_abs_difference_threshold,\n confidence_calculator,\n )\n self.items_storages = items_storages\n self.query_retriever = query_retriever\n\n if not metric_calculators:\n logger.debug(\n \"metric_calculators list is empty - DistanceShift metric will be used by default.\"\n )\n self.calculators = (\n metric_calculators\n if metric_calculators is not None\n else [DistanceShift()]\n )\n\n self.loss_func = loss_func\n self.loss_func.set_margin(fine_tuning_params.margin)\n self.fine_tuning_params = fine_tuning_params\n self.tracker = tracker\n self.step_size = step_size\n self.gamma = gamma\n self._validation_metrics = defaultdict(list)\n\n # Fix layers\n self.features_extractor.model.fix_item_model(\n fine_tuning_params.num_fixed_layers\n )\n self.features_extractor.model.fix_query_model(\n fine_tuning_params.num_fixed_layers\n )\n\n self.automatic_optimization = False\n\n def preprocess_sessions(self, clickstream_dataset: DatasetDict):\n for key in clickstream_dataset.keys():\n item_storage = self.items_storages[key]\n logger.info(\n f\"Calculate ranks for {key} not irrelevant clickstream sessions\"\n )\n for session in clickstream_dataset[key].not_irrelevant:\n unique_values = set(session.ranks.values())\n if len(unique_values) == 0 or None in unique_values:\n session.ranks = self.features_extractor.calculate_ranks(\n session, item_storage, self.query_retriever\n )\n\n logger.info(\n f\"Calculate ranks for {key} irrelevant clickstream sessions\"\n )\n for session in clickstream_dataset[key].irrelevant:\n unique_values = set(session.ranks.values())\n if len(unique_values) == 0 or None in unique_values:\n session.ranks = self.features_extractor.calculate_ranks(\n session, item_storage, self.query_retriever\n )\n\n # Standart LightningModule methods to be overrided to be used in PytorchLightning Trainer\n # 1. Configure optimizers and schedulers\n def configure_optimizers(\n self,\n ) -> Tuple[List[Optimizer], List[LRScheduler]]:\n if not (isinstance(self.step_size, int) and self.step_size > 0):\n raise ValueError(\"step_size must be a positive integer\")\n\n if not (isinstance(self.gamma, float) and 0 < self.gamma < 1):\n raise ValueError(\"gamma must be a float in the range (0, 1)\")\n\n items_optimizer: SGD = SGD(\n self.features_extractor.model.get_items_model_params(),\n lr=self.fine_tuning_params.items_lr,\n weight_decay=self.fine_tuning_params.items_weight_decay,\n )\n items_scheduler: StepLR = StepLR(\n items_optimizer, step_size=self.step_size, gamma=self.gamma\n )\n\n if self.features_extractor.model.same_query_and_items:\n return [items_optimizer], [items_scheduler]\n\n query_optimizer: SGD = SGD(\n self.features_extractor.model.get_query_model_params(),\n lr=self.fine_tuning_params.query_lr,\n weight_decay=self.fine_tuning_params.query_weight_decay,\n )\n query_scheduler: StepLR = torch.optim.lr_scheduler.StepLR(\n query_optimizer, step_size=self.step_size, gamma=self.gamma\n )\n\n return [items_optimizer, query_optimizer], [\n items_scheduler,\n query_scheduler,\n ]\n\n # 2. Training step code with one batch\n def training_step(\n self,"},"next_line":{"kind":"string","value":" batch: List[Tuple[ClickstreamSession, ClickstreamSession]],"},"gold_snippet_index":{"kind":"number","value":1,"string":"1"},"created_at":{"kind":"string","value":"2023-10-31 00:33:13+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5995,"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":17997,"string":"17,997"},"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"},"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():"},"next_line":{"kind":"string","value":" skel_motion = SkeletonMotion.from_file("},"gold_snippet_index":{"kind":"number","value":2,"string":"2"},"created_at":{"kind":"string","value":"2023-10-30 20:43:43+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5996,"cells":{"repo_name":{"kind":"string","value":"masked-spacetime-hashing/msth"},"file_path":{"kind":"string","value":"nerfstudio/models/tensorf.py"},"context":{"kind":"list like","value":[{"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":"to_immutable_dict","path":"nerfstudio/configs/config_utils.py","snippet":"def to_immutable_dict(d: Dict[str, Any]):\n \"\"\"Method to convert mutable dict to default factory dict\n\n Args:\n d: dictionary to convert into default factory dict for dataclass\n \"\"\"\n return field(default_factory=lambda: dict(d))"},{"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":"NeRFEncoding","path":"nerfstudio/field_components/encodings.py","snippet":"class NeRFEncoding(Encoding):\n \"\"\"Multi-scale sinusoidal encodings. Support ``integrated positional encodings`` if covariances are provided.\n Each axis is encoded with frequencies ranging from 2^min_freq_exp to 2^max_freq_exp.\n\n Args:\n in_dim: Input dimension of tensor\n num_frequencies: Number of encoded frequencies per axis\n min_freq_exp: Minimum frequency exponent\n max_freq_exp: Maximum frequency exponent\n include_input: Append the input coordinate to the encoding\n \"\"\"\n\n def __init__(\n self, in_dim: int, num_frequencies: int, min_freq_exp: float, max_freq_exp: float, include_input: bool = False\n ) -> None:\n super().__init__(in_dim)\n\n self.num_frequencies = num_frequencies\n self.min_freq = min_freq_exp\n self.max_freq = max_freq_exp\n self.include_input = include_input\n\n def get_out_dim(self) -> int:\n if self.in_dim is None:\n raise ValueError(\"Input dimension has not been set\")\n out_dim = self.in_dim * self.num_frequencies * 2\n if self.include_input:\n out_dim += self.in_dim\n return out_dim\n\n def forward(\n self,\n in_tensor: TensorType[\"bs\":..., \"input_dim\"],\n covs: Optional[TensorType[\"bs\":..., \"input_dim\", \"input_dim\"]] = None,\n ) -> TensorType[\"bs\":..., \"output_dim\"]:\n \"\"\"Calculates NeRF encoding. If covariances are provided the encodings will be integrated as proposed\n in mip-NeRF.\n\n Args:\n in_tensor: For best performance, the input tensor should be between 0 and 1.\n covs: Covariances of input points.\n Returns:\n Output values will be between -1 and 1\n \"\"\"\n in_tensor = 2 * torch.pi * in_tensor # scale to [0, 2pi]\n freqs = 2 ** torch.linspace(self.min_freq, self.max_freq, self.num_frequencies).to(in_tensor.device)\n scaled_inputs = in_tensor[..., None] * freqs # [..., \"input_dim\", \"num_scales\"]\n scaled_inputs = scaled_inputs.view(*scaled_inputs.shape[:-2], -1) # [..., \"input_dim\" * \"num_scales\"]\n\n if covs is None:\n encoded_inputs = torch.sin(torch.cat([scaled_inputs, scaled_inputs + torch.pi / 2.0], dim=-1))\n else:\n input_var = torch.diagonal(covs, dim1=-2, dim2=-1)[..., :, None] * freqs[None, :] ** 2\n input_var = input_var.reshape((*input_var.shape[:-2], -1))\n encoded_inputs = expected_sin(\n torch.cat([scaled_inputs, scaled_inputs + torch.pi / 2.0], dim=-1), torch.cat(2 * [input_var], dim=-1)\n )\n\n if self.include_input:\n encoded_inputs = torch.cat([encoded_inputs, in_tensor], dim=-1)\n return encoded_inputs"},{"identifier":"TensorCPEncoding","path":"nerfstudio/field_components/encodings.py","snippet":"class TensorCPEncoding(Encoding):\n \"\"\"Learned CANDECOMP/PARFAC (CP) decomposition encoding used in TensoRF\n\n Args:\n resolution: Resolution of grid.\n num_components: Number of components per dimension.\n init_scale: Initialization scale.\n \"\"\"\n\n def __init__(self, resolution: int = 256, num_components: int = 24, init_scale: float = 0.1) -> None:\n super().__init__(in_dim=3)\n\n self.resolution = resolution\n self.num_components = num_components\n\n # TODO Learning rates should be different for these\n self.line_coef = nn.Parameter(init_scale * torch.randn((3, num_components, resolution, 1)))\n\n def get_out_dim(self) -> int:\n return self.num_components\n\n def forward(self, in_tensor: TensorType[\"bs\":..., \"input_dim\"]) -> TensorType[\"bs\":..., \"output_dim\"]:\n line_coord = torch.stack([in_tensor[..., 2], in_tensor[..., 1], in_tensor[..., 0]]) # [3, ...]\n line_coord = torch.stack([torch.zeros_like(line_coord), line_coord], dim=-1) # [3, ...., 2]\n\n # Stop gradients from going to sampler\n line_coord = line_coord.view(3, -1, 1, 2).detach()\n\n line_features = F.grid_sample(self.line_coef, line_coord, align_corners=True) # [3, Components, -1, 1]\n\n features = torch.prod(line_features, dim=0)\n features = torch.moveaxis(features.view(self.num_components, *in_tensor.shape[:-1]), 0, -1)\n\n return features # [..., Components]\n\n @torch.no_grad()\n def upsample_grid(self, resolution: int) -> None:\n \"\"\"Upsamples underyling feature grid\n\n Args:\n resolution: Target resolution.\n \"\"\"\n\n self.line_coef.data = F.interpolate(\n self.line_coef.data, size=(resolution, 1), mode=\"bilinear\", align_corners=True\n )\n\n self.resolution = resolution"},{"identifier":"TensorVMEncoding","path":"nerfstudio/field_components/encodings.py","snippet":"class TensorVMEncoding(Encoding):\n \"\"\"Learned vector-matrix encoding proposed by TensoRF\n\n Args:\n resolution: Resolution of grid.\n num_components: Number of components per dimension.\n init_scale: Initialization scale.\n \"\"\"\n\n plane_coef: TensorType[3, \"num_components\", \"resolution\", \"resolution\"]\n line_coef: TensorType[3, \"num_components\", \"resolution\", 1]\n\n def __init__(\n self,\n resolution: int = 128,\n num_components: int = 24,\n init_scale: float = 0.1,\n ) -> None:\n super().__init__(in_dim=3)\n\n self.resolution = resolution\n self.num_components = num_components\n\n self.plane_coef = nn.Parameter(init_scale * torch.randn((3, num_components, resolution, resolution)))\n self.line_coef = nn.Parameter(init_scale * torch.randn((3, num_components, resolution, 1)))\n\n def get_out_dim(self) -> int:\n return self.num_components * 3\n\n def forward(self, in_tensor: TensorType[\"bs\":..., \"input_dim\"]) -> TensorType[\"bs\":..., \"output_dim\"]:\n \"\"\"Compute encoding for each position in in_positions\n\n Args:\n in_tensor: position inside bounds in range [-1,1],\n\n Returns: Encoded position\n \"\"\"\n plane_coord = torch.stack([in_tensor[..., [0, 1]], in_tensor[..., [0, 2]], in_tensor[..., [1, 2]]]) # [3,...,2]\n line_coord = torch.stack([in_tensor[..., 2], in_tensor[..., 1], in_tensor[..., 0]]) # [3, ...]\n line_coord = torch.stack([torch.zeros_like(line_coord), line_coord], dim=-1) # [3, ...., 2]\n\n # Stop gradients from going to sampler\n plane_coord = plane_coord.view(3, -1, 1, 2).detach()\n line_coord = line_coord.view(3, -1, 1, 2).detach()\n\n plane_features = F.grid_sample(self.plane_coef, plane_coord, align_corners=True) # [3, Components, -1, 1]\n line_features = F.grid_sample(self.line_coef, line_coord, align_corners=True) # [3, Components, -1, 1]\n\n features = plane_features * line_features # [3, Components, -1, 1]\n features = torch.moveaxis(features.view(3 * self.num_components, *in_tensor.shape[:-1]), 0, -1)\n\n return features # [..., 3 * Components]\n\n @torch.no_grad()\n def upsample_grid(self, resolution: int) -> None:\n \"\"\"Upsamples underlying feature grid\n\n Args:\n resolution: Target resolution.\n \"\"\"\n plane_coef = F.interpolate(\n self.plane_coef.data, size=(resolution, resolution), mode=\"bilinear\", align_corners=True\n )\n line_coef = F.interpolate(self.line_coef.data, size=(resolution, 1), mode=\"bilinear\", align_corners=True)\n\n self.plane_coef, self.line_coef = torch.nn.Parameter(plane_coef), torch.nn.Parameter(line_coef)\n self.resolution = resolution"},{"identifier":"TriplaneEncoding","path":"nerfstudio/field_components/encodings.py","snippet":"class TriplaneEncoding(Encoding):\n \"\"\"Learned triplane encoding\n\n The encoding at [i,j,k] is an n dimensional vector corresponding to the element-wise product of the\n three n dimensional vectors at plane_coeff[i,j], plane_coeff[i,k], and plane_coeff[j,k].\n\n This allows for marginally more expressivity than the TensorVMEncoding, and each component is self standing\n and symmetrical, unlike with VM decomposition where we needed one component with a vector along all the x, y, z\n directions for symmetry.\n\n This can be thought of as 3 planes of features perpendicular to the x, y, and z axes, respectively and intersecting\n at the origin, and the encoding being the element-wise product of the element at the projection of [i, j, k] on\n these planes.\n\n The use for this is in representing a tensor decomp of a 4D embedding tensor: (x, y, z, feature_size)\n\n This will return a tensor of shape (bs:..., num_components)\n\n Args:\n resolution: Resolution of grid.\n num_components: The number of scalar triplanes to use (ie: output feature size)\n init_scale: The scale of the initial values of the planes\n product: Whether to use the element-wise product of the planes or the sum\n \"\"\"\n\n plane_coef: TensorType[3, \"num_components\", \"resolution\", \"resolution\"]\n\n def __init__(\n self,\n resolution: int = 32,\n num_components: int = 64,\n init_scale: float = 0.1,\n reduce: Literal[\"sum\", \"product\"] = \"sum\",\n ) -> None:\n super().__init__(in_dim=3)\n\n self.resolution = resolution\n self.num_components = num_components\n self.init_scale = init_scale\n self.reduce = reduce\n\n self.plane_coef = nn.Parameter(\n self.init_scale * torch.randn((3, self.num_components, self.resolution, self.resolution))\n )\n\n def get_out_dim(self) -> int:\n return self.num_components\n\n def forward(self, in_tensor: TensorType[\"bs\":..., 3]) -> TensorType[\"bs\":..., \"num_components\", \"featuresize\"]:\n \"\"\"Sample features from this encoder. Expects in_tensor to be in range [0, resolution]\"\"\"\n\n original_shape = in_tensor.shape\n in_tensor = in_tensor.reshape(-1, 3)\n\n plane_coord = torch.stack([in_tensor[..., [0, 1]], in_tensor[..., [0, 2]], in_tensor[..., [1, 2]]], dim=0)\n\n # Stop gradients from going to sampler\n plane_coord = plane_coord.detach().view(3, -1, 1, 2)\n plane_features = F.grid_sample(\n self.plane_coef, plane_coord, align_corners=True\n ) # [3, num_components, flattened_bs, 1]\n\n if self.reduce == \"product\":\n plane_features = plane_features.prod(0).squeeze(-1).T # [flattened_bs, num_components]\n else:\n plane_features = plane_features.sum(0).squeeze(-1).T\n\n return plane_features.reshape(*original_shape[:-1], self.num_components)\n\n @torch.no_grad()\n def upsample_grid(self, resolution: int) -> None:\n \"\"\"Upsamples underlying feature grid\n\n Args:\n resolution: Target resolution.\n \"\"\"\n plane_coef = F.interpolate(\n self.plane_coef.data, size=(resolution, resolution), mode=\"bilinear\", align_corners=True\n )\n\n self.plane_coef = torch.nn.Parameter(plane_coef)\n self.resolution = resolution"},{"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":"TensoRFField","path":"nerfstudio/fields/tensorf_field.py","snippet":"class TensoRFField(Field):\n \"\"\"TensoRF Field\"\"\"\n\n def __init__(\n self,\n aabb: TensorType,\n # the aabb bounding box of the dataset\n feature_encoding: Encoding = Identity(in_dim=3),\n # the encoding method used for appearance encoding outputs\n direction_encoding: Encoding = Identity(in_dim=3),\n # the encoding method used for ray direction\n density_encoding: Encoding = Identity(in_dim=3),\n # the tensor encoding method used for scene density\n color_encoding: Encoding = Identity(in_dim=3),\n # the tensor encoding method used for scene color\n appearance_dim: int = 27,\n # the number of dimensions for the appearance embedding\n head_mlp_num_layers: int = 2,\n # number of layers for the MLP\n head_mlp_layer_width: int = 128,\n # layer width for the MLP\n use_sh: bool = False,\n # whether to use spherical harmonics as the feature decoding function\n sh_levels: int = 2,\n # number of levels to use for spherical harmonics\n ) -> None:\n super().__init__()\n self.aabb = Parameter(aabb, requires_grad=False)\n self.feature_encoding = feature_encoding\n self.direction_encoding = direction_encoding\n self.density_encoding = density_encoding\n self.color_encoding = color_encoding\n\n self.mlp_head = MLP(\n in_dim=appearance_dim + 3 + self.direction_encoding.get_out_dim() + self.feature_encoding.get_out_dim(),\n num_layers=head_mlp_num_layers,\n layer_width=head_mlp_layer_width,\n activation=nn.ReLU(),\n out_activation=nn.ReLU(),\n )\n\n self.use_sh = use_sh\n\n if self.use_sh:\n self.sh = SHEncoding(sh_levels)\n self.B = nn.Linear(\n in_features=self.color_encoding.get_out_dim(), out_features=3 * self.sh.get_out_dim(), bias=False\n )\n else:\n self.B = nn.Linear(in_features=self.color_encoding.get_out_dim(), out_features=appearance_dim, bias=False)\n\n self.field_output_rgb = RGBFieldHead(in_dim=self.mlp_head.get_out_dim(), activation=nn.Sigmoid())\n\n def get_density(self, ray_samples: RaySamples) -> TensorType:\n positions = SceneBox.get_normalized_positions(ray_samples.frustums.get_positions(), self.aabb)\n positions = positions * 2 - 1\n density = self.density_encoding(positions)\n density_enc = torch.sum(density, dim=-1)[:, :, None]\n relu = torch.nn.ReLU()\n density_enc = relu(density_enc)\n return density_enc\n\n def get_outputs(self, ray_samples: RaySamples, density_embedding: Optional[TensorType] = None) -> TensorType:\n d = ray_samples.frustums.directions\n positions = SceneBox.get_normalized_positions(ray_samples.frustums.get_positions(), self.aabb)\n positions = positions * 2 - 1\n rgb_features = self.color_encoding(positions)\n rgb_features = self.B(rgb_features)\n\n d_encoded = self.direction_encoding(d)\n rgb_features_encoded = self.feature_encoding(rgb_features)\n\n if self.use_sh:\n sh_mult = self.sh(d)[:, :, None]\n rgb_sh = rgb_features.view(sh_mult.shape[0], sh_mult.shape[1], 3, sh_mult.shape[-1])\n rgb = torch.relu(torch.sum(sh_mult * rgb_sh, dim=-1) + 0.5)\n else:\n out = self.mlp_head(torch.cat([rgb_features, d, rgb_features_encoded, d_encoded], dim=-1)) # type: ignore\n rgb = self.field_output_rgb(out)\n\n return rgb\n\n def forward(\n self,\n ray_samples: RaySamples,\n compute_normals: bool = False,\n mask: Optional[TensorType] = None,\n bg_color: Optional[TensorType] = None,\n ) -> Dict[FieldHeadNames, TensorType]:\n if compute_normals is True:\n raise ValueError(\"Surface normals are not currently supported with TensoRF\")\n if mask is not None and bg_color is not None:\n base_density = torch.zeros(ray_samples.shape)[:, :, None].to(mask.device)\n base_rgb = bg_color.repeat(ray_samples[:, :, None].shape)\n if mask.any():\n input_rays = ray_samples[mask, :]\n density = self.get_density(input_rays)\n rgb = self.get_outputs(input_rays, None)\n\n base_density[mask] = density\n base_rgb[mask] = rgb\n\n base_density.requires_grad_()\n base_rgb.requires_grad_()\n\n density = base_density\n rgb = base_rgb\n else:\n density = self.get_density(ray_samples)\n rgb = self.get_outputs(ray_samples, None)\n\n return {FieldHeadNames.DENSITY: density, FieldHeadNames.RGB: rgb}"},{"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":"PDFSampler","path":"nerfstudio/model_components/ray_samplers.py","snippet":"class PDFSampler(Sampler):\n \"\"\"Sample based on probability distribution\n\n Args:\n num_samples: Number of samples per ray\n train_stratified: Randomize location within each bin during training.\n single_jitter: Use a same random jitter for all samples along a ray. Defaults to False\n include_original: Add original samples to ray.\n histogram_padding: Amount to weights prior to computing PDF.\n \"\"\"\n\n def __init__(\n self,\n num_samples: Optional[int] = None,\n train_stratified: bool = True,\n single_jitter: bool = False,\n include_original: bool = True,\n histogram_padding: float = 0.01,\n ) -> None:\n super().__init__(num_samples=num_samples)\n self.train_stratified = train_stratified\n self.include_original = include_original\n self.histogram_padding = histogram_padding\n self.single_jitter = single_jitter\n\n def generate_ray_samples(\n self,\n ray_bundle: Optional[RayBundle] = None,\n ray_samples: Optional[RaySamples] = None,\n weights: TensorType[..., \"num_samples\", 1] = None,\n num_samples: Optional[int] = None,\n eps: float = 1e-5,\n ) -> RaySamples:\n \"\"\"Generates position samples given a distribution.\n\n Args:\n ray_bundle: Rays to generate samples for\n ray_samples: Existing ray samples\n weights: Weights for each bin\n num_samples: Number of samples per ray\n eps: Small value to prevent numerical issues.\n\n Returns:\n Positions and deltas for samples along a ray\n \"\"\"\n\n if ray_samples is None or ray_bundle is None:\n raise ValueError(\"ray_samples and ray_bundle must be provided\")\n\n num_samples = num_samples or self.num_samples\n assert num_samples is not None\n num_bins = num_samples + 1\n\n weights = weights[..., 0] + self.histogram_padding\n\n # Add small offset to rays with zero weight to prevent NaNs\n weights_sum = torch.sum(weights, dim=-1, keepdim=True)\n padding = torch.relu(eps - weights_sum)\n weights = weights + padding / weights.shape[-1]\n weights_sum += padding\n\n pdf = weights / weights_sum\n cdf = torch.min(torch.ones_like(pdf), torch.cumsum(pdf, dim=-1))\n cdf = torch.cat([torch.zeros_like(cdf[..., :1]), cdf], dim=-1)\n\n if self.train_stratified and self.training:\n # Stratified samples between 0 and 1\n u = torch.linspace(0.0, 1.0 - (1.0 / num_bins), steps=num_bins, device=cdf.device)\n u = u.expand(size=(*cdf.shape[:-1], num_bins))\n if self.single_jitter:\n rand = torch.rand((*cdf.shape[:-1], 1), device=cdf.device) / num_bins\n else:\n rand = torch.rand((*cdf.shape[:-1], num_samples + 1), device=cdf.device) / num_bins\n u = u + rand\n else:\n # Uniform samples between 0 and 1\n u = torch.linspace(0.0, 1.0 - (1.0 / num_bins), steps=num_bins, device=cdf.device)\n u = u + 1.0 / (2 * num_bins)\n u = u.expand(size=(*cdf.shape[:-1], num_bins))\n u = u.contiguous()\n\n assert (\n ray_samples.spacing_starts is not None and ray_samples.spacing_ends is not None\n ), \"ray_sample spacing_starts and spacing_ends must be provided\"\n assert ray_samples.spacing_to_euclidean_fn is not None, \"ray_samples.spacing_to_euclidean_fn must be provided\"\n existing_bins = torch.cat(\n [\n ray_samples.spacing_starts[..., 0],\n ray_samples.spacing_ends[..., -1:, 0],\n ],\n dim=-1,\n )\n\n inds = torch.searchsorted(cdf, u, side=\"right\")\n below = torch.clamp(inds - 1, 0, existing_bins.shape[-1] - 1)\n above = torch.clamp(inds, 0, existing_bins.shape[-1] - 1)\n cdf_g0 = torch.gather(cdf, -1, below)\n bins_g0 = torch.gather(existing_bins, -1, below)\n cdf_g1 = torch.gather(cdf, -1, above)\n bins_g1 = torch.gather(existing_bins, -1, above)\n\n t = torch.clip(torch.nan_to_num((u - cdf_g0) / (cdf_g1 - cdf_g0), 0), 0, 1)\n bins = bins_g0 + t * (bins_g1 - bins_g0)\n\n if self.include_original:\n bins, _ = torch.sort(torch.cat([existing_bins, bins], -1), -1)\n\n # Stop gradients\n bins = bins.detach()\n\n euclidean_bins = ray_samples.spacing_to_euclidean_fn(bins)\n\n ray_samples = ray_bundle.get_ray_samples(\n bin_starts=euclidean_bins[..., :-1, None],\n bin_ends=euclidean_bins[..., 1:, None],\n spacing_starts=bins[..., :-1, None],\n spacing_ends=bins[..., 1:, None],\n spacing_to_euclidean_fn=ray_samples.spacing_to_euclidean_fn,\n )\n\n return ray_samples"},{"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":"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":"AABBBoxCollider","path":"nerfstudio/model_components/scene_colliders.py","snippet":"class AABBBoxCollider(SceneCollider):\n \"\"\"Module for colliding rays with the scene box to compute near and far values.\n\n Args:\n scene_box: scene box to apply to dataset\n \"\"\"\n\n def __init__(self, scene_box: SceneBox, near_plane: float = 0.0, **kwargs) -> None:\n super().__init__(**kwargs)\n self.scene_box = scene_box\n self.near_plane = near_plane\n\n def _intersect_with_aabb(\n self, rays_o: TensorType[\"num_rays\", 3], rays_d: TensorType[\"num_rays\", 3], aabb: TensorType[2, 3]\n ):\n \"\"\"Returns collection of valid rays within a specified near/far bounding box along with a mask\n specifying which rays are valid\n\n Args:\n rays_o: (num_rays, 3) ray origins\n rays_d: (num_rays, 3) ray directions\n aabb: (2, 3) This is [min point (x,y,z), max point (x,y,z)]\n \"\"\"\n # avoid divide by zero\n dir_fraction = 1.0 / (rays_d + 1e-6)\n\n # x\n t1 = (aabb[0, 0] - rays_o[:, 0:1]) * dir_fraction[:, 0:1]\n t2 = (aabb[1, 0] - rays_o[:, 0:1]) * dir_fraction[:, 0:1]\n # y\n t3 = (aabb[0, 1] - rays_o[:, 1:2]) * dir_fraction[:, 1:2]\n t4 = (aabb[1, 1] - rays_o[:, 1:2]) * dir_fraction[:, 1:2]\n # z\n t5 = (aabb[0, 2] - rays_o[:, 2:3]) * dir_fraction[:, 2:3]\n t6 = (aabb[1, 2] - rays_o[:, 2:3]) * dir_fraction[:, 2:3]\n\n nears = torch.max(\n torch.cat([torch.minimum(t1, t2), torch.minimum(t3, t4), torch.minimum(t5, t6)], dim=1), dim=1\n ).values\n fars = torch.min(\n torch.cat([torch.maximum(t1, t2), torch.maximum(t3, t4), torch.maximum(t5, t6)], dim=1), dim=1\n ).values\n\n # clamp to near plane\n near_plane = self.near_plane if self.training else 0\n nears = torch.clamp(nears, min=near_plane)\n fars = torch.maximum(fars, nears + 1e-6)\n\n return nears, fars\n\n def set_nears_and_fars(self, ray_bundle: RayBundle) -> RayBundle:\n \"\"\"Intersects the rays with the scene box and updates the near and far values.\n Populates nears and fars fields and returns the ray_bundle.\n\n Args:\n ray_bundle: specified ray bundle to operate on\n \"\"\"\n aabb = self.scene_box.aabb\n nears, fars = self._intersect_with_aabb(ray_bundle.origins, ray_bundle.directions, aabb)\n ray_bundle.nears = nears[..., None]\n ray_bundle.fars = fars[..., None]\n return ray_bundle"},{"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":"colors","path":"nerfstudio/utils/colors.py","snippet":"WHITE = torch.tensor([1.0, 1.0, 1.0])\nBLACK = torch.tensor([0.0, 0.0, 0.0])\nRED = torch.tensor([1.0, 0.0, 0.0])\nGREEN = torch.tensor([0.0, 1.0, 0.0])\nBLUE = torch.tensor([0.0, 0.0, 1.0])\nCOLORS_DICT = {\n \"white\": WHITE,\n \"black\": BLACK,\n \"red\": RED,\n \"green\": GREEN,\n \"blue\": BLUE,\n}\ndef get_color(color: Union[str, list]) -> TensorType[3]:"},{"identifier":"misc","path":"nerfstudio/utils/misc.py","snippet":"def get_dict_to_torch(stuff: Any, device: Union[torch.device, str] = \"cpu\", exclude: Optional[List[str]] = None):\ndef get_dict_to_cpu(stuff: Any):\ndef get_masked_dict(d, mask):\n def __init__(self, new_iter: Callable, new_next: Callable, length: int = -1):\n def __next__(self):\n def __iter__(self):\ndef scale_dict(dictionary: Dict[Any, Any], coefficients: Dict[str, float]) -> Dict[Any, Any]:\ndef step_check(step, step_size, run_at_zero=False) -> bool:\ndef update_avg(prev_avg: float, new_val: float, step: int) -> float:\ndef strtobool(val) -> bool:\nclass IterableWrapper: # pylint: disable=too-few-public-methods"}],"string":"[\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\": \"to_immutable_dict\",\n \"path\": \"nerfstudio/configs/config_utils.py\",\n \"snippet\": \"def to_immutable_dict(d: Dict[str, Any]):\\n \\\"\\\"\\\"Method to convert mutable dict to default factory dict\\n\\n Args:\\n d: dictionary to convert into default factory dict for dataclass\\n \\\"\\\"\\\"\\n return field(default_factory=lambda: dict(d))\"\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\": \"NeRFEncoding\",\n \"path\": \"nerfstudio/field_components/encodings.py\",\n \"snippet\": \"class NeRFEncoding(Encoding):\\n \\\"\\\"\\\"Multi-scale sinusoidal encodings. Support ``integrated positional encodings`` if covariances are provided.\\n Each axis is encoded with frequencies ranging from 2^min_freq_exp to 2^max_freq_exp.\\n\\n Args:\\n in_dim: Input dimension of tensor\\n num_frequencies: Number of encoded frequencies per axis\\n min_freq_exp: Minimum frequency exponent\\n max_freq_exp: Maximum frequency exponent\\n include_input: Append the input coordinate to the encoding\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self, in_dim: int, num_frequencies: int, min_freq_exp: float, max_freq_exp: float, include_input: bool = False\\n ) -> None:\\n super().__init__(in_dim)\\n\\n self.num_frequencies = num_frequencies\\n self.min_freq = min_freq_exp\\n self.max_freq = max_freq_exp\\n self.include_input = include_input\\n\\n def get_out_dim(self) -> int:\\n if self.in_dim is None:\\n raise ValueError(\\\"Input dimension has not been set\\\")\\n out_dim = self.in_dim * self.num_frequencies * 2\\n if self.include_input:\\n out_dim += self.in_dim\\n return out_dim\\n\\n def forward(\\n self,\\n in_tensor: TensorType[\\\"bs\\\":..., \\\"input_dim\\\"],\\n covs: Optional[TensorType[\\\"bs\\\":..., \\\"input_dim\\\", \\\"input_dim\\\"]] = None,\\n ) -> TensorType[\\\"bs\\\":..., \\\"output_dim\\\"]:\\n \\\"\\\"\\\"Calculates NeRF encoding. If covariances are provided the encodings will be integrated as proposed\\n in mip-NeRF.\\n\\n Args:\\n in_tensor: For best performance, the input tensor should be between 0 and 1.\\n covs: Covariances of input points.\\n Returns:\\n Output values will be between -1 and 1\\n \\\"\\\"\\\"\\n in_tensor = 2 * torch.pi * in_tensor # scale to [0, 2pi]\\n freqs = 2 ** torch.linspace(self.min_freq, self.max_freq, self.num_frequencies).to(in_tensor.device)\\n scaled_inputs = in_tensor[..., None] * freqs # [..., \\\"input_dim\\\", \\\"num_scales\\\"]\\n scaled_inputs = scaled_inputs.view(*scaled_inputs.shape[:-2], -1) # [..., \\\"input_dim\\\" * \\\"num_scales\\\"]\\n\\n if covs is None:\\n encoded_inputs = torch.sin(torch.cat([scaled_inputs, scaled_inputs + torch.pi / 2.0], dim=-1))\\n else:\\n input_var = torch.diagonal(covs, dim1=-2, dim2=-1)[..., :, None] * freqs[None, :] ** 2\\n input_var = input_var.reshape((*input_var.shape[:-2], -1))\\n encoded_inputs = expected_sin(\\n torch.cat([scaled_inputs, scaled_inputs + torch.pi / 2.0], dim=-1), torch.cat(2 * [input_var], dim=-1)\\n )\\n\\n if self.include_input:\\n encoded_inputs = torch.cat([encoded_inputs, in_tensor], dim=-1)\\n return encoded_inputs\"\n },\n {\n \"identifier\": \"TensorCPEncoding\",\n \"path\": \"nerfstudio/field_components/encodings.py\",\n \"snippet\": \"class TensorCPEncoding(Encoding):\\n \\\"\\\"\\\"Learned CANDECOMP/PARFAC (CP) decomposition encoding used in TensoRF\\n\\n Args:\\n resolution: Resolution of grid.\\n num_components: Number of components per dimension.\\n init_scale: Initialization scale.\\n \\\"\\\"\\\"\\n\\n def __init__(self, resolution: int = 256, num_components: int = 24, init_scale: float = 0.1) -> None:\\n super().__init__(in_dim=3)\\n\\n self.resolution = resolution\\n self.num_components = num_components\\n\\n # TODO Learning rates should be different for these\\n self.line_coef = nn.Parameter(init_scale * torch.randn((3, num_components, resolution, 1)))\\n\\n def get_out_dim(self) -> int:\\n return self.num_components\\n\\n def forward(self, in_tensor: TensorType[\\\"bs\\\":..., \\\"input_dim\\\"]) -> TensorType[\\\"bs\\\":..., \\\"output_dim\\\"]:\\n line_coord = torch.stack([in_tensor[..., 2], in_tensor[..., 1], in_tensor[..., 0]]) # [3, ...]\\n line_coord = torch.stack([torch.zeros_like(line_coord), line_coord], dim=-1) # [3, ...., 2]\\n\\n # Stop gradients from going to sampler\\n line_coord = line_coord.view(3, -1, 1, 2).detach()\\n\\n line_features = F.grid_sample(self.line_coef, line_coord, align_corners=True) # [3, Components, -1, 1]\\n\\n features = torch.prod(line_features, dim=0)\\n features = torch.moveaxis(features.view(self.num_components, *in_tensor.shape[:-1]), 0, -1)\\n\\n return features # [..., Components]\\n\\n @torch.no_grad()\\n def upsample_grid(self, resolution: int) -> None:\\n \\\"\\\"\\\"Upsamples underyling feature grid\\n\\n Args:\\n resolution: Target resolution.\\n \\\"\\\"\\\"\\n\\n self.line_coef.data = F.interpolate(\\n self.line_coef.data, size=(resolution, 1), mode=\\\"bilinear\\\", align_corners=True\\n )\\n\\n self.resolution = resolution\"\n },\n {\n \"identifier\": \"TensorVMEncoding\",\n \"path\": \"nerfstudio/field_components/encodings.py\",\n \"snippet\": \"class TensorVMEncoding(Encoding):\\n \\\"\\\"\\\"Learned vector-matrix encoding proposed by TensoRF\\n\\n Args:\\n resolution: Resolution of grid.\\n num_components: Number of components per dimension.\\n init_scale: Initialization scale.\\n \\\"\\\"\\\"\\n\\n plane_coef: TensorType[3, \\\"num_components\\\", \\\"resolution\\\", \\\"resolution\\\"]\\n line_coef: TensorType[3, \\\"num_components\\\", \\\"resolution\\\", 1]\\n\\n def __init__(\\n self,\\n resolution: int = 128,\\n num_components: int = 24,\\n init_scale: float = 0.1,\\n ) -> None:\\n super().__init__(in_dim=3)\\n\\n self.resolution = resolution\\n self.num_components = num_components\\n\\n self.plane_coef = nn.Parameter(init_scale * torch.randn((3, num_components, resolution, resolution)))\\n self.line_coef = nn.Parameter(init_scale * torch.randn((3, num_components, resolution, 1)))\\n\\n def get_out_dim(self) -> int:\\n return self.num_components * 3\\n\\n def forward(self, in_tensor: TensorType[\\\"bs\\\":..., \\\"input_dim\\\"]) -> TensorType[\\\"bs\\\":..., \\\"output_dim\\\"]:\\n \\\"\\\"\\\"Compute encoding for each position in in_positions\\n\\n Args:\\n in_tensor: position inside bounds in range [-1,1],\\n\\n Returns: Encoded position\\n \\\"\\\"\\\"\\n plane_coord = torch.stack([in_tensor[..., [0, 1]], in_tensor[..., [0, 2]], in_tensor[..., [1, 2]]]) # [3,...,2]\\n line_coord = torch.stack([in_tensor[..., 2], in_tensor[..., 1], in_tensor[..., 0]]) # [3, ...]\\n line_coord = torch.stack([torch.zeros_like(line_coord), line_coord], dim=-1) # [3, ...., 2]\\n\\n # Stop gradients from going to sampler\\n plane_coord = plane_coord.view(3, -1, 1, 2).detach()\\n line_coord = line_coord.view(3, -1, 1, 2).detach()\\n\\n plane_features = F.grid_sample(self.plane_coef, plane_coord, align_corners=True) # [3, Components, -1, 1]\\n line_features = F.grid_sample(self.line_coef, line_coord, align_corners=True) # [3, Components, -1, 1]\\n\\n features = plane_features * line_features # [3, Components, -1, 1]\\n features = torch.moveaxis(features.view(3 * self.num_components, *in_tensor.shape[:-1]), 0, -1)\\n\\n return features # [..., 3 * Components]\\n\\n @torch.no_grad()\\n def upsample_grid(self, resolution: int) -> None:\\n \\\"\\\"\\\"Upsamples underlying feature grid\\n\\n Args:\\n resolution: Target resolution.\\n \\\"\\\"\\\"\\n plane_coef = F.interpolate(\\n self.plane_coef.data, size=(resolution, resolution), mode=\\\"bilinear\\\", align_corners=True\\n )\\n line_coef = F.interpolate(self.line_coef.data, size=(resolution, 1), mode=\\\"bilinear\\\", align_corners=True)\\n\\n self.plane_coef, self.line_coef = torch.nn.Parameter(plane_coef), torch.nn.Parameter(line_coef)\\n self.resolution = resolution\"\n },\n {\n \"identifier\": \"TriplaneEncoding\",\n \"path\": \"nerfstudio/field_components/encodings.py\",\n \"snippet\": \"class TriplaneEncoding(Encoding):\\n \\\"\\\"\\\"Learned triplane encoding\\n\\n The encoding at [i,j,k] is an n dimensional vector corresponding to the element-wise product of the\\n three n dimensional vectors at plane_coeff[i,j], plane_coeff[i,k], and plane_coeff[j,k].\\n\\n This allows for marginally more expressivity than the TensorVMEncoding, and each component is self standing\\n and symmetrical, unlike with VM decomposition where we needed one component with a vector along all the x, y, z\\n directions for symmetry.\\n\\n This can be thought of as 3 planes of features perpendicular to the x, y, and z axes, respectively and intersecting\\n at the origin, and the encoding being the element-wise product of the element at the projection of [i, j, k] on\\n these planes.\\n\\n The use for this is in representing a tensor decomp of a 4D embedding tensor: (x, y, z, feature_size)\\n\\n This will return a tensor of shape (bs:..., num_components)\\n\\n Args:\\n resolution: Resolution of grid.\\n num_components: The number of scalar triplanes to use (ie: output feature size)\\n init_scale: The scale of the initial values of the planes\\n product: Whether to use the element-wise product of the planes or the sum\\n \\\"\\\"\\\"\\n\\n plane_coef: TensorType[3, \\\"num_components\\\", \\\"resolution\\\", \\\"resolution\\\"]\\n\\n def __init__(\\n self,\\n resolution: int = 32,\\n num_components: int = 64,\\n init_scale: float = 0.1,\\n reduce: Literal[\\\"sum\\\", \\\"product\\\"] = \\\"sum\\\",\\n ) -> None:\\n super().__init__(in_dim=3)\\n\\n self.resolution = resolution\\n self.num_components = num_components\\n self.init_scale = init_scale\\n self.reduce = reduce\\n\\n self.plane_coef = nn.Parameter(\\n self.init_scale * torch.randn((3, self.num_components, self.resolution, self.resolution))\\n )\\n\\n def get_out_dim(self) -> int:\\n return self.num_components\\n\\n def forward(self, in_tensor: TensorType[\\\"bs\\\":..., 3]) -> TensorType[\\\"bs\\\":..., \\\"num_components\\\", \\\"featuresize\\\"]:\\n \\\"\\\"\\\"Sample features from this encoder. Expects in_tensor to be in range [0, resolution]\\\"\\\"\\\"\\n\\n original_shape = in_tensor.shape\\n in_tensor = in_tensor.reshape(-1, 3)\\n\\n plane_coord = torch.stack([in_tensor[..., [0, 1]], in_tensor[..., [0, 2]], in_tensor[..., [1, 2]]], dim=0)\\n\\n # Stop gradients from going to sampler\\n plane_coord = plane_coord.detach().view(3, -1, 1, 2)\\n plane_features = F.grid_sample(\\n self.plane_coef, plane_coord, align_corners=True\\n ) # [3, num_components, flattened_bs, 1]\\n\\n if self.reduce == \\\"product\\\":\\n plane_features = plane_features.prod(0).squeeze(-1).T # [flattened_bs, num_components]\\n else:\\n plane_features = plane_features.sum(0).squeeze(-1).T\\n\\n return plane_features.reshape(*original_shape[:-1], self.num_components)\\n\\n @torch.no_grad()\\n def upsample_grid(self, resolution: int) -> None:\\n \\\"\\\"\\\"Upsamples underlying feature grid\\n\\n Args:\\n resolution: Target resolution.\\n \\\"\\\"\\\"\\n plane_coef = F.interpolate(\\n self.plane_coef.data, size=(resolution, resolution), mode=\\\"bilinear\\\", align_corners=True\\n )\\n\\n self.plane_coef = torch.nn.Parameter(plane_coef)\\n self.resolution = resolution\"\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\": \"TensoRFField\",\n \"path\": \"nerfstudio/fields/tensorf_field.py\",\n \"snippet\": \"class TensoRFField(Field):\\n \\\"\\\"\\\"TensoRF Field\\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n aabb: TensorType,\\n # the aabb bounding box of the dataset\\n feature_encoding: Encoding = Identity(in_dim=3),\\n # the encoding method used for appearance encoding outputs\\n direction_encoding: Encoding = Identity(in_dim=3),\\n # the encoding method used for ray direction\\n density_encoding: Encoding = Identity(in_dim=3),\\n # the tensor encoding method used for scene density\\n color_encoding: Encoding = Identity(in_dim=3),\\n # the tensor encoding method used for scene color\\n appearance_dim: int = 27,\\n # the number of dimensions for the appearance embedding\\n head_mlp_num_layers: int = 2,\\n # number of layers for the MLP\\n head_mlp_layer_width: int = 128,\\n # layer width for the MLP\\n use_sh: bool = False,\\n # whether to use spherical harmonics as the feature decoding function\\n sh_levels: int = 2,\\n # number of levels to use for spherical harmonics\\n ) -> None:\\n super().__init__()\\n self.aabb = Parameter(aabb, requires_grad=False)\\n self.feature_encoding = feature_encoding\\n self.direction_encoding = direction_encoding\\n self.density_encoding = density_encoding\\n self.color_encoding = color_encoding\\n\\n self.mlp_head = MLP(\\n in_dim=appearance_dim + 3 + self.direction_encoding.get_out_dim() + self.feature_encoding.get_out_dim(),\\n num_layers=head_mlp_num_layers,\\n layer_width=head_mlp_layer_width,\\n activation=nn.ReLU(),\\n out_activation=nn.ReLU(),\\n )\\n\\n self.use_sh = use_sh\\n\\n if self.use_sh:\\n self.sh = SHEncoding(sh_levels)\\n self.B = nn.Linear(\\n in_features=self.color_encoding.get_out_dim(), out_features=3 * self.sh.get_out_dim(), bias=False\\n )\\n else:\\n self.B = nn.Linear(in_features=self.color_encoding.get_out_dim(), out_features=appearance_dim, bias=False)\\n\\n self.field_output_rgb = RGBFieldHead(in_dim=self.mlp_head.get_out_dim(), activation=nn.Sigmoid())\\n\\n def get_density(self, ray_samples: RaySamples) -> TensorType:\\n positions = SceneBox.get_normalized_positions(ray_samples.frustums.get_positions(), self.aabb)\\n positions = positions * 2 - 1\\n density = self.density_encoding(positions)\\n density_enc = torch.sum(density, dim=-1)[:, :, None]\\n relu = torch.nn.ReLU()\\n density_enc = relu(density_enc)\\n return density_enc\\n\\n def get_outputs(self, ray_samples: RaySamples, density_embedding: Optional[TensorType] = None) -> TensorType:\\n d = ray_samples.frustums.directions\\n positions = SceneBox.get_normalized_positions(ray_samples.frustums.get_positions(), self.aabb)\\n positions = positions * 2 - 1\\n rgb_features = self.color_encoding(positions)\\n rgb_features = self.B(rgb_features)\\n\\n d_encoded = self.direction_encoding(d)\\n rgb_features_encoded = self.feature_encoding(rgb_features)\\n\\n if self.use_sh:\\n sh_mult = self.sh(d)[:, :, None]\\n rgb_sh = rgb_features.view(sh_mult.shape[0], sh_mult.shape[1], 3, sh_mult.shape[-1])\\n rgb = torch.relu(torch.sum(sh_mult * rgb_sh, dim=-1) + 0.5)\\n else:\\n out = self.mlp_head(torch.cat([rgb_features, d, rgb_features_encoded, d_encoded], dim=-1)) # type: ignore\\n rgb = self.field_output_rgb(out)\\n\\n return rgb\\n\\n def forward(\\n self,\\n ray_samples: RaySamples,\\n compute_normals: bool = False,\\n mask: Optional[TensorType] = None,\\n bg_color: Optional[TensorType] = None,\\n ) -> Dict[FieldHeadNames, TensorType]:\\n if compute_normals is True:\\n raise ValueError(\\\"Surface normals are not currently supported with TensoRF\\\")\\n if mask is not None and bg_color is not None:\\n base_density = torch.zeros(ray_samples.shape)[:, :, None].to(mask.device)\\n base_rgb = bg_color.repeat(ray_samples[:, :, None].shape)\\n if mask.any():\\n input_rays = ray_samples[mask, :]\\n density = self.get_density(input_rays)\\n rgb = self.get_outputs(input_rays, None)\\n\\n base_density[mask] = density\\n base_rgb[mask] = rgb\\n\\n base_density.requires_grad_()\\n base_rgb.requires_grad_()\\n\\n density = base_density\\n rgb = base_rgb\\n else:\\n density = self.get_density(ray_samples)\\n rgb = self.get_outputs(ray_samples, None)\\n\\n return {FieldHeadNames.DENSITY: density, FieldHeadNames.RGB: rgb}\"\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\": \"PDFSampler\",\n \"path\": \"nerfstudio/model_components/ray_samplers.py\",\n \"snippet\": \"class PDFSampler(Sampler):\\n \\\"\\\"\\\"Sample based on probability distribution\\n\\n Args:\\n num_samples: Number of samples per ray\\n train_stratified: Randomize location within each bin during training.\\n single_jitter: Use a same random jitter for all samples along a ray. Defaults to False\\n include_original: Add original samples to ray.\\n histogram_padding: Amount to weights prior to computing PDF.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n num_samples: Optional[int] = None,\\n train_stratified: bool = True,\\n single_jitter: bool = False,\\n include_original: bool = True,\\n histogram_padding: float = 0.01,\\n ) -> None:\\n super().__init__(num_samples=num_samples)\\n self.train_stratified = train_stratified\\n self.include_original = include_original\\n self.histogram_padding = histogram_padding\\n self.single_jitter = single_jitter\\n\\n def generate_ray_samples(\\n self,\\n ray_bundle: Optional[RayBundle] = None,\\n ray_samples: Optional[RaySamples] = None,\\n weights: TensorType[..., \\\"num_samples\\\", 1] = None,\\n num_samples: Optional[int] = None,\\n eps: float = 1e-5,\\n ) -> RaySamples:\\n \\\"\\\"\\\"Generates position samples given a distribution.\\n\\n Args:\\n ray_bundle: Rays to generate samples for\\n ray_samples: Existing ray samples\\n weights: Weights for each bin\\n num_samples: Number of samples per ray\\n eps: Small value to prevent numerical issues.\\n\\n Returns:\\n Positions and deltas for samples along a ray\\n \\\"\\\"\\\"\\n\\n if ray_samples is None or ray_bundle is None:\\n raise ValueError(\\\"ray_samples and ray_bundle must be provided\\\")\\n\\n num_samples = num_samples or self.num_samples\\n assert num_samples is not None\\n num_bins = num_samples + 1\\n\\n weights = weights[..., 0] + self.histogram_padding\\n\\n # Add small offset to rays with zero weight to prevent NaNs\\n weights_sum = torch.sum(weights, dim=-1, keepdim=True)\\n padding = torch.relu(eps - weights_sum)\\n weights = weights + padding / weights.shape[-1]\\n weights_sum += padding\\n\\n pdf = weights / weights_sum\\n cdf = torch.min(torch.ones_like(pdf), torch.cumsum(pdf, dim=-1))\\n cdf = torch.cat([torch.zeros_like(cdf[..., :1]), cdf], dim=-1)\\n\\n if self.train_stratified and self.training:\\n # Stratified samples between 0 and 1\\n u = torch.linspace(0.0, 1.0 - (1.0 / num_bins), steps=num_bins, device=cdf.device)\\n u = u.expand(size=(*cdf.shape[:-1], num_bins))\\n if self.single_jitter:\\n rand = torch.rand((*cdf.shape[:-1], 1), device=cdf.device) / num_bins\\n else:\\n rand = torch.rand((*cdf.shape[:-1], num_samples + 1), device=cdf.device) / num_bins\\n u = u + rand\\n else:\\n # Uniform samples between 0 and 1\\n u = torch.linspace(0.0, 1.0 - (1.0 / num_bins), steps=num_bins, device=cdf.device)\\n u = u + 1.0 / (2 * num_bins)\\n u = u.expand(size=(*cdf.shape[:-1], num_bins))\\n u = u.contiguous()\\n\\n assert (\\n ray_samples.spacing_starts is not None and ray_samples.spacing_ends is not None\\n ), \\\"ray_sample spacing_starts and spacing_ends must be provided\\\"\\n assert ray_samples.spacing_to_euclidean_fn is not None, \\\"ray_samples.spacing_to_euclidean_fn must be provided\\\"\\n existing_bins = torch.cat(\\n [\\n ray_samples.spacing_starts[..., 0],\\n ray_samples.spacing_ends[..., -1:, 0],\\n ],\\n dim=-1,\\n )\\n\\n inds = torch.searchsorted(cdf, u, side=\\\"right\\\")\\n below = torch.clamp(inds - 1, 0, existing_bins.shape[-1] - 1)\\n above = torch.clamp(inds, 0, existing_bins.shape[-1] - 1)\\n cdf_g0 = torch.gather(cdf, -1, below)\\n bins_g0 = torch.gather(existing_bins, -1, below)\\n cdf_g1 = torch.gather(cdf, -1, above)\\n bins_g1 = torch.gather(existing_bins, -1, above)\\n\\n t = torch.clip(torch.nan_to_num((u - cdf_g0) / (cdf_g1 - cdf_g0), 0), 0, 1)\\n bins = bins_g0 + t * (bins_g1 - bins_g0)\\n\\n if self.include_original:\\n bins, _ = torch.sort(torch.cat([existing_bins, bins], -1), -1)\\n\\n # Stop gradients\\n bins = bins.detach()\\n\\n euclidean_bins = ray_samples.spacing_to_euclidean_fn(bins)\\n\\n ray_samples = ray_bundle.get_ray_samples(\\n bin_starts=euclidean_bins[..., :-1, None],\\n bin_ends=euclidean_bins[..., 1:, None],\\n spacing_starts=bins[..., :-1, None],\\n spacing_ends=bins[..., 1:, None],\\n spacing_to_euclidean_fn=ray_samples.spacing_to_euclidean_fn,\\n )\\n\\n return ray_samples\"\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\": \"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\": \"AABBBoxCollider\",\n \"path\": \"nerfstudio/model_components/scene_colliders.py\",\n \"snippet\": \"class AABBBoxCollider(SceneCollider):\\n \\\"\\\"\\\"Module for colliding rays with the scene box to compute near and far values.\\n\\n Args:\\n scene_box: scene box to apply to dataset\\n \\\"\\\"\\\"\\n\\n def __init__(self, scene_box: SceneBox, near_plane: float = 0.0, **kwargs) -> None:\\n super().__init__(**kwargs)\\n self.scene_box = scene_box\\n self.near_plane = near_plane\\n\\n def _intersect_with_aabb(\\n self, rays_o: TensorType[\\\"num_rays\\\", 3], rays_d: TensorType[\\\"num_rays\\\", 3], aabb: TensorType[2, 3]\\n ):\\n \\\"\\\"\\\"Returns collection of valid rays within a specified near/far bounding box along with a mask\\n specifying which rays are valid\\n\\n Args:\\n rays_o: (num_rays, 3) ray origins\\n rays_d: (num_rays, 3) ray directions\\n aabb: (2, 3) This is [min point (x,y,z), max point (x,y,z)]\\n \\\"\\\"\\\"\\n # avoid divide by zero\\n dir_fraction = 1.0 / (rays_d + 1e-6)\\n\\n # x\\n t1 = (aabb[0, 0] - rays_o[:, 0:1]) * dir_fraction[:, 0:1]\\n t2 = (aabb[1, 0] - rays_o[:, 0:1]) * dir_fraction[:, 0:1]\\n # y\\n t3 = (aabb[0, 1] - rays_o[:, 1:2]) * dir_fraction[:, 1:2]\\n t4 = (aabb[1, 1] - rays_o[:, 1:2]) * dir_fraction[:, 1:2]\\n # z\\n t5 = (aabb[0, 2] - rays_o[:, 2:3]) * dir_fraction[:, 2:3]\\n t6 = (aabb[1, 2] - rays_o[:, 2:3]) * dir_fraction[:, 2:3]\\n\\n nears = torch.max(\\n torch.cat([torch.minimum(t1, t2), torch.minimum(t3, t4), torch.minimum(t5, t6)], dim=1), dim=1\\n ).values\\n fars = torch.min(\\n torch.cat([torch.maximum(t1, t2), torch.maximum(t3, t4), torch.maximum(t5, t6)], dim=1), dim=1\\n ).values\\n\\n # clamp to near plane\\n near_plane = self.near_plane if self.training else 0\\n nears = torch.clamp(nears, min=near_plane)\\n fars = torch.maximum(fars, nears + 1e-6)\\n\\n return nears, fars\\n\\n def set_nears_and_fars(self, ray_bundle: RayBundle) -> RayBundle:\\n \\\"\\\"\\\"Intersects the rays with the scene box and updates the near and far values.\\n Populates nears and fars fields and returns the ray_bundle.\\n\\n Args:\\n ray_bundle: specified ray bundle to operate on\\n \\\"\\\"\\\"\\n aabb = self.scene_box.aabb\\n nears, fars = self._intersect_with_aabb(ray_bundle.origins, ray_bundle.directions, aabb)\\n ray_bundle.nears = nears[..., None]\\n ray_bundle.fars = fars[..., None]\\n return ray_bundle\"\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\": \"colors\",\n \"path\": \"nerfstudio/utils/colors.py\",\n \"snippet\": \"WHITE = torch.tensor([1.0, 1.0, 1.0])\\nBLACK = torch.tensor([0.0, 0.0, 0.0])\\nRED = torch.tensor([1.0, 0.0, 0.0])\\nGREEN = torch.tensor([0.0, 1.0, 0.0])\\nBLUE = torch.tensor([0.0, 0.0, 1.0])\\nCOLORS_DICT = {\\n \\\"white\\\": WHITE,\\n \\\"black\\\": BLACK,\\n \\\"red\\\": RED,\\n \\\"green\\\": GREEN,\\n \\\"blue\\\": BLUE,\\n}\\ndef get_color(color: Union[str, list]) -> TensorType[3]:\"\n },\n {\n \"identifier\": \"misc\",\n \"path\": \"nerfstudio/utils/misc.py\",\n \"snippet\": \"def get_dict_to_torch(stuff: Any, device: Union[torch.device, str] = \\\"cpu\\\", exclude: Optional[List[str]] = None):\\ndef get_dict_to_cpu(stuff: Any):\\ndef get_masked_dict(d, mask):\\n def __init__(self, new_iter: Callable, new_next: Callable, length: int = -1):\\n def __next__(self):\\n def __iter__(self):\\ndef scale_dict(dictionary: Dict[Any, Any], coefficients: Dict[str, float]) -> Dict[Any, Any]:\\ndef step_check(step, step_size, run_at_zero=False) -> bool:\\ndef update_avg(prev_avg: float, new_val: float, step: int) -> float:\\ndef strtobool(val) -> bool:\\nclass IterableWrapper: # pylint: disable=too-few-public-methods\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from dataclasses import dataclass, field\nfrom typing import Dict, List, Tuple, Type\nfrom torch.nn import Parameter\nfrom torchmetrics import PeakSignalNoiseRatio\nfrom torchmetrics.functional import structural_similarity_index_measure\nfrom torchmetrics.image.lpip import LearnedPerceptualImagePatchSimilarity\nfrom typing_extensions import Literal\nfrom nerfstudio.cameras.rays import RayBundle\nfrom nerfstudio.configs.config_utils import to_immutable_dict\nfrom nerfstudio.engine.callbacks import (\n TrainingCallback,\n TrainingCallbackAttributes,\n TrainingCallbackLocation,\n)\nfrom nerfstudio.field_components.encodings import (\n NeRFEncoding,\n TensorCPEncoding,\n TensorVMEncoding,\n TriplaneEncoding,\n)\nfrom nerfstudio.field_components.field_heads import FieldHeadNames\nfrom nerfstudio.fields.tensorf_field import TensoRFField\nfrom nerfstudio.model_components.losses import MSELoss\nfrom nerfstudio.model_components.ray_samplers import PDFSampler, UniformSampler\nfrom nerfstudio.model_components.renderers import (\n AccumulationRenderer,\n DepthRenderer,\n RGBRenderer,\n)\nfrom nerfstudio.model_components.scene_colliders import AABBBoxCollider\nfrom nerfstudio.models.base_model import Model, ModelConfig\nfrom nerfstudio.utils import colormaps, colors, misc\nimport numpy as np\nimport torch"},"token_num":{"kind":"number","value":15552,"string":"15,552"},"cropped_code":{"kind":"string","value":" np.exp(\n np.linspace(\n np.log(config.init_resolution),\n np.log(config.final_resolution),\n len(config.upsampling_iters) + 1,\n )\n )\n )\n .astype(\"int\")\n .tolist()[1:]\n )\n super().__init__(config=config, **kwargs)\n\n def get_training_callbacks(\n self, training_callback_attributes: TrainingCallbackAttributes\n ) -> List[TrainingCallback]:\n\n # the callback that we want to run every X iterations after the training iteration\n def reinitialize_optimizer(\n self, training_callback_attributes: TrainingCallbackAttributes, step: int # pylint: disable=unused-argument\n ):\n index = self.upsampling_iters.index(step)\n resolution = self.upsampling_steps[index]\n\n # upsample the position and direction grids\n self.field.density_encoding.upsample_grid(resolution)\n self.field.color_encoding.upsample_grid(resolution)\n\n # reinitialize the encodings optimizer\n optimizers_config = training_callback_attributes.optimizers.config\n enc = training_callback_attributes.pipeline.get_param_groups()[\"encodings\"]\n lr_init = optimizers_config[\"encodings\"][\"optimizer\"].lr\n\n training_callback_attributes.optimizers.optimizers[\"encodings\"] = optimizers_config[\"encodings\"][\n \"optimizer\"\n ].setup(params=enc)\n if optimizers_config[\"encodings\"][\"scheduler\"]:\n training_callback_attributes.optimizers.schedulers[\"encodings\"] = (\n optimizers_config[\"encodings\"][\"scheduler\"]\n .setup()\n .get_scheduler(\n optimizer=training_callback_attributes.optimizers.optimizers[\"encodings\"], lr_init=lr_init\n )\n )\n\n callbacks = [\n TrainingCallback(\n where_to_run=[TrainingCallbackLocation.AFTER_TRAIN_ITERATION],\n iters=self.upsampling_iters,\n func=reinitialize_optimizer,\n args=[self, training_callback_attributes],\n )\n ]\n return callbacks\n\n def update_to_step(self, step: int) -> None:\n if step < self.upsampling_iters[0]:\n return\n\n new_iters = list(self.upsampling_iters) + [step + 1]\n new_iters.sort()\n\n index = new_iters.index(step + 1)\n new_grid_resolution = self.upsampling_steps[index - 1]\n\n self.field.density_encoding.upsample_grid(new_grid_resolution) # type: ignore\n self.field.color_encoding.upsample_grid(new_grid_resolution) # type: ignore\n\n def populate_modules(self):\n \"\"\"Set the fields and modules\"\"\"\n super().populate_modules()\n\n # setting up fields\n if self.config.tensorf_encoding == \"vm\":\n density_encoding = TensorVMEncoding(\n resolution=self.init_resolution,\n num_components=self.num_den_components,\n )\n color_encoding = TensorVMEncoding(\n resolution=self.init_resolution,\n num_components=self.num_color_components,\n )\n elif self.config.tensorf_encoding == \"cp\":\n density_encoding = TensorCPEncoding(\n resolution=self.init_resolution,\n num_components=self.num_den_components,\n )\n color_encoding = TensorCPEncoding(\n resolution=self.init_resolution,\n num_components=self.num_color_components,\n )\n elif self.config.tensorf_encoding == \"triplane\":\n density_encoding = TriplaneEncoding(\n resolution=self.init_resolution,\n num_components=self.num_den_components,\n )\n color_encoding = TriplaneEncoding(\n resolution=self.init_resolution,\n num_components=self.num_color_components,\n )\n else:\n raise ValueError(f\"Encoding {self.config.tensorf_encoding} not supported\")\n\n feature_encoding = NeRFEncoding(in_dim=self.appearance_dim, num_frequencies=2, min_freq_exp=0, max_freq_exp=2)\n direction_encoding = NeRFEncoding(in_dim=3, num_frequencies=2, min_freq_exp=0, max_freq_exp=2)\n\n self.field = TensoRFField(\n self.scene_box.aabb,\n feature_encoding=feature_encoding,\n direction_encoding=direction_encoding,\n density_encoding=density_encoding,\n color_encoding=color_encoding,\n appearance_dim=self.appearance_dim,\n head_mlp_num_layers=2,\n head_mlp_layer_width=128,\n use_sh=False,\n )\n\n # samplers\n self.sampler_uniform = UniformSampler(num_samples=self.config.num_samples, single_jitter=True)\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\"\"\"\nTensorRF implementation.\n\"\"\"\n\nfrom __future__ import annotations\n\n\n\n\n\n@dataclass\nclass TensoRFModelConfig(ModelConfig):\n \"\"\"TensoRF model config\"\"\"\n\n _target: Type = field(default_factory=lambda: TensoRFModel)\n \"\"\"target class to instantiate\"\"\"\n init_resolution: int = 128\n \"\"\"initial render resolution\"\"\"\n final_resolution: int = 300\n \"\"\"final render resolution\"\"\"\n upsampling_iters: Tuple[int, ...] = (2000, 3000, 4000, 5500, 7000)\n \"\"\"specifies a list of iteration step numbers to perform upsampling\"\"\"\n loss_coefficients: Dict[str, float] = to_immutable_dict({\"rgb_loss\": 1.0})\n \"\"\"Loss specific weights.\"\"\"\n num_samples: int = 256\n \"\"\"Number of samples in field evaluation\"\"\"\n num_den_components: int = 16\n \"\"\"Number of components in density encoding\"\"\"\n num_color_components: int = 48\n \"\"\"Number of components in color encoding\"\"\"\n appearance_dim: int = 27\n \"\"\"Number of channels for color encoding\"\"\"\n tensorf_encoding: Literal[\"triplane\", \"vm\", \"cp\"] = \"vm\"\n\n\nclass TensoRFModel(Model):\n \"\"\"TensoRF Model\n\n Args:\n config: TensoRF configuration to instantiate model\n \"\"\"\n\n def __init__(\n self,\n config: TensoRFModelConfig,\n **kwargs,\n ) -> None:\n self.init_resolution = config.init_resolution\n self.upsampling_iters = config.upsampling_iters\n self.num_den_components = config.num_den_components\n self.num_color_components = config.num_color_components\n self.appearance_dim = config.appearance_dim\n self.upsampling_steps = (\n np.round(\n np.exp(\n np.linspace(\n np.log(config.init_resolution),\n np.log(config.final_resolution),\n len(config.upsampling_iters) + 1,\n )\n )\n )\n .astype(\"int\")\n .tolist()[1:]\n )\n super().__init__(config=config, **kwargs)\n\n def get_training_callbacks(\n self, training_callback_attributes: TrainingCallbackAttributes\n ) -> List[TrainingCallback]:\n\n # the callback that we want to run every X iterations after the training iteration\n def reinitialize_optimizer(\n self, training_callback_attributes: TrainingCallbackAttributes, step: int # pylint: disable=unused-argument\n ):\n index = self.upsampling_iters.index(step)\n resolution = self.upsampling_steps[index]\n\n # upsample the position and direction grids\n self.field.density_encoding.upsample_grid(resolution)\n self.field.color_encoding.upsample_grid(resolution)\n\n # reinitialize the encodings optimizer\n optimizers_config = training_callback_attributes.optimizers.config\n enc = training_callback_attributes.pipeline.get_param_groups()[\"encodings\"]\n lr_init = optimizers_config[\"encodings\"][\"optimizer\"].lr\n\n training_callback_attributes.optimizers.optimizers[\"encodings\"] = optimizers_config[\"encodings\"][\n \"optimizer\"\n ].setup(params=enc)\n if optimizers_config[\"encodings\"][\"scheduler\"]:\n training_callback_attributes.optimizers.schedulers[\"encodings\"] = (\n optimizers_config[\"encodings\"][\"scheduler\"]\n .setup()\n .get_scheduler(\n optimizer=training_callback_attributes.optimizers.optimizers[\"encodings\"], lr_init=lr_init\n )\n )\n\n callbacks = [\n TrainingCallback(\n where_to_run=[TrainingCallbackLocation.AFTER_TRAIN_ITERATION],\n iters=self.upsampling_iters,\n func=reinitialize_optimizer,\n args=[self, training_callback_attributes],\n )\n ]\n return callbacks\n\n def update_to_step(self, step: int) -> None:\n if step < self.upsampling_iters[0]:\n return\n\n new_iters = list(self.upsampling_iters) + [step + 1]\n new_iters.sort()\n\n index = new_iters.index(step + 1)\n new_grid_resolution = self.upsampling_steps[index - 1]\n\n self.field.density_encoding.upsample_grid(new_grid_resolution) # type: ignore\n self.field.color_encoding.upsample_grid(new_grid_resolution) # type: ignore\n\n def populate_modules(self):\n \"\"\"Set the fields and modules\"\"\"\n super().populate_modules()\n\n # setting up fields\n if self.config.tensorf_encoding == \"vm\":\n density_encoding = TensorVMEncoding(\n resolution=self.init_resolution,\n num_components=self.num_den_components,\n )\n color_encoding = TensorVMEncoding(\n resolution=self.init_resolution,\n num_components=self.num_color_components,\n )\n elif self.config.tensorf_encoding == \"cp\":\n density_encoding = TensorCPEncoding(\n resolution=self.init_resolution,\n num_components=self.num_den_components,\n )\n color_encoding = TensorCPEncoding(\n resolution=self.init_resolution,\n num_components=self.num_color_components,\n )\n elif self.config.tensorf_encoding == \"triplane\":\n density_encoding = TriplaneEncoding(\n resolution=self.init_resolution,\n num_components=self.num_den_components,\n )\n color_encoding = TriplaneEncoding(\n resolution=self.init_resolution,\n num_components=self.num_color_components,\n )\n else:\n raise ValueError(f\"Encoding {self.config.tensorf_encoding} not supported\")\n\n feature_encoding = NeRFEncoding(in_dim=self.appearance_dim, num_frequencies=2, min_freq_exp=0, max_freq_exp=2)\n direction_encoding = NeRFEncoding(in_dim=3, num_frequencies=2, min_freq_exp=0, max_freq_exp=2)\n\n self.field = TensoRFField(\n self.scene_box.aabb,\n feature_encoding=feature_encoding,\n direction_encoding=direction_encoding,\n density_encoding=density_encoding,\n color_encoding=color_encoding,\n appearance_dim=self.appearance_dim,\n head_mlp_num_layers=2,\n head_mlp_layer_width=128,\n use_sh=False,\n )\n\n # samplers\n self.sampler_uniform = UniformSampler(num_samples=self.config.num_samples, single_jitter=True)"},"next_line":{"kind":"string","value":" self.sampler_pdf = PDFSampler(num_samples=self.config.num_samples // 2, single_jitter=True)"},"gold_snippet_index":{"kind":"number","value":12,"string":"12"},"created_at":{"kind":"string","value":"2023-10-26 04:39:15+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5997,"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":19488,"string":"19,488"},"cropped_code":{"kind":"string","value":"\n\n\n\nPROCESS_FUNC = {\n \"QM9\": ProcessedQM9,\n \"DoubleQM9\": ProcessedDoubleQM9,\n \"TripleQM9\": ProcessedTripleQM9,\n"},"all_code":{"kind":"string","value":"\n\n\n\nPROCESS_FUNC = {\n \"QM9\": ProcessedQM9,\n \"DoubleQM9\": ProcessedDoubleQM9,\n \"TripleQM9\": ProcessedTripleQM9,"},"next_line":{"kind":"string","value":" \"TS1x\": ProcessedTS1x,"},"gold_snippet_index":{"kind":"number","value":3,"string":"3"},"created_at":{"kind":"string","value":"2023-10-30 02:53:38+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5998,"cells":{"repo_name":{"kind":"string","value":"nv-tlabs/pacer"},"file_path":{"kind":"string","value":"pacer/env/tasks/humanoid_amp.py"},"context":{"kind":"list like","value":[{"identifier":"MotionLib","path":"pacer/utils/motion_lib.py","snippet":"class MotionLib():\n def __init__(self, motion_file, dof_body_ids, dof_offsets, key_body_ids,\n device):\n self._dof_body_ids = dof_body_ids\n self._dof_offsets = dof_offsets\n self._num_dof = dof_offsets[-1]\n self._key_body_ids = torch.tensor(key_body_ids, device=device)\n self._device = device\n\n self._load_motions(motion_file)\n motions = self._motions\n self.gts = torch.cat([m.global_translation for m in motions],\n dim=0).float()\n self.grs = torch.cat([m.global_rotation for m in motions],\n dim=0).float()\n self.lrs = torch.cat([m.local_rotation for m in motions],\n dim=0).float()\n self.grvs = torch.cat([m.global_root_velocity for m in motions],\n dim=0).float()\n self.gravs = torch.cat(\n [m.global_root_angular_velocity for m in motions], dim=0).float()\n self.dvs = torch.cat([m.dof_vels for m in motions], dim=0).float()\n\n self.lrs[0]\n\n lengths = self._motion_num_frames\n lengths_shifted = lengths.roll(1)\n lengths_shifted[0] = 0\n self.length_starts = lengths_shifted.cumsum(0)\n\n self.motion_ids = torch.arange(len(self._motions),\n dtype=torch.long,\n device=self._device)\n\n\n return\n\n def num_motions(self):\n return len(self._motions)\n\n def get_total_length(self):\n return sum(self._motion_lengths)\n\n def get_motion(self, motion_id):\n return self._motions[motion_id]\n\n def sample_motions(self, n):\n motion_ids = torch.multinomial(self._motion_weights,\n num_samples=n,\n replacement=True)\n\n # m = self.num_motions()\n # motion_ids = np.random.choice(m, size=n, replace=True, p=self._motion_weights)\n # motion_ids = torch.tensor(motion_ids, device=self._device, dtype=torch.long)\n return motion_ids\n\n def sample_time(self, motion_ids, truncate_time=None):\n n = len(motion_ids)\n phase = torch.rand(motion_ids.shape, device=self._device)\n motion_len = self._motion_lengths[motion_ids]\n if (truncate_time is not None):\n assert (truncate_time >= 0.0)\n motion_len -= truncate_time\n\n motion_time = phase * motion_len\n return motion_time\n\n def get_motion_length(self, motion_ids):\n return self._motion_lengths[motion_ids]\n\n def get_motion_state_smpl(self, motion_ids, motion_times):\n n = len(motion_ids)\n num_bodies = self._get_num_bodies()\n num_key_bodies = self._key_body_ids.shape[0]\n\n motion_len = self._motion_lengths[motion_ids]\n num_frames = self._motion_num_frames[motion_ids]\n dt = self._motion_dt[motion_ids]\n\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\n motion_times, motion_len, num_frames, dt)\n\n f0l = frame_idx0 + self.length_starts[motion_ids]\n f1l = frame_idx1 + self.length_starts[motion_ids]\n\n root_pos0 = self.gts[f0l, 0]\n root_pos1 = self.gts[f1l, 0]\n\n root_rot0 = self.grs[f0l, 0]\n root_rot1 = self.grs[f1l, 0]\n\n local_rot0 = self.lrs[f0l]\n local_rot1 = self.lrs[f1l]\n\n root_vel = self.grvs[f0l]\n\n root_ang_vel = self.gravs[f0l]\n\n rg_pos0 = self.gts[f0l, :]\n rg_pos1 = self.gts[f1l, :]\n\n dof_vel = self.dvs[f0l]\n\n vals = [\n root_pos0, root_pos1, local_rot0, local_rot1, root_vel,\n root_ang_vel, rg_pos0, rg_pos1\n ]\n for v in vals:\n assert v.dtype != torch.float64\n\n blend = blend.unsqueeze(-1)\n\n root_pos = (1.0 - blend) * root_pos0 + blend * root_pos1\n\n root_rot = torch_utils.slerp(root_rot0, root_rot1, blend)\n\n blend_exp = blend.unsqueeze(-1)\n rg_pos = (1.0 - blend_exp) * rg_pos0 + blend_exp * rg_pos1\n key_pos = rg_pos[:, self._key_body_ids]\n\n local_rot = torch_utils.slerp(local_rot0, local_rot1,\n torch.unsqueeze(blend, axis=-1))\n dof_pos = self._local_rotation_to_dof(local_rot)\n\n rb_rot0 = self.grs[f0l]\n rb_rot1 = self.grs[f1l]\n rb_rot = torch_utils.slerp(rb_rot0, rb_rot1, blend_exp)\n\n # import ipdb\n # ipdb.set_trace()\n # self.torch_humanoid.fk_batch()\n return root_pos, root_rot, dof_pos, root_vel, root_ang_vel, dof_vel, key_pos, self._motion_bodies[\n motion_ids], self._motion_aa[f0l], rg_pos, rb_rot\n\n def get_motion_state(self, motion_ids, motion_times):\n n = len(motion_ids)\n num_bodies = self._get_num_bodies()\n num_key_bodies = self._key_body_ids.shape[0]\n\n motion_len = self._motion_lengths[motion_ids]\n num_frames = self._motion_num_frames[motion_ids]\n dt = self._motion_dt[motion_ids]\n\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\n motion_times, motion_len, num_frames, dt)\n\n f0l = frame_idx0 + self.length_starts[motion_ids]\n f1l = frame_idx1 + self.length_starts[motion_ids]\n\n root_pos0 = self.gts[f0l, 0]\n root_pos1 = self.gts[f1l, 0]\n\n root_rot0 = self.grs[f0l, 0]\n root_rot1 = self.grs[f1l, 0]\n\n local_rot0 = self.lrs[f0l]\n local_rot1 = self.lrs[f1l]\n\n root_vel = self.grvs[f0l]\n\n root_ang_vel = self.gravs[f0l]\n\n key_pos0 = self.gts[f0l.unsqueeze(-1), self._key_body_ids.unsqueeze(0)]\n key_pos1 = self.gts[f1l.unsqueeze(-1), self._key_body_ids.unsqueeze(0)]\n\n dof_vel = self.dvs[f0l]\n\n vals = [\n root_pos0, root_pos1, local_rot0, local_rot1, root_vel,\n root_ang_vel, key_pos0, key_pos1\n ]\n for v in vals:\n assert v.dtype != torch.float64\n\n blend = blend.unsqueeze(-1)\n\n root_pos = (1.0 - blend) * root_pos0 + blend * root_pos1\n\n root_rot = torch_utils.slerp(root_rot0, root_rot1, blend)\n\n blend_exp = blend.unsqueeze(-1)\n key_pos = (1.0 - blend_exp) * key_pos0 + blend_exp * key_pos1\n\n local_rot = torch_utils.slerp(local_rot0, local_rot1,\n torch.unsqueeze(blend, axis=-1))\n dof_pos = self._local_rotation_to_dof(local_rot)\n\n return root_pos, root_rot, dof_pos, root_vel, root_ang_vel, dof_vel, key_pos\n\n def _load_motions(self, motion_file):\n self._motions = []\n self._motion_lengths = []\n self._motion_weights = []\n self._motion_fps = []\n self._motion_dt = []\n self._motion_num_frames = []\n self._motion_files = []\n self._motion_bodies = []\n self._motion_aa = []\n self._motion_quat = []\n\n total_len = 0.0\n\n motion_files, motion_weights = self._fetch_motion_files(motion_file)\n num_motion_files = len(motion_files)\n for f in tqdm(range(num_motion_files)):\n curr_file = motion_files[f]\n\n if (isinstance(curr_file, str)):\n print(\"Loading {:d}/{:d} motion files: {:s}\".format(\n f + 1, num_motion_files, curr_file))\n motion_file_data = np.load(curr_file, allow_pickle=True).item()\n curr_motion = SkeletonMotion.from_dict(motion_file_data)\n elif (isinstance(curr_file, dict)):\n motion_file_data = curr_file\n curr_motion = SkeletonMotion.from_dict(curr_file)\n\n if \"beta\" in motion_file_data:\n beta, gender, pose_aa = motion_file_data[\n 'beta'], motion_file_data['gender'], motion_file_data[\n 'pose_aa']\n\n if isinstance(gender, bytes):\n gender = gender.decode(\"utf-8\")\n if gender == \"neutral\":\n gender = [0]\n elif gender == \"male\":\n gender = [1]\n elif gender == \"female\":\n gender = [2]\n else:\n import ipdb\n ipdb.set_trace()\n raise Exception(\"Gender Not Supported!!\")\n self._motion_aa.append(pose_aa.reshape(-1, 72))\n self._motion_bodies.append(np.concatenate((gender, beta)))\n else:\n seq_len, _, _ = curr_file['rotation']['arr'].shape\n self._motion_bodies.append(np.zeros(17))\n self._motion_quat.append(np.zeros([seq_len, 96]))\n self._motion_aa.append(np.zeros([seq_len, 72]))\n\n motion_fps = curr_motion.fps\n curr_dt = 1.0 / motion_fps\n\n num_frames = curr_motion.tensor.shape[0]\n curr_len = 1.0 / motion_fps * (num_frames - 1)\n\n self._motion_fps.append(motion_fps)\n self._motion_dt.append(curr_dt)\n self._motion_num_frames.append(num_frames)\n\n curr_dof_vels = self._compute_motion_dof_vels(curr_motion)\n curr_motion.dof_vels = curr_dof_vels\n\n # Moving motion tensors to the GPU\n if USE_CACHE:\n curr_motion = DeviceCache(curr_motion, self._device)\n else:\n curr_motion.tensor = curr_motion.tensor.to(self._device)\n curr_motion._skeleton_tree._parent_indices = curr_motion._skeleton_tree._parent_indices.to(\n self._device)\n curr_motion._skeleton_tree._local_translation = curr_motion._skeleton_tree._local_translation.to(\n self._device)\n curr_motion._rotation = curr_motion._rotation.to(self._device)\n\n self._motions.append(curr_motion)\n self._motion_lengths.append(curr_len)\n\n curr_weight = motion_weights[f]\n self._motion_weights.append(curr_weight)\n self._motion_files.append(curr_file)\n # jp hack\n #self._hack_test_vel_consistency(curr_motion)\n\n self._motion_lengths = torch.tensor(self._motion_lengths,\n device=self._device,\n dtype=torch.float32)\n\n self._motion_weights = torch.tensor(self._motion_weights,\n dtype=torch.float32,\n device=self._device)\n self._motion_weights /= self._motion_weights.sum()\n\n self._motion_fps = torch.tensor(self._motion_fps,\n device=self._device,\n dtype=torch.float32)\n self._motion_bodies = torch.tensor(self._motion_bodies,\n device=self._device,\n dtype=torch.float32)\n self._motion_aa = torch.tensor(np.concatenate(self._motion_aa),\n device=self._device,\n dtype=torch.float32)\n self._motion_quat = torch.tensor(np.concatenate(self._motion_quat),\n device=self._device,\n dtype=torch.float32)\n \n self._motion_dt = torch.tensor(self._motion_dt,\n device=self._device,\n dtype=torch.float32)\n self._motion_num_frames = torch.tensor(self._motion_num_frames,\n device=self._device)\n\n num_motions = self.num_motions()\n total_len = self.get_total_length()\n\n print(\"Loaded {:d} motions with a total length of {:.3f}s.\".format(\n num_motions, total_len))\n\n # self.torch_humanoid.update_model(self._motion_bodies[:, 1:],\n # self._motion_bodies[:, 0])\n\n return\n\n def _fetch_motion_files(self, motion_file):\n ext = os.path.splitext(motion_file)[1]\n if (ext == \".yaml\"):\n dir_name = os.path.dirname(motion_file)\n motion_files = []\n motion_weights = []\n\n with open(os.path.join(os.getcwd(), motion_file), 'r') as f:\n motion_config = yaml.load(f, Loader=yaml.SafeLoader)\n\n motion_list = motion_config['motions']\n for motion_entry in motion_list:\n curr_file = motion_entry['file']\n curr_weight = motion_entry['weight']\n assert (curr_weight >= 0)\n\n curr_file = os.path.join(dir_name, curr_file)\n motion_weights.append(curr_weight)\n motion_files.append(curr_file)\n\n elif (ext == \".pkl\"):\n motion_data = joblib.load(motion_file)\n motion_files = list(motion_data.values())\n motion_weights = [1 / len(motion_files)] * len(motion_files)\n\n # motion_lens = [v['rotation']['arr'].shape[0] for v in motion_files]\n # motion_weights = np.array(motion_lens)/np.sum(motion_lens)\n\n else:\n motion_files = [motion_file]\n motion_weights = [1.0]\n\n return motion_files, motion_weights\n\n def _calc_frame_blend(self, time, len, num_frames, dt):\n\n phase = time / len\n phase = torch.clip(phase, 0.0, 1.0)\n\n frame_idx0 = (phase * (num_frames - 1)).long()\n frame_idx1 = torch.min(frame_idx0 + 1, num_frames - 1)\n blend = (time - frame_idx0 * dt) / dt\n\n return frame_idx0, frame_idx1, blend\n\n def _get_num_bodies(self):\n motion = self.get_motion(0)\n num_bodies = motion.num_joints\n return num_bodies\n\n def _compute_motion_dof_vels(self, motion):\n num_frames = motion.tensor.shape[0]\n dt = 1.0 / motion.fps\n dof_vels = []\n\n for f in range(num_frames - 1):\n local_rot0 = motion.local_rotation[f]\n local_rot1 = motion.local_rotation[f + 1]\n frame_dof_vel = self._local_rotation_to_dof_vel(\n local_rot0, local_rot1, dt)\n frame_dof_vel = frame_dof_vel\n dof_vels.append(frame_dof_vel)\n\n dof_vels.append(dof_vels[-1])\n dof_vels = torch.stack(dof_vels, dim=0)\n\n return dof_vels\n\n # jp hack\n # get rid of this ASAP, need a proper way of projecting from max coords to reduced coords\n def _local_rotation_to_dof(self, local_rot):\n body_ids = self._dof_body_ids\n dof_offsets = self._dof_offsets\n\n n = local_rot.shape[0]\n dof_pos = torch.zeros((n, self._num_dof),\n dtype=torch.float,\n device=self._device)\n\n for j in range(len(body_ids)):\n body_id = body_ids[j]\n joint_offset = dof_offsets[j]\n joint_size = dof_offsets[j + 1] - joint_offset\n\n if (joint_size == 3):\n joint_q = local_rot[:, body_id]\n joint_exp_map = torch_utils.quat_to_exp_map(joint_q)\n dof_pos[:, joint_offset:(joint_offset +\n joint_size)] = joint_exp_map\n elif (joint_size == 1):\n joint_q = local_rot[:, body_id]\n joint_theta, joint_axis = torch_utils.quat_to_angle_axis(\n joint_q)\n joint_theta = joint_theta * joint_axis[\n ..., 1] # assume joint is always along y axis\n\n joint_theta = normalize_angle(joint_theta)\n dof_pos[:, joint_offset] = joint_theta\n\n else:\n print(\"Unsupported joint type\")\n assert (False)\n\n return dof_pos\n\n def _local_rotation_to_dof_vel(self, local_rot0, local_rot1, dt):\n body_ids = self._dof_body_ids\n dof_offsets = self._dof_offsets\n\n dof_vel = torch.zeros([self._num_dof], device=self._device)\n\n diff_quat_data = quat_mul_norm(quat_inverse(local_rot0), local_rot1)\n diff_angle, diff_axis = quat_angle_axis(diff_quat_data)\n local_vel = diff_axis * diff_angle.unsqueeze(-1) / dt\n local_vel = local_vel\n for j in range(len(body_ids)):\n body_id = body_ids[j]\n joint_offset = dof_offsets[j]\n joint_size = dof_offsets[j + 1] - joint_offset\n\n if (joint_size == 3):\n joint_vel = local_vel[body_id]\n dof_vel[joint_offset:(joint_offset + joint_size)] = joint_vel\n\n elif (joint_size == 1):\n assert (joint_size == 1)\n joint_vel = local_vel[body_id]\n dof_vel[joint_offset] = joint_vel[\n 1] # assume joint is always along y axis\n\n else:\n print(\"Unsupported joint type\")\n assert (False)\n\n return dof_vel\n\n # jp hack\n def _hack_test_vel_consistency(self, motion):\n test_vel = np.loadtxt(\"output/vel.txt\", delimiter=\",\")\n test_root_vel = test_vel[:, :3]\n test_root_ang_vel = test_vel[:, 3:6]\n test_dof_vel = test_vel[:, 6:]\n\n dof_vel = motion.dof_vels\n dof_vel_err = test_dof_vel[:-1] - dof_vel[:-1]\n dof_vel_err = np.max(np.abs(dof_vel_err))\n\n root_vel = motion.global_root_velocity.numpy()\n root_vel_err = test_root_vel[:-1] - root_vel[:-1]\n root_vel_err = np.max(np.abs(root_vel_err))\n\n root_ang_vel = motion.global_root_angular_velocity.numpy()\n root_ang_vel_err = test_root_ang_vel[:-1] - root_ang_vel[:-1]\n root_ang_vel_err = np.max(np.abs(root_ang_vel_err))\n\n return"},{"identifier":"MotionLib","path":"pacer/utils/motion_lib_smpl.py","snippet":"class MotionLib():\n def __init__(self, motion_file, key_body_ids, device, fix_height = True, masterfoot_conifg = None, min_length = -1):\n self._key_body_ids = torch.tensor(key_body_ids, device=device)\n self._device = device\n self._motion_data = joblib.load(motion_file)\n\n if min_length != -1:\n data_list = {k: v for k, v in list(self._motion_data.items()) if len(v['pose_quat_global']) >= min_length}\n self._motion_data_list = np.array(list(data_list.values()))\n self._motion_data_keys = np.array(list(data_list.keys()))\n else:\n self._motion_data_list = np.array(list(self._motion_data.values()))\n self._motion_data_keys = np.array(list(self._motion_data.keys()))\n self._num_unique_motions = len(self._motion_data_list)\n\n\n self._masterfoot_conifg = masterfoot_conifg\n data_dir = \"data/smpl\"\n smpl_parser_n = SMPL_Parser(model_path=data_dir,\n gender=\"neutral\")\n smpl_parser_m = SMPL_Parser(model_path=data_dir,\n gender=\"male\")\n smpl_parser_f = SMPL_Parser(model_path=data_dir,\n gender=\"female\")\n self.smpl_parsers = {\n 0: smpl_parser_n,\n 1: smpl_parser_m,\n 2: smpl_parser_f\n }\n self.fix_height = fix_height\n\n #### Termination history\n self._curr_motion_ids = None\n self._termination_history = torch.zeros(self._num_unique_motions)\n self._success_rate = torch.zeros(self._num_unique_motions)\n self._sampling_history = torch.zeros(self._num_unique_motions)\n self._sampling_prob = torch.ones(self._num_unique_motions)/self._num_unique_motions # For use in sampling batches\n self._sampling_batch_prob = None # For use in sampling within batches\n return\n\n def load_motions(self, skeleton_trees, gender_betas, limb_weights, random_sample = True, start_idx = 0):\n # load motion load the same number of motions as there are skeletons (humanoids)\n if \"gts\" in self.__dict__:\n del self.gts , self.grs , self.lrs, self.grvs, self.gravs , self.gavs , self.gvs, self.dvs,\n del self._motion_lengths, self._motion_fps, self._motion_dt, self._motion_num_frames, self._motion_bodies, self._motion_aa , self._motion_quat\n\n motions = []\n self._motion_lengths = []\n self._motion_fps = []\n self._motion_dt = []\n self._motion_num_frames = []\n self._motion_bodies = []\n self._motion_aa = []\n self._motion_quat = []\n\n torch.cuda.empty_cache()\n gc.collect()\n\n total_len = 0.0\n num_motion_to_load = len(skeleton_trees)\n\n if random_sample:\n sample_idxes = torch.multinomial(self._sampling_prob,num_samples=num_motion_to_load, replacement=True)\n else:\n sample_idxes = torch.clip(torch.arange(len(skeleton_trees)) + start_idx, 0, self._num_unique_motions - 1)\n\n self._curr_motion_ids = sample_idxes\n\n self._sampling_batch_prob = self._sampling_prob[self._curr_motion_ids]/self._sampling_prob[self._curr_motion_ids].sum()\n\n print(\"Sampling motion:\", sample_idxes[:10])\n\n motion_data_list = self._motion_data_list[sample_idxes.cpu().numpy()]\n mp.set_sharing_strategy('file_system')\n\n manager = mp.Manager()\n queue = manager.Queue()\n num_jobs = mp.cpu_count()\n\n if num_jobs <= 8: num_jobs = 1\n # num_jobs = 1\n\n res_acc = {} # using dictionary ensures order of the results.\n jobs = motion_data_list\n chunk = np.ceil(len(jobs) / num_jobs).astype(int)\n ids = np.arange(len(jobs))\n\n jobs = [(ids[i:i + chunk], jobs[i:i + chunk],\n skeleton_trees[i:i + chunk], gender_betas[i:i + chunk],\n self.fix_height, self.smpl_parsers, self._masterfoot_conifg)\n for i in range(0, len(jobs), chunk)]\n job_args = [jobs[i] for i in range(len(jobs))]\n\n for i in range(1, len(jobs)):\n worker_args = (*job_args[i], queue, i)\n worker = mp.Process(target=load_motion_with_skeleton,\n args=worker_args)\n worker.start()\n res_acc.update(load_motion_with_skeleton(*jobs[0], None, 0))\n\n for i in tqdm(range(len(jobs) - 1)):\n res = queue.get()\n res_acc.update(res)\n\n for f in tqdm(range(len(res_acc))):\n motion_file_data, curr_motion = res_acc[f]\n if USE_CACHE:\n curr_motion = DeviceCache(curr_motion, self._device)\n\n if \"beta\" in motion_file_data:\n self._motion_aa.append(motion_file_data['pose_aa'].reshape(-1, 72))\n self._motion_bodies.append(curr_motion.gender_beta)\n else:\n print(\"no beta, using default value\")\n self._motion_bodies.append(np.zeros(17))\n self._motion_quat.append(np.zeros(96))\n self._motion_aa.append(np.zeros(72))\n\n motion_fps = curr_motion.fps\n curr_dt = 1.0 / motion_fps\n\n num_frames = curr_motion.tensor.shape[0]\n curr_len = 1.0 / motion_fps * (num_frames - 1)\n\n self._motion_fps.append(motion_fps)\n self._motion_dt.append(curr_dt)\n self._motion_num_frames.append(num_frames)\n motions.append(curr_motion)\n self._motion_lengths.append(curr_len)\n\n self._motion_lengths = torch.tensor(self._motion_lengths,\n device=self._device,\n dtype=torch.float32)\n self._motion_fps = torch.tensor(self._motion_fps,\n device=self._device,\n dtype=torch.float32)\n self._motion_bodies = torch.stack(self._motion_bodies).to(self._device).type(torch.float32)\n self._motion_aa = torch.tensor(np.concatenate(self._motion_aa),\n device=self._device,\n dtype=torch.float32)\n\n self._motion_quat = torch.tensor(self._motion_quat,\n device=self._device,\n dtype=torch.float32)\n self._motion_dt = torch.tensor(self._motion_dt,\n device=self._device,\n dtype=torch.float32)\n self._motion_num_frames = torch.tensor(self._motion_num_frames,\n device=self._device)\n self._motion_limb_weights = torch.tensor(limb_weights,\n device=self._device,\n dtype=torch.float32)\n self._num_motions = len(motions)\n\n self.gts = torch.cat([m.global_translation for m in motions], dim=0).float()\n self.grs = torch.cat([m.global_rotation for m in motions], dim=0).float()\n self.lrs = torch.cat([m.local_rotation for m in motions], dim=0).float()\n self.grvs = torch.cat([m.global_root_velocity for m in motions], dim=0).float()\n self.gravs = torch.cat([m.global_root_angular_velocity for m in motions], dim=0).float()\n self.gavs = torch.cat([m.global_angular_velocity for m in motions], dim=0).float()\n self.gvs = torch.cat([m.global_velocity for m in motions], dim=0).float()\n self.dvs = torch.cat([m.dof_vels for m in motions], dim=0).float()\n\n lengths = self._motion_num_frames\n lengths_shifted = lengths.roll(1)\n lengths_shifted[0] = 0\n self.length_starts = lengths_shifted.cumsum(0)\n self.motion_ids = torch.arange(len(motions),\n dtype=torch.long,\n device=self._device)\n motion = motions[0]\n self.num_bodies = motion.num_joints\n\n\n num_motions = self.num_motions()\n total_len = self.get_total_length()\n print(\"Loaded {:d} motions with a total length of {:.3f}s.\".format(\n num_motions, total_len))\n return\n\n def num_motions(self):\n return self._num_motions\n\n def get_total_length(self):\n return sum(self._motion_lengths)\n\n def update_sampling_weight(self):\n sampling_temp = 0.2\n curr_termination_prob = 0.5\n curr_succ_rate = 1 - self._termination_history[self._curr_motion_ids]/ self._sampling_history[self._curr_motion_ids]\n self._success_rate[self._curr_motion_ids] = curr_succ_rate\n sample_prob = torch.exp(-self._success_rate/sampling_temp)\n\n self._sampling_prob = sample_prob/sample_prob.sum()\n self._termination_history[self._curr_motion_ids] = 0\n self._sampling_history[self._curr_motion_ids] = 0\n\n topk_sampled = self._sampling_prob.topk(50)\n print(\"Current most sampled\", self._motion_data_keys[topk_sampled.indices.cpu().numpy()])\n\n\n def update_sampling_history(self, env_ids):\n self._sampling_history[self._curr_motion_ids[env_ids]] += 1\n # print(\"sampling history: \", self._sampling_history[self._curr_motion_ids])\n\n def update_termination_history(self, termination):\n self._termination_history[self._curr_motion_ids] += termination.cpu()\n # print(\"termination history: \", self._termination_history[self._curr_motion_ids])\n\n\n def sample_motions(self, n):\n motion_ids = torch.multinomial(self._sampling_batch_prob,\n num_samples=n,\n replacement=True).to(self._device)\n\n return motion_ids\n\n\n def sample_time(self, motion_ids, truncate_time=None):\n n = len(motion_ids)\n phase = torch.rand(motion_ids.shape, device=self._device)\n motion_len = self._motion_lengths[motion_ids]\n if (truncate_time is not None):\n assert (truncate_time >= 0.0)\n motion_len -= truncate_time\n\n motion_time = phase * motion_len\n return motion_time.to(self._device)\n\n def sample_time_interval(self, motion_ids, truncate_time=None):\n n = len(motion_ids)\n phase = torch.rand(motion_ids.shape, device=self._device)\n motion_len = self._motion_lengths[motion_ids]\n if (truncate_time is not None):\n assert (truncate_time >= 0.0)\n motion_len -= truncate_time\n curr_fps = 1/30\n motion_time = ((phase * motion_len)/curr_fps).long() * curr_fps\n\n return motion_time\n\n def get_motion_length(self, motion_ids = None):\n if motion_ids is None:\n return self._motion_lengths\n else:\n return self._motion_lengths[motion_ids]\n\n def get_motion_num_frames(self, motion_ids = None):\n if motion_ids is None:\n return self._motion_num_frames\n else:\n return self._motion_num_frames[motion_ids]\n\n def get_motion_state_smpl_interval(self, motion_ids, motion_times, offset = None):\n n = len(motion_ids)\n num_bodies = self._get_num_bodies()\n num_key_bodies = self._key_body_ids.shape[0]\n\n motion_len = self._motion_lengths[motion_ids]\n num_frames = self._motion_num_frames[motion_ids]\n dt = self._motion_dt[motion_ids]\n\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\n motion_times, motion_len, num_frames, dt)\n\n frame_idx = torch.round((frame_idx0 * (1 - blend) + frame_idx1 * blend)).long()\n fl = frame_idx + self.length_starts[motion_ids]\n\n local_rot = self.lrs[fl]\n\n body_vel = self.gvs[fl]\n body_ang_vel = self.gavs[fl]\n\n rg_pos = self.gts[fl, :] # ZL: apply offset\n\n dof_vel = self.dvs[fl]\n\n vals = [local_rot, body_vel, body_ang_vel, rg_pos]\n for v in vals:\n assert v.dtype != torch.float64\n\n blend = blend.unsqueeze(-1)\n blend_exp = blend.unsqueeze(-1)\n key_pos = rg_pos[:, self._key_body_ids]\n\n dof_pos = self._local_rotation_to_dof_smpl(local_rot)\n\n rb_rot = self.grs[fl]\n return {\n \"root_pos\": rg_pos[..., 0, :].clone(),\n \"root_rot\": rb_rot[..., 0, :].clone(),\n \"dof_pos\": dof_pos.clone(),\n \"root_vel\": body_vel[..., 0, :].clone(),\n \"root_ang_vel\": body_ang_vel[..., 0, :].clone(),\n \"dof_vel\": dof_vel.view(dof_vel.shape[0], -1),\n \"key_pos\": key_pos,\n \"motion_aa\": self._motion_aa[fl],\n \"rg_pos\": rg_pos,\n \"rb_rot\": rb_rot,\n \"body_vel\": body_vel,\n \"body_ang_vel\": body_ang_vel,\n \"motion_bodies\": self._motion_bodies[motion_ids],\n \"motion_limb_weights\": self._motion_limb_weights[motion_ids],\n }\n\n def get_motion_state_smpl(self, motion_ids, motion_times, offset = None):\n n = len(motion_ids)\n num_bodies = self._get_num_bodies()\n num_key_bodies = self._key_body_ids.shape[0]\n\n motion_len = self._motion_lengths[motion_ids]\n num_frames = self._motion_num_frames[motion_ids]\n dt = self._motion_dt[motion_ids]\n\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\n motion_times, motion_len, num_frames, dt)\n # print(\"non_interval\", frame_idx0, frame_idx1)\n f0l = frame_idx0 + self.length_starts[motion_ids]\n f1l = frame_idx1 + self.length_starts[motion_ids]\n\n\n local_rot0 = self.lrs[f0l]\n local_rot1 = self.lrs[f1l]\n\n body_vel0 = self.gvs[f0l]\n body_vel1 = self.gvs[f1l]\n\n body_ang_vel0 = self.gavs[f0l]\n body_ang_vel1 = self.gavs[f1l]\n\n rg_pos0 = self.gts[f0l, :]\n rg_pos1 = self.gts[f1l, :]\n\n dof_vel0 = self.dvs[f0l]\n dof_vel1 = self.dvs[f1l]\n\n vals = [\n local_rot0, local_rot1, body_vel0, body_vel1,\n body_ang_vel0, body_ang_vel1, rg_pos0, rg_pos1, dof_vel0, dof_vel1\n ]\n for v in vals:\n assert v.dtype != torch.float64\n\n blend = blend.unsqueeze(-1)\n\n blend_exp = blend.unsqueeze(-1)\n\n if offset is None:\n rg_pos = (1.0 - blend_exp) * rg_pos0 + blend_exp * rg_pos1 # ZL: apply offset\n else:\n rg_pos = (1.0 - blend_exp) * rg_pos0 + blend_exp * rg_pos1 + offset[..., None, :] # ZL: apply offset\n\n body_vel = (1.0 - blend_exp) * body_vel0 + blend_exp * body_vel1\n body_ang_vel = (1.0 - blend_exp) * body_ang_vel0 + blend_exp * body_ang_vel1\n dof_vel = (1.0 - blend_exp) * dof_vel0 + blend_exp * dof_vel1\n\n key_pos = rg_pos[:, self._key_body_ids]\n\n local_rot = torch_utils.slerp(local_rot0, local_rot1,\n torch.unsqueeze(blend, axis=-1))\n dof_pos = self._local_rotation_to_dof_smpl(local_rot)\n\n rb_rot0 = self.grs[f0l]\n rb_rot1 = self.grs[f1l]\n rb_rot = torch_utils.slerp(rb_rot0, rb_rot1, blend_exp)\n\n # self.torch_humanoid.fk_batch()\n\n return {\n \"root_pos\": rg_pos[..., 0, :].clone(),\n \"root_rot\": rb_rot[..., 0, :].clone(),\n \"dof_pos\": dof_pos.clone(),\n \"root_vel\": body_vel[..., 0, :].clone(),\n \"root_ang_vel\": body_ang_vel[..., 0, :].clone(),\n \"dof_vel\": dof_vel.view(dof_vel.shape[0], -1),\n \"key_pos\": key_pos,\n \"motion_aa\": self._motion_aa[f0l],\n \"rg_pos\": rg_pos,\n \"rb_rot\": rb_rot,\n \"body_vel\": body_vel,\n \"body_ang_vel\": body_ang_vel,\n \"motion_bodies\": self._motion_bodies[motion_ids],\n \"motion_limb_weights\": self._motion_limb_weights[motion_ids],\n }\n\n def get_root_pos_smpl(self, motion_ids, motion_times):\n n = len(motion_ids)\n num_bodies = self._get_num_bodies()\n num_key_bodies = self._key_body_ids.shape[0]\n\n motion_len = self._motion_lengths[motion_ids]\n num_frames = self._motion_num_frames[motion_ids]\n dt = self._motion_dt[motion_ids]\n\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\n motion_times, motion_len, num_frames, dt)\n # print(\"non_interval\", frame_idx0, frame_idx1)\n f0l = frame_idx0 + self.length_starts[motion_ids]\n f1l = frame_idx1 + self.length_starts[motion_ids]\n\n rg_pos0 = self.gts[f0l, :]\n rg_pos1 = self.gts[f1l, :]\n\n\n vals = [rg_pos0, rg_pos1]\n for v in vals:\n assert v.dtype != torch.float64\n\n blend = blend.unsqueeze(-1)\n\n blend_exp = blend.unsqueeze(-1)\n\n rg_pos = (1.0 - blend_exp) * rg_pos0 + blend_exp * rg_pos1 # ZL: apply offset\n return {\"root_pos\": rg_pos[..., 0, :].clone()}\n\n def _calc_frame_blend(self, time, len, num_frames, dt):\n time = time.clone()\n phase = time / len\n phase = torch.clip(phase, 0.0, 1.0) # clip time to be within motion length.\n time[time < 0] = 0\n\n frame_idx0 = (phase * (num_frames - 1)).long()\n frame_idx1 = torch.min(frame_idx0 + 1, num_frames - 1)\n blend = (time - frame_idx0 * dt) / dt\n\n return frame_idx0, frame_idx1, blend\n\n def _get_num_bodies(self):\n return self.num_bodies\n\n def _local_rotation_to_dof_smpl(self, local_rot):\n B, J, _ = local_rot.shape\n dof_pos = torch_utils.quat_to_exp_map(local_rot[:, 1:])\n return dof_pos.reshape(B, -1)\n\n # jp hack\n def _hack_test_vel_consistency(self, motion):\n test_vel = np.loadtxt(\"output/vel.txt\", delimiter=\",\")\n test_root_vel = test_vel[:, :3]\n test_root_ang_vel = test_vel[:, 3:6]\n test_dof_vel = test_vel[:, 6:]\n\n dof_vel = motion.dof_vels\n dof_vel_err = test_dof_vel[:-1] - dof_vel[:-1]\n dof_vel_err = np.max(np.abs(dof_vel_err))\n\n root_vel = motion.global_root_velocity.numpy()\n root_vel_err = test_root_vel[:-1] - root_vel[:-1]\n root_vel_err = np.max(np.abs(root_vel_err))\n\n root_ang_vel = motion.global_root_angular_velocity.numpy()\n root_ang_vel_err = test_root_ang_vel[:-1] - root_ang_vel[:-1]\n root_ang_vel_err = np.max(np.abs(root_ang_vel_err))\n\n return"},{"identifier":"SMPL_Parser","path":"uhc/smpllib/smpl_parser.py","snippet":"class SMPL_Parser(_SMPL):\n def __init__(self, create_transl=False, *args, **kwargs):\n \"\"\"SMPL model constructor\n Parameters\n ----------\n model_path: str\n The path to the folder or to the file where the model\n parameters are stored\n data_struct: Strct\n A struct object. If given, then the parameters of the model are\n read from the object. Otherwise, the model tries to read the\n parameters from the given `model_path`. (default = None)\n create_global_orient: bool, optional\n Flag for creating a member variable for the global orientation\n of the body. (default = True)\n global_orient: torch.tensor, optional, Bx3\n The default value for the global orientation variable.\n (default = None)\n create_body_pose: bool, optional\n Flag for creating a member variable for the pose of the body.\n (default = True)\n body_pose: torch.tensor, optional, Bx(Body Joints * 3)\n The default value for the body pose variable.\n (default = None)\n create_betas: bool, optional\n Flag for creating a member variable for the shape space\n (default = True).\n betas: torch.tensor, optional, Bx10\n The default value for the shape member variable.\n (default = None)\n create_transl: bool, optional\n Flag for creating a member variable for the translation\n of the body. (default = True)\n transl: torch.tensor, optional, Bx3\n The default value for the transl variable.\n (default = None)\n dtype: torch.dtype, optional\n The data type for the created variables\n batch_size: int, optional\n The batch size used for creating the member variables\n joint_mapper: object, optional\n An object that re-maps the joints. Useful if one wants to\n re-order the SMPL joints to some other convention (e.g. MSCOCO)\n (default = None)\n gender: str, optional\n Which gender to load\n vertex_ids: dict, optional\n A dictionary containing the indices of the extra vertices that\n will be selected\n \"\"\"\n super(SMPL_Parser, self).__init__(*args, **kwargs)\n self.device = next(self.parameters()).device\n self.joint_names = SMPL_BONE_ORDER_NAMES\n\n self.joint_axes = {x: np.identity(3) for x in self.joint_names}\n self.joint_dofs = {x: [\"x\", \"y\", \"z\"] for x in self.joint_names}\n self.joint_range = {\n x: np.hstack([np.ones([3, 1]) * -np.pi,\n np.ones([3, 1]) * np.pi])\n for x in self.joint_names\n }\n self.joint_range[\"L_Elbow\"] *= 4\n self.joint_range[\"R_Elbow\"] *= 4\n self.joint_range[\"L_Shoulder\"] *= 4\n self.joint_range[\"R_Shoulder\"] *= 4\n\n self.contype = {1: self.joint_names}\n self.conaffinity = {1: self.joint_names}\n\n # self.contype = {\n # 3: ['Pelvis', 'L_Hip', 'L_Knee', 'L_Ankle', 'L_Toe', 'R_Hip', 'R_Knee','R_Ankle', 'R_Toe', 'Torso', 'Spine', 'Neck', 'Head','L_Thorax', 'L_Elbow', 'L_Wrist', 'L_Hand', 'R_Thorax', 'R_Elbow', 'R_Wrist', 'R_Hand'],\n # 1: ['Chest', \"L_Shoulder\", \"R_Shoulder\"]\n # }\n\n # self.conaffinity = {\n # 1: ['Pelvis', 'L_Hip', 'L_Knee', 'L_Ankle', 'L_Toe', 'R_Hip', 'R_Knee','R_Ankle', 'R_Toe', 'Torso', 'Spine', 'Neck', 'Head','L_Thorax', 'L_Elbow', 'L_Wrist', 'L_Hand', 'R_Thorax', 'R_Elbow', 'R_Wrist', 'R_Hand'],\n # 3: ['Chest', \"L_Shoulder\", \"R_Shoulder\"]\n # }\n\n self.zero_pose = torch.zeros(1, 72).float()\n\n def forward(self, *args, **kwargs):\n smpl_output = super(SMPL_Parser, self).forward(*args, **kwargs)\n return smpl_output\n\n def get_joints_verts(self, pose, th_betas=None, th_trans=None):\n \"\"\"\n Pose should be batch_size x 72\n \"\"\"\n if pose.shape[1] != 72:\n pose = pose.reshape(-1, 72)\n\n pose = pose.float()\n if th_betas is not None:\n th_betas = th_betas.float()\n\n if th_betas.shape[-1] == 16:\n th_betas = th_betas[:, :10]\n\n batch_size = pose.shape[0]\n\n smpl_output = self.forward(\n betas=th_betas,\n transl=th_trans,\n body_pose=pose[:, 3:],\n global_orient=pose[:, :3],\n )\n vertices = smpl_output.vertices\n joints = smpl_output.joints[:, :24]\n # joints = smpl_output.joints[:,JOINST_TO_USE]\n return vertices, joints\n\n def get_offsets(self, zero_pose=None, betas=torch.zeros(1, 10).float()):\n with torch.no_grad():\n if zero_pose is None:\n verts, Jtr = self.get_joints_verts(self.zero_pose,\n th_betas=betas)\n else:\n verts, Jtr = self.get_joints_verts(zero_pose, th_betas=betas)\n verts_np = verts.detach().cpu().numpy()\n jts_np = Jtr.detach().cpu().numpy()\n parents = self.parents.cpu().numpy()\n offsets_smpl = [np.array([0, 0, 0])]\n for i in range(1, len(parents)):\n p_id = parents[i]\n p3d = jts_np[0, p_id]\n curr_3d = jts_np[0, i]\n offset_curr = curr_3d - p3d\n offsets_smpl.append(offset_curr)\n offsets_smpl = np.array(offsets_smpl)\n joint_names = self.joint_names\n joint_pos = Jtr[0].numpy()\n smpl_joint_parents = self.parents.cpu().numpy()\n joint_offsets = {\n joint_names[c]:\n (joint_pos[c] - joint_pos[p]) if c > 0 else joint_pos[c]\n for c, p in enumerate(smpl_joint_parents)\n }\n parents_dict = {\n joint_names[i]: joint_names[parents[i]]\n for i in range(len(joint_names))\n }\n channels = [\"z\", \"y\", \"x\"]\n skin_weights = self.lbs_weights.numpy()\n return (verts[0], jts_np[0], skin_weights, self.joint_names,\n joint_offsets, parents_dict, channels, self.joint_range)\n\n def get_mesh_offsets(self,\n zero_pose=None,\n betas=torch.zeros(1, 10),\n flatfoot=False):\n with torch.no_grad():\n joint_names = self.joint_names\n if zero_pose is None:\n verts, Jtr = self.get_joints_verts(self.zero_pose,\n th_betas=betas)\n else:\n verts, Jtr = self.get_joints_verts(zero_pose, th_betas=betas)\n\n verts_np = verts.detach().cpu().numpy()\n verts = verts_np[0]\n\n if flatfoot:\n feet_subset = verts[:, 1] < np.min(verts[:, 1]) + 0.01\n verts[feet_subset, 1] = np.mean(verts[feet_subset][:, 1])\n\n smpl_joint_parents = self.parents.cpu().numpy()\n\n joint_pos = Jtr[0].numpy()\n joint_offsets = {\n joint_names[c]:\n (joint_pos[c] - joint_pos[p]) if c > 0 else joint_pos[c]\n for c, p in enumerate(smpl_joint_parents)\n }\n joint_parents = {\n x: joint_names[i] if i >= 0 else None\n for x, i in zip(joint_names, smpl_joint_parents)\n }\n\n # skin_weights = smpl_layer.th_weights.numpy()\n skin_weights = self.lbs_weights.numpy()\n return (\n verts,\n joint_pos,\n skin_weights,\n joint_names,\n joint_offsets,\n joint_parents,\n self.joint_axes,\n self.joint_dofs,\n self.joint_range,\n self.contype,\n self.conaffinity,\n )\n\n def get_mesh_offsets_batch(self, betas=torch.zeros(1, 10), flatfoot=False):\n with torch.no_grad():\n joint_names = self.joint_names\n verts, Jtr = self.get_joints_verts(self.zero_pose.repeat(\n betas.shape[0], 1),\n th_betas=betas)\n verts_np = verts.detach().cpu().numpy()\n verts = verts_np[0]\n\n if flatfoot:\n feet_subset = verts[:, 1] < np.min(verts[:, 1]) + 0.01\n verts[feet_subset, 1] = np.mean(verts[feet_subset][:, 1])\n\n smpl_joint_parents = self.parents.cpu().numpy()\n\n joint_pos = Jtr\n joint_offsets = {\n joint_names[c]:\n (joint_pos[:, c] - joint_pos[:, p]) if c > 0 else joint_pos[:,\n c]\n for c, p in enumerate(smpl_joint_parents)\n }\n joint_parents = {\n x: joint_names[i] if i >= 0 else None\n for x, i in zip(joint_names, smpl_joint_parents)\n }\n\n skin_weights = self.lbs_weights\n return (\n verts,\n joint_pos,\n skin_weights,\n joint_names,\n joint_offsets,\n joint_parents,\n self.joint_axes,\n self.joint_dofs,\n self.joint_range,\n self.contype,\n self.conaffinity,\n )"},{"identifier":"SMPLH_Parser","path":"uhc/smpllib/smpl_parser.py","snippet":"class SMPLH_Parser(_SMPLH):\n def __init__(self, *args, **kwargs):\n super(SMPLH_Parser, self).__init__(*args, **kwargs)\n self.device = next(self.parameters()).device\n self.joint_names = SMPLH_BONE_ORDER_NAMES\n self.joint_axes = {x: np.identity(3) for x in self.joint_names}\n self.joint_dofs = {x: [\"z\", \"y\", \"x\"] for x in self.joint_names}\n self.joint_range = {\n x: np.hstack([np.ones([3, 1]) * -np.pi,\n np.ones([3, 1]) * np.pi])\n for x in self.joint_names\n }\n self.joint_range[\"L_Elbow\"] *= 4\n self.joint_range[\"R_Elbow\"] *= 4\n # import ipdb\n # ipdb.set_trace()\n\n self.contype = {1: self.joint_names}\n self.conaffinity = {1: self.joint_names}\n self.zero_pose = torch.zeros(1, 156).float()\n\n def forward(self, *args, **kwargs):\n smpl_output = super(SMPLH_Parser, self).forward(*args, **kwargs)\n return smpl_output\n\n def get_joints_verts(self, pose, th_betas=None, th_trans=None):\n \"\"\"\n Pose should be batch_size x 156\n \"\"\"\n\n if pose.shape[1] != 156:\n pose = pose.reshape(-1, 156)\n pose = pose.float()\n if th_betas is not None:\n th_betas = th_betas.float()\n\n batch_size = pose.shape[0]\n smpl_output = self.forward(\n body_pose=pose[:, 3:66],\n global_orient=pose[:, :3],\n L_hand_pose=pose[:, 66:111],\n R_hand_pose=pose[:, 111:156],\n betas=th_betas,\n transl=th_trans,\n )\n vertices = smpl_output.vertices\n joints = smpl_output.joints\n # joints = smpl_output.joints[:,JOINST_TO_USE]\n return vertices, joints\n\n def get_offsets(self, betas=torch.zeros(1, 16).float()):\n with torch.no_grad():\n verts, jts = self.get_joints_verts(self.zero_pose, th_betas=betas)\n verts_np = verts.detach().cpu().numpy()\n jts_np = jts.detach().cpu().numpy()\n\n parents = self.parents.cpu().numpy()\n offsets_smpl = [np.array([0, 0, 0])]\n for i in range(1, len(parents)):\n p_id = parents[i]\n p3d = jts_np[0, p_id]\n curr_3d = jts_np[0, i]\n offset_curr = curr_3d - p3d\n offsets_smpl.append(offset_curr)\n offsets_smpl = np.array(offsets_smpl)\n names_smpl = self.joint_names\n offset_smpl_dict = {\n names_smpl[i]: offsets_smpl[i]\n for i in range(len(names_smpl))\n }\n parents_dict = {\n names_smpl[i]: names_smpl[parents[i]]\n for i in range(len(names_smpl))\n }\n parents_dict[\"Hips\"] = \"None\"\n channels = [\"z\", \"y\", \"x\"]\n\n return offset_smpl_dict, parents_dict, channels\n\n def get_mesh_offsets(self, betas=torch.zeros(1, 16), flatfoot=False):\n with torch.no_grad():\n joint_names = self.joint_names\n verts, Jtr = self.get_joints_verts(self.zero_pose, th_betas=betas)\n\n verts_np = verts.detach().cpu().numpy()\n verts = verts_np[0]\n\n if flatfoot:\n feet_subset = verts[:, 1] < np.min(verts[:, 1]) + 0.01\n verts[feet_subset, 1] = np.mean(verts[feet_subset][:, 1])\n\n smpl_joint_parents = self.parents.cpu().numpy()\n joint_pos = Jtr[0].numpy()\n joint_offsets = {\n joint_names[c]:\n (joint_pos[c] - joint_pos[p]) if c > 0 else joint_pos[c]\n for c, p in enumerate(smpl_joint_parents)\n }\n joint_parents = {\n x: joint_names[i] if i >= 0 else None\n for x, i in zip(joint_names, smpl_joint_parents)\n }\n\n # skin_weights = smpl_layer.th_weights.numpy()\n skin_weights = self.lbs_weights.numpy()\n return (\n verts,\n joint_pos,\n skin_weights,\n joint_names,\n joint_offsets,\n joint_parents,\n self.joint_axes,\n self.joint_dofs,\n self.joint_range,\n self.contype,\n self.conaffinity,\n )"},{"identifier":"SMPLX_Parser","path":"uhc/smpllib/smpl_parser.py","snippet":"class SMPLX_Parser(_SMPLX):\n def __init__(self, *args, **kwargs):\n super(SMPLX_Parser, self).__init__(*args, **kwargs)\n self.device = next(self.parameters()).device\n self.joint_names = SMPLH_BONE_ORDER_NAMES\n self.joint_axes = {x: np.identity(3) for x in self.joint_names}\n self.joint_dofs = {x: [\"z\", \"y\", \"x\"] for x in self.joint_names}\n self.joint_range = {\n x: np.hstack([np.ones([3, 1]) * -np.pi,\n np.ones([3, 1]) * np.pi])\n for x in self.joint_names\n }\n self.joint_range[\"L_Elbow\"] *= 4\n self.joint_range[\"R_Elbow\"] *= 4\n # import ipdb\n # ipdb.set_trace()\n\n self.contype = {1: self.joint_names}\n self.conaffinity = {1: self.joint_names}\n self.zero_pose = torch.zeros(1, 156).float()\n self.joint_to_use = [\n SMPLX_BONE_ORDER_NAMES.index(i) for i in SMPLH_BONE_ORDER_NAMES\n ]\n self.parents_to_use = np.concatenate(\n [np.arange(0, 22), np.arange(25, 55)])\n\n def forward(self, *args, **kwargs):\n smpl_output = super(SMPLX_Parser, self).forward(*args, **kwargs)\n return smpl_output\n\n def get_joints_verts(self, pose, th_betas=None, th_trans=None):\n \"\"\"\n Pose should be batch_size x 156\n \"\"\"\n\n if pose.shape[1] != 156:\n pose = pose.reshape(-1, 156)\n pose = pose.float()\n if th_betas is not None:\n th_betas = th_betas.float()\n\n batch_size = pose.shape[0]\n smpl_output = self.forward(\n body_pose=pose[:, 3:66],\n global_orient=pose[:, :3],\n left_hand_pose=pose[:, 66:111],\n right_hand_pose=pose[:, 111:156],\n betas=th_betas,\n transl=th_trans,\n )\n vertices = smpl_output.vertices\n joints = smpl_output.joints\n # return vertices, joints\n return vertices, joints\n\n def get_offsets(self, v_template=None):\n if not v_template is None:\n self.v_template = v_template\n with torch.no_grad():\n verts, jts = self.get_joints_verts(self.zero_pose)\n verts_np = verts.detach().cpu().numpy()\n jts_np = jts.detach().cpu().numpy()\n\n parents = self.parents.cpu().numpy()\n offsets_smpl = [np.array([0, 0, 0])]\n for i in range(1, len(parents)):\n p_id = parents[i]\n p3d = jts_np[0, p_id]\n curr_3d = jts_np[0, i]\n offset_curr = curr_3d - p3d\n offsets_smpl.append(offset_curr)\n offsets_smpl = np.array(offsets_smpl)\n names_smpl = self.joint_names\n offset_smpl_dict = {\n names_smpl[i]: offsets_smpl[i]\n for i in range(len(names_smpl))\n }\n parents_dict = {\n names_smpl[i]: names_smpl[parents[i]]\n for i in range(len(names_smpl))\n }\n parents_dict[\"Hips\"] = \"None\"\n channels = [\"z\", \"y\", \"x\"]\n return offset_smpl_dict, parents_dict, channels\n\n def get_mesh_offsets(self, v_template=None):\n if not v_template is None:\n self.v_template = v_template\n with torch.no_grad():\n # joint_names = self.joint_names\n joint_names = SMPLX_BONE_ORDER_NAMES\n verts, Jtr = self.get_joints_verts(self.zero_pose)\n\n smpl_joint_parents = self.parents.cpu().numpy()\n joint_pos = Jtr[0].numpy()\n # print(\n # joint_pos.shape,\n # smpl_joint_parents.shape,\n # len(self.parents_to_use),\n # self.parents.cpu().numpy().shape,\n # )\n joint_offsets = {\n joint_names[c]:\n (joint_pos[c] - joint_pos[p]) if c > 0 else joint_pos[c]\n for c, p in enumerate(smpl_joint_parents)\n if joint_names[c] in self.joint_names\n }\n joint_parents = {\n x: joint_names[i] if i >= 0 else None\n for x, i in zip(joint_names, smpl_joint_parents)\n if joint_names[i] in self.joint_names\n }\n\n verts = verts[0].numpy()\n # skin_weights = smpl_layer.th_weights.numpy()\n skin_weights = self.lbs_weights.numpy()[:, self.parents_to_use]\n return (\n verts,\n joint_pos,\n skin_weights,\n self.joint_names,\n joint_offsets,\n joint_parents,\n self.joint_axes,\n self.joint_dofs,\n self.joint_range,\n self.contype,\n self.conaffinity,\n )"},{"identifier":"flags","path":"pacer/utils/flags.py","snippet":"class Flags(object):\n def __init__(self, items):"}],"string":"[\n {\n \"identifier\": \"MotionLib\",\n \"path\": \"pacer/utils/motion_lib.py\",\n \"snippet\": \"class MotionLib():\\n def __init__(self, motion_file, dof_body_ids, dof_offsets, key_body_ids,\\n device):\\n self._dof_body_ids = dof_body_ids\\n self._dof_offsets = dof_offsets\\n self._num_dof = dof_offsets[-1]\\n self._key_body_ids = torch.tensor(key_body_ids, device=device)\\n self._device = device\\n\\n self._load_motions(motion_file)\\n motions = self._motions\\n self.gts = torch.cat([m.global_translation for m in motions],\\n dim=0).float()\\n self.grs = torch.cat([m.global_rotation for m in motions],\\n dim=0).float()\\n self.lrs = torch.cat([m.local_rotation for m in motions],\\n dim=0).float()\\n self.grvs = torch.cat([m.global_root_velocity for m in motions],\\n dim=0).float()\\n self.gravs = torch.cat(\\n [m.global_root_angular_velocity for m in motions], dim=0).float()\\n self.dvs = torch.cat([m.dof_vels for m in motions], dim=0).float()\\n\\n self.lrs[0]\\n\\n lengths = self._motion_num_frames\\n lengths_shifted = lengths.roll(1)\\n lengths_shifted[0] = 0\\n self.length_starts = lengths_shifted.cumsum(0)\\n\\n self.motion_ids = torch.arange(len(self._motions),\\n dtype=torch.long,\\n device=self._device)\\n\\n\\n return\\n\\n def num_motions(self):\\n return len(self._motions)\\n\\n def get_total_length(self):\\n return sum(self._motion_lengths)\\n\\n def get_motion(self, motion_id):\\n return self._motions[motion_id]\\n\\n def sample_motions(self, n):\\n motion_ids = torch.multinomial(self._motion_weights,\\n num_samples=n,\\n replacement=True)\\n\\n # m = self.num_motions()\\n # motion_ids = np.random.choice(m, size=n, replace=True, p=self._motion_weights)\\n # motion_ids = torch.tensor(motion_ids, device=self._device, dtype=torch.long)\\n return motion_ids\\n\\n def sample_time(self, motion_ids, truncate_time=None):\\n n = len(motion_ids)\\n phase = torch.rand(motion_ids.shape, device=self._device)\\n motion_len = self._motion_lengths[motion_ids]\\n if (truncate_time is not None):\\n assert (truncate_time >= 0.0)\\n motion_len -= truncate_time\\n\\n motion_time = phase * motion_len\\n return motion_time\\n\\n def get_motion_length(self, motion_ids):\\n return self._motion_lengths[motion_ids]\\n\\n def get_motion_state_smpl(self, motion_ids, motion_times):\\n n = len(motion_ids)\\n num_bodies = self._get_num_bodies()\\n num_key_bodies = self._key_body_ids.shape[0]\\n\\n motion_len = self._motion_lengths[motion_ids]\\n num_frames = self._motion_num_frames[motion_ids]\\n dt = self._motion_dt[motion_ids]\\n\\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\\n motion_times, motion_len, num_frames, dt)\\n\\n f0l = frame_idx0 + self.length_starts[motion_ids]\\n f1l = frame_idx1 + self.length_starts[motion_ids]\\n\\n root_pos0 = self.gts[f0l, 0]\\n root_pos1 = self.gts[f1l, 0]\\n\\n root_rot0 = self.grs[f0l, 0]\\n root_rot1 = self.grs[f1l, 0]\\n\\n local_rot0 = self.lrs[f0l]\\n local_rot1 = self.lrs[f1l]\\n\\n root_vel = self.grvs[f0l]\\n\\n root_ang_vel = self.gravs[f0l]\\n\\n rg_pos0 = self.gts[f0l, :]\\n rg_pos1 = self.gts[f1l, :]\\n\\n dof_vel = self.dvs[f0l]\\n\\n vals = [\\n root_pos0, root_pos1, local_rot0, local_rot1, root_vel,\\n root_ang_vel, rg_pos0, rg_pos1\\n ]\\n for v in vals:\\n assert v.dtype != torch.float64\\n\\n blend = blend.unsqueeze(-1)\\n\\n root_pos = (1.0 - blend) * root_pos0 + blend * root_pos1\\n\\n root_rot = torch_utils.slerp(root_rot0, root_rot1, blend)\\n\\n blend_exp = blend.unsqueeze(-1)\\n rg_pos = (1.0 - blend_exp) * rg_pos0 + blend_exp * rg_pos1\\n key_pos = rg_pos[:, self._key_body_ids]\\n\\n local_rot = torch_utils.slerp(local_rot0, local_rot1,\\n torch.unsqueeze(blend, axis=-1))\\n dof_pos = self._local_rotation_to_dof(local_rot)\\n\\n rb_rot0 = self.grs[f0l]\\n rb_rot1 = self.grs[f1l]\\n rb_rot = torch_utils.slerp(rb_rot0, rb_rot1, blend_exp)\\n\\n # import ipdb\\n # ipdb.set_trace()\\n # self.torch_humanoid.fk_batch()\\n return root_pos, root_rot, dof_pos, root_vel, root_ang_vel, dof_vel, key_pos, self._motion_bodies[\\n motion_ids], self._motion_aa[f0l], rg_pos, rb_rot\\n\\n def get_motion_state(self, motion_ids, motion_times):\\n n = len(motion_ids)\\n num_bodies = self._get_num_bodies()\\n num_key_bodies = self._key_body_ids.shape[0]\\n\\n motion_len = self._motion_lengths[motion_ids]\\n num_frames = self._motion_num_frames[motion_ids]\\n dt = self._motion_dt[motion_ids]\\n\\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\\n motion_times, motion_len, num_frames, dt)\\n\\n f0l = frame_idx0 + self.length_starts[motion_ids]\\n f1l = frame_idx1 + self.length_starts[motion_ids]\\n\\n root_pos0 = self.gts[f0l, 0]\\n root_pos1 = self.gts[f1l, 0]\\n\\n root_rot0 = self.grs[f0l, 0]\\n root_rot1 = self.grs[f1l, 0]\\n\\n local_rot0 = self.lrs[f0l]\\n local_rot1 = self.lrs[f1l]\\n\\n root_vel = self.grvs[f0l]\\n\\n root_ang_vel = self.gravs[f0l]\\n\\n key_pos0 = self.gts[f0l.unsqueeze(-1), self._key_body_ids.unsqueeze(0)]\\n key_pos1 = self.gts[f1l.unsqueeze(-1), self._key_body_ids.unsqueeze(0)]\\n\\n dof_vel = self.dvs[f0l]\\n\\n vals = [\\n root_pos0, root_pos1, local_rot0, local_rot1, root_vel,\\n root_ang_vel, key_pos0, key_pos1\\n ]\\n for v in vals:\\n assert v.dtype != torch.float64\\n\\n blend = blend.unsqueeze(-1)\\n\\n root_pos = (1.0 - blend) * root_pos0 + blend * root_pos1\\n\\n root_rot = torch_utils.slerp(root_rot0, root_rot1, blend)\\n\\n blend_exp = blend.unsqueeze(-1)\\n key_pos = (1.0 - blend_exp) * key_pos0 + blend_exp * key_pos1\\n\\n local_rot = torch_utils.slerp(local_rot0, local_rot1,\\n torch.unsqueeze(blend, axis=-1))\\n dof_pos = self._local_rotation_to_dof(local_rot)\\n\\n return root_pos, root_rot, dof_pos, root_vel, root_ang_vel, dof_vel, key_pos\\n\\n def _load_motions(self, motion_file):\\n self._motions = []\\n self._motion_lengths = []\\n self._motion_weights = []\\n self._motion_fps = []\\n self._motion_dt = []\\n self._motion_num_frames = []\\n self._motion_files = []\\n self._motion_bodies = []\\n self._motion_aa = []\\n self._motion_quat = []\\n\\n total_len = 0.0\\n\\n motion_files, motion_weights = self._fetch_motion_files(motion_file)\\n num_motion_files = len(motion_files)\\n for f in tqdm(range(num_motion_files)):\\n curr_file = motion_files[f]\\n\\n if (isinstance(curr_file, str)):\\n print(\\\"Loading {:d}/{:d} motion files: {:s}\\\".format(\\n f + 1, num_motion_files, curr_file))\\n motion_file_data = np.load(curr_file, allow_pickle=True).item()\\n curr_motion = SkeletonMotion.from_dict(motion_file_data)\\n elif (isinstance(curr_file, dict)):\\n motion_file_data = curr_file\\n curr_motion = SkeletonMotion.from_dict(curr_file)\\n\\n if \\\"beta\\\" in motion_file_data:\\n beta, gender, pose_aa = motion_file_data[\\n 'beta'], motion_file_data['gender'], motion_file_data[\\n 'pose_aa']\\n\\n if isinstance(gender, bytes):\\n gender = gender.decode(\\\"utf-8\\\")\\n if gender == \\\"neutral\\\":\\n gender = [0]\\n elif gender == \\\"male\\\":\\n gender = [1]\\n elif gender == \\\"female\\\":\\n gender = [2]\\n else:\\n import ipdb\\n ipdb.set_trace()\\n raise Exception(\\\"Gender Not Supported!!\\\")\\n self._motion_aa.append(pose_aa.reshape(-1, 72))\\n self._motion_bodies.append(np.concatenate((gender, beta)))\\n else:\\n seq_len, _, _ = curr_file['rotation']['arr'].shape\\n self._motion_bodies.append(np.zeros(17))\\n self._motion_quat.append(np.zeros([seq_len, 96]))\\n self._motion_aa.append(np.zeros([seq_len, 72]))\\n\\n motion_fps = curr_motion.fps\\n curr_dt = 1.0 / motion_fps\\n\\n num_frames = curr_motion.tensor.shape[0]\\n curr_len = 1.0 / motion_fps * (num_frames - 1)\\n\\n self._motion_fps.append(motion_fps)\\n self._motion_dt.append(curr_dt)\\n self._motion_num_frames.append(num_frames)\\n\\n curr_dof_vels = self._compute_motion_dof_vels(curr_motion)\\n curr_motion.dof_vels = curr_dof_vels\\n\\n # Moving motion tensors to the GPU\\n if USE_CACHE:\\n curr_motion = DeviceCache(curr_motion, self._device)\\n else:\\n curr_motion.tensor = curr_motion.tensor.to(self._device)\\n curr_motion._skeleton_tree._parent_indices = curr_motion._skeleton_tree._parent_indices.to(\\n self._device)\\n curr_motion._skeleton_tree._local_translation = curr_motion._skeleton_tree._local_translation.to(\\n self._device)\\n curr_motion._rotation = curr_motion._rotation.to(self._device)\\n\\n self._motions.append(curr_motion)\\n self._motion_lengths.append(curr_len)\\n\\n curr_weight = motion_weights[f]\\n self._motion_weights.append(curr_weight)\\n self._motion_files.append(curr_file)\\n # jp hack\\n #self._hack_test_vel_consistency(curr_motion)\\n\\n self._motion_lengths = torch.tensor(self._motion_lengths,\\n device=self._device,\\n dtype=torch.float32)\\n\\n self._motion_weights = torch.tensor(self._motion_weights,\\n dtype=torch.float32,\\n device=self._device)\\n self._motion_weights /= self._motion_weights.sum()\\n\\n self._motion_fps = torch.tensor(self._motion_fps,\\n device=self._device,\\n dtype=torch.float32)\\n self._motion_bodies = torch.tensor(self._motion_bodies,\\n device=self._device,\\n dtype=torch.float32)\\n self._motion_aa = torch.tensor(np.concatenate(self._motion_aa),\\n device=self._device,\\n dtype=torch.float32)\\n self._motion_quat = torch.tensor(np.concatenate(self._motion_quat),\\n device=self._device,\\n dtype=torch.float32)\\n \\n self._motion_dt = torch.tensor(self._motion_dt,\\n device=self._device,\\n dtype=torch.float32)\\n self._motion_num_frames = torch.tensor(self._motion_num_frames,\\n device=self._device)\\n\\n num_motions = self.num_motions()\\n total_len = self.get_total_length()\\n\\n print(\\\"Loaded {:d} motions with a total length of {:.3f}s.\\\".format(\\n num_motions, total_len))\\n\\n # self.torch_humanoid.update_model(self._motion_bodies[:, 1:],\\n # self._motion_bodies[:, 0])\\n\\n return\\n\\n def _fetch_motion_files(self, motion_file):\\n ext = os.path.splitext(motion_file)[1]\\n if (ext == \\\".yaml\\\"):\\n dir_name = os.path.dirname(motion_file)\\n motion_files = []\\n motion_weights = []\\n\\n with open(os.path.join(os.getcwd(), motion_file), 'r') as f:\\n motion_config = yaml.load(f, Loader=yaml.SafeLoader)\\n\\n motion_list = motion_config['motions']\\n for motion_entry in motion_list:\\n curr_file = motion_entry['file']\\n curr_weight = motion_entry['weight']\\n assert (curr_weight >= 0)\\n\\n curr_file = os.path.join(dir_name, curr_file)\\n motion_weights.append(curr_weight)\\n motion_files.append(curr_file)\\n\\n elif (ext == \\\".pkl\\\"):\\n motion_data = joblib.load(motion_file)\\n motion_files = list(motion_data.values())\\n motion_weights = [1 / len(motion_files)] * len(motion_files)\\n\\n # motion_lens = [v['rotation']['arr'].shape[0] for v in motion_files]\\n # motion_weights = np.array(motion_lens)/np.sum(motion_lens)\\n\\n else:\\n motion_files = [motion_file]\\n motion_weights = [1.0]\\n\\n return motion_files, motion_weights\\n\\n def _calc_frame_blend(self, time, len, num_frames, dt):\\n\\n phase = time / len\\n phase = torch.clip(phase, 0.0, 1.0)\\n\\n frame_idx0 = (phase * (num_frames - 1)).long()\\n frame_idx1 = torch.min(frame_idx0 + 1, num_frames - 1)\\n blend = (time - frame_idx0 * dt) / dt\\n\\n return frame_idx0, frame_idx1, blend\\n\\n def _get_num_bodies(self):\\n motion = self.get_motion(0)\\n num_bodies = motion.num_joints\\n return num_bodies\\n\\n def _compute_motion_dof_vels(self, motion):\\n num_frames = motion.tensor.shape[0]\\n dt = 1.0 / motion.fps\\n dof_vels = []\\n\\n for f in range(num_frames - 1):\\n local_rot0 = motion.local_rotation[f]\\n local_rot1 = motion.local_rotation[f + 1]\\n frame_dof_vel = self._local_rotation_to_dof_vel(\\n local_rot0, local_rot1, dt)\\n frame_dof_vel = frame_dof_vel\\n dof_vels.append(frame_dof_vel)\\n\\n dof_vels.append(dof_vels[-1])\\n dof_vels = torch.stack(dof_vels, dim=0)\\n\\n return dof_vels\\n\\n # jp hack\\n # get rid of this ASAP, need a proper way of projecting from max coords to reduced coords\\n def _local_rotation_to_dof(self, local_rot):\\n body_ids = self._dof_body_ids\\n dof_offsets = self._dof_offsets\\n\\n n = local_rot.shape[0]\\n dof_pos = torch.zeros((n, self._num_dof),\\n dtype=torch.float,\\n device=self._device)\\n\\n for j in range(len(body_ids)):\\n body_id = body_ids[j]\\n joint_offset = dof_offsets[j]\\n joint_size = dof_offsets[j + 1] - joint_offset\\n\\n if (joint_size == 3):\\n joint_q = local_rot[:, body_id]\\n joint_exp_map = torch_utils.quat_to_exp_map(joint_q)\\n dof_pos[:, joint_offset:(joint_offset +\\n joint_size)] = joint_exp_map\\n elif (joint_size == 1):\\n joint_q = local_rot[:, body_id]\\n joint_theta, joint_axis = torch_utils.quat_to_angle_axis(\\n joint_q)\\n joint_theta = joint_theta * joint_axis[\\n ..., 1] # assume joint is always along y axis\\n\\n joint_theta = normalize_angle(joint_theta)\\n dof_pos[:, joint_offset] = joint_theta\\n\\n else:\\n print(\\\"Unsupported joint type\\\")\\n assert (False)\\n\\n return dof_pos\\n\\n def _local_rotation_to_dof_vel(self, local_rot0, local_rot1, dt):\\n body_ids = self._dof_body_ids\\n dof_offsets = self._dof_offsets\\n\\n dof_vel = torch.zeros([self._num_dof], device=self._device)\\n\\n diff_quat_data = quat_mul_norm(quat_inverse(local_rot0), local_rot1)\\n diff_angle, diff_axis = quat_angle_axis(diff_quat_data)\\n local_vel = diff_axis * diff_angle.unsqueeze(-1) / dt\\n local_vel = local_vel\\n for j in range(len(body_ids)):\\n body_id = body_ids[j]\\n joint_offset = dof_offsets[j]\\n joint_size = dof_offsets[j + 1] - joint_offset\\n\\n if (joint_size == 3):\\n joint_vel = local_vel[body_id]\\n dof_vel[joint_offset:(joint_offset + joint_size)] = joint_vel\\n\\n elif (joint_size == 1):\\n assert (joint_size == 1)\\n joint_vel = local_vel[body_id]\\n dof_vel[joint_offset] = joint_vel[\\n 1] # assume joint is always along y axis\\n\\n else:\\n print(\\\"Unsupported joint type\\\")\\n assert (False)\\n\\n return dof_vel\\n\\n # jp hack\\n def _hack_test_vel_consistency(self, motion):\\n test_vel = np.loadtxt(\\\"output/vel.txt\\\", delimiter=\\\",\\\")\\n test_root_vel = test_vel[:, :3]\\n test_root_ang_vel = test_vel[:, 3:6]\\n test_dof_vel = test_vel[:, 6:]\\n\\n dof_vel = motion.dof_vels\\n dof_vel_err = test_dof_vel[:-1] - dof_vel[:-1]\\n dof_vel_err = np.max(np.abs(dof_vel_err))\\n\\n root_vel = motion.global_root_velocity.numpy()\\n root_vel_err = test_root_vel[:-1] - root_vel[:-1]\\n root_vel_err = np.max(np.abs(root_vel_err))\\n\\n root_ang_vel = motion.global_root_angular_velocity.numpy()\\n root_ang_vel_err = test_root_ang_vel[:-1] - root_ang_vel[:-1]\\n root_ang_vel_err = np.max(np.abs(root_ang_vel_err))\\n\\n return\"\n },\n {\n \"identifier\": \"MotionLib\",\n \"path\": \"pacer/utils/motion_lib_smpl.py\",\n \"snippet\": \"class MotionLib():\\n def __init__(self, motion_file, key_body_ids, device, fix_height = True, masterfoot_conifg = None, min_length = -1):\\n self._key_body_ids = torch.tensor(key_body_ids, device=device)\\n self._device = device\\n self._motion_data = joblib.load(motion_file)\\n\\n if min_length != -1:\\n data_list = {k: v for k, v in list(self._motion_data.items()) if len(v['pose_quat_global']) >= min_length}\\n self._motion_data_list = np.array(list(data_list.values()))\\n self._motion_data_keys = np.array(list(data_list.keys()))\\n else:\\n self._motion_data_list = np.array(list(self._motion_data.values()))\\n self._motion_data_keys = np.array(list(self._motion_data.keys()))\\n self._num_unique_motions = len(self._motion_data_list)\\n\\n\\n self._masterfoot_conifg = masterfoot_conifg\\n data_dir = \\\"data/smpl\\\"\\n smpl_parser_n = SMPL_Parser(model_path=data_dir,\\n gender=\\\"neutral\\\")\\n smpl_parser_m = SMPL_Parser(model_path=data_dir,\\n gender=\\\"male\\\")\\n smpl_parser_f = SMPL_Parser(model_path=data_dir,\\n gender=\\\"female\\\")\\n self.smpl_parsers = {\\n 0: smpl_parser_n,\\n 1: smpl_parser_m,\\n 2: smpl_parser_f\\n }\\n self.fix_height = fix_height\\n\\n #### Termination history\\n self._curr_motion_ids = None\\n self._termination_history = torch.zeros(self._num_unique_motions)\\n self._success_rate = torch.zeros(self._num_unique_motions)\\n self._sampling_history = torch.zeros(self._num_unique_motions)\\n self._sampling_prob = torch.ones(self._num_unique_motions)/self._num_unique_motions # For use in sampling batches\\n self._sampling_batch_prob = None # For use in sampling within batches\\n return\\n\\n def load_motions(self, skeleton_trees, gender_betas, limb_weights, random_sample = True, start_idx = 0):\\n # load motion load the same number of motions as there are skeletons (humanoids)\\n if \\\"gts\\\" in self.__dict__:\\n del self.gts , self.grs , self.lrs, self.grvs, self.gravs , self.gavs , self.gvs, self.dvs,\\n del self._motion_lengths, self._motion_fps, self._motion_dt, self._motion_num_frames, self._motion_bodies, self._motion_aa , self._motion_quat\\n\\n motions = []\\n self._motion_lengths = []\\n self._motion_fps = []\\n self._motion_dt = []\\n self._motion_num_frames = []\\n self._motion_bodies = []\\n self._motion_aa = []\\n self._motion_quat = []\\n\\n torch.cuda.empty_cache()\\n gc.collect()\\n\\n total_len = 0.0\\n num_motion_to_load = len(skeleton_trees)\\n\\n if random_sample:\\n sample_idxes = torch.multinomial(self._sampling_prob,num_samples=num_motion_to_load, replacement=True)\\n else:\\n sample_idxes = torch.clip(torch.arange(len(skeleton_trees)) + start_idx, 0, self._num_unique_motions - 1)\\n\\n self._curr_motion_ids = sample_idxes\\n\\n self._sampling_batch_prob = self._sampling_prob[self._curr_motion_ids]/self._sampling_prob[self._curr_motion_ids].sum()\\n\\n print(\\\"Sampling motion:\\\", sample_idxes[:10])\\n\\n motion_data_list = self._motion_data_list[sample_idxes.cpu().numpy()]\\n mp.set_sharing_strategy('file_system')\\n\\n manager = mp.Manager()\\n queue = manager.Queue()\\n num_jobs = mp.cpu_count()\\n\\n if num_jobs <= 8: num_jobs = 1\\n # num_jobs = 1\\n\\n res_acc = {} # using dictionary ensures order of the results.\\n jobs = motion_data_list\\n chunk = np.ceil(len(jobs) / num_jobs).astype(int)\\n ids = np.arange(len(jobs))\\n\\n jobs = [(ids[i:i + chunk], jobs[i:i + chunk],\\n skeleton_trees[i:i + chunk], gender_betas[i:i + chunk],\\n self.fix_height, self.smpl_parsers, self._masterfoot_conifg)\\n for i in range(0, len(jobs), chunk)]\\n job_args = [jobs[i] for i in range(len(jobs))]\\n\\n for i in range(1, len(jobs)):\\n worker_args = (*job_args[i], queue, i)\\n worker = mp.Process(target=load_motion_with_skeleton,\\n args=worker_args)\\n worker.start()\\n res_acc.update(load_motion_with_skeleton(*jobs[0], None, 0))\\n\\n for i in tqdm(range(len(jobs) - 1)):\\n res = queue.get()\\n res_acc.update(res)\\n\\n for f in tqdm(range(len(res_acc))):\\n motion_file_data, curr_motion = res_acc[f]\\n if USE_CACHE:\\n curr_motion = DeviceCache(curr_motion, self._device)\\n\\n if \\\"beta\\\" in motion_file_data:\\n self._motion_aa.append(motion_file_data['pose_aa'].reshape(-1, 72))\\n self._motion_bodies.append(curr_motion.gender_beta)\\n else:\\n print(\\\"no beta, using default value\\\")\\n self._motion_bodies.append(np.zeros(17))\\n self._motion_quat.append(np.zeros(96))\\n self._motion_aa.append(np.zeros(72))\\n\\n motion_fps = curr_motion.fps\\n curr_dt = 1.0 / motion_fps\\n\\n num_frames = curr_motion.tensor.shape[0]\\n curr_len = 1.0 / motion_fps * (num_frames - 1)\\n\\n self._motion_fps.append(motion_fps)\\n self._motion_dt.append(curr_dt)\\n self._motion_num_frames.append(num_frames)\\n motions.append(curr_motion)\\n self._motion_lengths.append(curr_len)\\n\\n self._motion_lengths = torch.tensor(self._motion_lengths,\\n device=self._device,\\n dtype=torch.float32)\\n self._motion_fps = torch.tensor(self._motion_fps,\\n device=self._device,\\n dtype=torch.float32)\\n self._motion_bodies = torch.stack(self._motion_bodies).to(self._device).type(torch.float32)\\n self._motion_aa = torch.tensor(np.concatenate(self._motion_aa),\\n device=self._device,\\n dtype=torch.float32)\\n\\n self._motion_quat = torch.tensor(self._motion_quat,\\n device=self._device,\\n dtype=torch.float32)\\n self._motion_dt = torch.tensor(self._motion_dt,\\n device=self._device,\\n dtype=torch.float32)\\n self._motion_num_frames = torch.tensor(self._motion_num_frames,\\n device=self._device)\\n self._motion_limb_weights = torch.tensor(limb_weights,\\n device=self._device,\\n dtype=torch.float32)\\n self._num_motions = len(motions)\\n\\n self.gts = torch.cat([m.global_translation for m in motions], dim=0).float()\\n self.grs = torch.cat([m.global_rotation for m in motions], dim=0).float()\\n self.lrs = torch.cat([m.local_rotation for m in motions], dim=0).float()\\n self.grvs = torch.cat([m.global_root_velocity for m in motions], dim=0).float()\\n self.gravs = torch.cat([m.global_root_angular_velocity for m in motions], dim=0).float()\\n self.gavs = torch.cat([m.global_angular_velocity for m in motions], dim=0).float()\\n self.gvs = torch.cat([m.global_velocity for m in motions], dim=0).float()\\n self.dvs = torch.cat([m.dof_vels for m in motions], dim=0).float()\\n\\n lengths = self._motion_num_frames\\n lengths_shifted = lengths.roll(1)\\n lengths_shifted[0] = 0\\n self.length_starts = lengths_shifted.cumsum(0)\\n self.motion_ids = torch.arange(len(motions),\\n dtype=torch.long,\\n device=self._device)\\n motion = motions[0]\\n self.num_bodies = motion.num_joints\\n\\n\\n num_motions = self.num_motions()\\n total_len = self.get_total_length()\\n print(\\\"Loaded {:d} motions with a total length of {:.3f}s.\\\".format(\\n num_motions, total_len))\\n return\\n\\n def num_motions(self):\\n return self._num_motions\\n\\n def get_total_length(self):\\n return sum(self._motion_lengths)\\n\\n def update_sampling_weight(self):\\n sampling_temp = 0.2\\n curr_termination_prob = 0.5\\n curr_succ_rate = 1 - self._termination_history[self._curr_motion_ids]/ self._sampling_history[self._curr_motion_ids]\\n self._success_rate[self._curr_motion_ids] = curr_succ_rate\\n sample_prob = torch.exp(-self._success_rate/sampling_temp)\\n\\n self._sampling_prob = sample_prob/sample_prob.sum()\\n self._termination_history[self._curr_motion_ids] = 0\\n self._sampling_history[self._curr_motion_ids] = 0\\n\\n topk_sampled = self._sampling_prob.topk(50)\\n print(\\\"Current most sampled\\\", self._motion_data_keys[topk_sampled.indices.cpu().numpy()])\\n\\n\\n def update_sampling_history(self, env_ids):\\n self._sampling_history[self._curr_motion_ids[env_ids]] += 1\\n # print(\\\"sampling history: \\\", self._sampling_history[self._curr_motion_ids])\\n\\n def update_termination_history(self, termination):\\n self._termination_history[self._curr_motion_ids] += termination.cpu()\\n # print(\\\"termination history: \\\", self._termination_history[self._curr_motion_ids])\\n\\n\\n def sample_motions(self, n):\\n motion_ids = torch.multinomial(self._sampling_batch_prob,\\n num_samples=n,\\n replacement=True).to(self._device)\\n\\n return motion_ids\\n\\n\\n def sample_time(self, motion_ids, truncate_time=None):\\n n = len(motion_ids)\\n phase = torch.rand(motion_ids.shape, device=self._device)\\n motion_len = self._motion_lengths[motion_ids]\\n if (truncate_time is not None):\\n assert (truncate_time >= 0.0)\\n motion_len -= truncate_time\\n\\n motion_time = phase * motion_len\\n return motion_time.to(self._device)\\n\\n def sample_time_interval(self, motion_ids, truncate_time=None):\\n n = len(motion_ids)\\n phase = torch.rand(motion_ids.shape, device=self._device)\\n motion_len = self._motion_lengths[motion_ids]\\n if (truncate_time is not None):\\n assert (truncate_time >= 0.0)\\n motion_len -= truncate_time\\n curr_fps = 1/30\\n motion_time = ((phase * motion_len)/curr_fps).long() * curr_fps\\n\\n return motion_time\\n\\n def get_motion_length(self, motion_ids = None):\\n if motion_ids is None:\\n return self._motion_lengths\\n else:\\n return self._motion_lengths[motion_ids]\\n\\n def get_motion_num_frames(self, motion_ids = None):\\n if motion_ids is None:\\n return self._motion_num_frames\\n else:\\n return self._motion_num_frames[motion_ids]\\n\\n def get_motion_state_smpl_interval(self, motion_ids, motion_times, offset = None):\\n n = len(motion_ids)\\n num_bodies = self._get_num_bodies()\\n num_key_bodies = self._key_body_ids.shape[0]\\n\\n motion_len = self._motion_lengths[motion_ids]\\n num_frames = self._motion_num_frames[motion_ids]\\n dt = self._motion_dt[motion_ids]\\n\\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\\n motion_times, motion_len, num_frames, dt)\\n\\n frame_idx = torch.round((frame_idx0 * (1 - blend) + frame_idx1 * blend)).long()\\n fl = frame_idx + self.length_starts[motion_ids]\\n\\n local_rot = self.lrs[fl]\\n\\n body_vel = self.gvs[fl]\\n body_ang_vel = self.gavs[fl]\\n\\n rg_pos = self.gts[fl, :] # ZL: apply offset\\n\\n dof_vel = self.dvs[fl]\\n\\n vals = [local_rot, body_vel, body_ang_vel, rg_pos]\\n for v in vals:\\n assert v.dtype != torch.float64\\n\\n blend = blend.unsqueeze(-1)\\n blend_exp = blend.unsqueeze(-1)\\n key_pos = rg_pos[:, self._key_body_ids]\\n\\n dof_pos = self._local_rotation_to_dof_smpl(local_rot)\\n\\n rb_rot = self.grs[fl]\\n return {\\n \\\"root_pos\\\": rg_pos[..., 0, :].clone(),\\n \\\"root_rot\\\": rb_rot[..., 0, :].clone(),\\n \\\"dof_pos\\\": dof_pos.clone(),\\n \\\"root_vel\\\": body_vel[..., 0, :].clone(),\\n \\\"root_ang_vel\\\": body_ang_vel[..., 0, :].clone(),\\n \\\"dof_vel\\\": dof_vel.view(dof_vel.shape[0], -1),\\n \\\"key_pos\\\": key_pos,\\n \\\"motion_aa\\\": self._motion_aa[fl],\\n \\\"rg_pos\\\": rg_pos,\\n \\\"rb_rot\\\": rb_rot,\\n \\\"body_vel\\\": body_vel,\\n \\\"body_ang_vel\\\": body_ang_vel,\\n \\\"motion_bodies\\\": self._motion_bodies[motion_ids],\\n \\\"motion_limb_weights\\\": self._motion_limb_weights[motion_ids],\\n }\\n\\n def get_motion_state_smpl(self, motion_ids, motion_times, offset = None):\\n n = len(motion_ids)\\n num_bodies = self._get_num_bodies()\\n num_key_bodies = self._key_body_ids.shape[0]\\n\\n motion_len = self._motion_lengths[motion_ids]\\n num_frames = self._motion_num_frames[motion_ids]\\n dt = self._motion_dt[motion_ids]\\n\\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\\n motion_times, motion_len, num_frames, dt)\\n # print(\\\"non_interval\\\", frame_idx0, frame_idx1)\\n f0l = frame_idx0 + self.length_starts[motion_ids]\\n f1l = frame_idx1 + self.length_starts[motion_ids]\\n\\n\\n local_rot0 = self.lrs[f0l]\\n local_rot1 = self.lrs[f1l]\\n\\n body_vel0 = self.gvs[f0l]\\n body_vel1 = self.gvs[f1l]\\n\\n body_ang_vel0 = self.gavs[f0l]\\n body_ang_vel1 = self.gavs[f1l]\\n\\n rg_pos0 = self.gts[f0l, :]\\n rg_pos1 = self.gts[f1l, :]\\n\\n dof_vel0 = self.dvs[f0l]\\n dof_vel1 = self.dvs[f1l]\\n\\n vals = [\\n local_rot0, local_rot1, body_vel0, body_vel1,\\n body_ang_vel0, body_ang_vel1, rg_pos0, rg_pos1, dof_vel0, dof_vel1\\n ]\\n for v in vals:\\n assert v.dtype != torch.float64\\n\\n blend = blend.unsqueeze(-1)\\n\\n blend_exp = blend.unsqueeze(-1)\\n\\n if offset is None:\\n rg_pos = (1.0 - blend_exp) * rg_pos0 + blend_exp * rg_pos1 # ZL: apply offset\\n else:\\n rg_pos = (1.0 - blend_exp) * rg_pos0 + blend_exp * rg_pos1 + offset[..., None, :] # ZL: apply offset\\n\\n body_vel = (1.0 - blend_exp) * body_vel0 + blend_exp * body_vel1\\n body_ang_vel = (1.0 - blend_exp) * body_ang_vel0 + blend_exp * body_ang_vel1\\n dof_vel = (1.0 - blend_exp) * dof_vel0 + blend_exp * dof_vel1\\n\\n key_pos = rg_pos[:, self._key_body_ids]\\n\\n local_rot = torch_utils.slerp(local_rot0, local_rot1,\\n torch.unsqueeze(blend, axis=-1))\\n dof_pos = self._local_rotation_to_dof_smpl(local_rot)\\n\\n rb_rot0 = self.grs[f0l]\\n rb_rot1 = self.grs[f1l]\\n rb_rot = torch_utils.slerp(rb_rot0, rb_rot1, blend_exp)\\n\\n # self.torch_humanoid.fk_batch()\\n\\n return {\\n \\\"root_pos\\\": rg_pos[..., 0, :].clone(),\\n \\\"root_rot\\\": rb_rot[..., 0, :].clone(),\\n \\\"dof_pos\\\": dof_pos.clone(),\\n \\\"root_vel\\\": body_vel[..., 0, :].clone(),\\n \\\"root_ang_vel\\\": body_ang_vel[..., 0, :].clone(),\\n \\\"dof_vel\\\": dof_vel.view(dof_vel.shape[0], -1),\\n \\\"key_pos\\\": key_pos,\\n \\\"motion_aa\\\": self._motion_aa[f0l],\\n \\\"rg_pos\\\": rg_pos,\\n \\\"rb_rot\\\": rb_rot,\\n \\\"body_vel\\\": body_vel,\\n \\\"body_ang_vel\\\": body_ang_vel,\\n \\\"motion_bodies\\\": self._motion_bodies[motion_ids],\\n \\\"motion_limb_weights\\\": self._motion_limb_weights[motion_ids],\\n }\\n\\n def get_root_pos_smpl(self, motion_ids, motion_times):\\n n = len(motion_ids)\\n num_bodies = self._get_num_bodies()\\n num_key_bodies = self._key_body_ids.shape[0]\\n\\n motion_len = self._motion_lengths[motion_ids]\\n num_frames = self._motion_num_frames[motion_ids]\\n dt = self._motion_dt[motion_ids]\\n\\n frame_idx0, frame_idx1, blend = self._calc_frame_blend(\\n motion_times, motion_len, num_frames, dt)\\n # print(\\\"non_interval\\\", frame_idx0, frame_idx1)\\n f0l = frame_idx0 + self.length_starts[motion_ids]\\n f1l = frame_idx1 + self.length_starts[motion_ids]\\n\\n rg_pos0 = self.gts[f0l, :]\\n rg_pos1 = self.gts[f1l, :]\\n\\n\\n vals = [rg_pos0, rg_pos1]\\n for v in vals:\\n assert v.dtype != torch.float64\\n\\n blend = blend.unsqueeze(-1)\\n\\n blend_exp = blend.unsqueeze(-1)\\n\\n rg_pos = (1.0 - blend_exp) * rg_pos0 + blend_exp * rg_pos1 # ZL: apply offset\\n return {\\\"root_pos\\\": rg_pos[..., 0, :].clone()}\\n\\n def _calc_frame_blend(self, time, len, num_frames, dt):\\n time = time.clone()\\n phase = time / len\\n phase = torch.clip(phase, 0.0, 1.0) # clip time to be within motion length.\\n time[time < 0] = 0\\n\\n frame_idx0 = (phase * (num_frames - 1)).long()\\n frame_idx1 = torch.min(frame_idx0 + 1, num_frames - 1)\\n blend = (time - frame_idx0 * dt) / dt\\n\\n return frame_idx0, frame_idx1, blend\\n\\n def _get_num_bodies(self):\\n return self.num_bodies\\n\\n def _local_rotation_to_dof_smpl(self, local_rot):\\n B, J, _ = local_rot.shape\\n dof_pos = torch_utils.quat_to_exp_map(local_rot[:, 1:])\\n return dof_pos.reshape(B, -1)\\n\\n # jp hack\\n def _hack_test_vel_consistency(self, motion):\\n test_vel = np.loadtxt(\\\"output/vel.txt\\\", delimiter=\\\",\\\")\\n test_root_vel = test_vel[:, :3]\\n test_root_ang_vel = test_vel[:, 3:6]\\n test_dof_vel = test_vel[:, 6:]\\n\\n dof_vel = motion.dof_vels\\n dof_vel_err = test_dof_vel[:-1] - dof_vel[:-1]\\n dof_vel_err = np.max(np.abs(dof_vel_err))\\n\\n root_vel = motion.global_root_velocity.numpy()\\n root_vel_err = test_root_vel[:-1] - root_vel[:-1]\\n root_vel_err = np.max(np.abs(root_vel_err))\\n\\n root_ang_vel = motion.global_root_angular_velocity.numpy()\\n root_ang_vel_err = test_root_ang_vel[:-1] - root_ang_vel[:-1]\\n root_ang_vel_err = np.max(np.abs(root_ang_vel_err))\\n\\n return\"\n },\n {\n \"identifier\": \"SMPL_Parser\",\n \"path\": \"uhc/smpllib/smpl_parser.py\",\n \"snippet\": \"class SMPL_Parser(_SMPL):\\n def __init__(self, create_transl=False, *args, **kwargs):\\n \\\"\\\"\\\"SMPL model constructor\\n Parameters\\n ----------\\n model_path: str\\n The path to the folder or to the file where the model\\n parameters are stored\\n data_struct: Strct\\n A struct object. If given, then the parameters of the model are\\n read from the object. Otherwise, the model tries to read the\\n parameters from the given `model_path`. (default = None)\\n create_global_orient: bool, optional\\n Flag for creating a member variable for the global orientation\\n of the body. (default = True)\\n global_orient: torch.tensor, optional, Bx3\\n The default value for the global orientation variable.\\n (default = None)\\n create_body_pose: bool, optional\\n Flag for creating a member variable for the pose of the body.\\n (default = True)\\n body_pose: torch.tensor, optional, Bx(Body Joints * 3)\\n The default value for the body pose variable.\\n (default = None)\\n create_betas: bool, optional\\n Flag for creating a member variable for the shape space\\n (default = True).\\n betas: torch.tensor, optional, Bx10\\n The default value for the shape member variable.\\n (default = None)\\n create_transl: bool, optional\\n Flag for creating a member variable for the translation\\n of the body. (default = True)\\n transl: torch.tensor, optional, Bx3\\n The default value for the transl variable.\\n (default = None)\\n dtype: torch.dtype, optional\\n The data type for the created variables\\n batch_size: int, optional\\n The batch size used for creating the member variables\\n joint_mapper: object, optional\\n An object that re-maps the joints. Useful if one wants to\\n re-order the SMPL joints to some other convention (e.g. MSCOCO)\\n (default = None)\\n gender: str, optional\\n Which gender to load\\n vertex_ids: dict, optional\\n A dictionary containing the indices of the extra vertices that\\n will be selected\\n \\\"\\\"\\\"\\n super(SMPL_Parser, self).__init__(*args, **kwargs)\\n self.device = next(self.parameters()).device\\n self.joint_names = SMPL_BONE_ORDER_NAMES\\n\\n self.joint_axes = {x: np.identity(3) for x in self.joint_names}\\n self.joint_dofs = {x: [\\\"x\\\", \\\"y\\\", \\\"z\\\"] for x in self.joint_names}\\n self.joint_range = {\\n x: np.hstack([np.ones([3, 1]) * -np.pi,\\n np.ones([3, 1]) * np.pi])\\n for x in self.joint_names\\n }\\n self.joint_range[\\\"L_Elbow\\\"] *= 4\\n self.joint_range[\\\"R_Elbow\\\"] *= 4\\n self.joint_range[\\\"L_Shoulder\\\"] *= 4\\n self.joint_range[\\\"R_Shoulder\\\"] *= 4\\n\\n self.contype = {1: self.joint_names}\\n self.conaffinity = {1: self.joint_names}\\n\\n # self.contype = {\\n # 3: ['Pelvis', 'L_Hip', 'L_Knee', 'L_Ankle', 'L_Toe', 'R_Hip', 'R_Knee','R_Ankle', 'R_Toe', 'Torso', 'Spine', 'Neck', 'Head','L_Thorax', 'L_Elbow', 'L_Wrist', 'L_Hand', 'R_Thorax', 'R_Elbow', 'R_Wrist', 'R_Hand'],\\n # 1: ['Chest', \\\"L_Shoulder\\\", \\\"R_Shoulder\\\"]\\n # }\\n\\n # self.conaffinity = {\\n # 1: ['Pelvis', 'L_Hip', 'L_Knee', 'L_Ankle', 'L_Toe', 'R_Hip', 'R_Knee','R_Ankle', 'R_Toe', 'Torso', 'Spine', 'Neck', 'Head','L_Thorax', 'L_Elbow', 'L_Wrist', 'L_Hand', 'R_Thorax', 'R_Elbow', 'R_Wrist', 'R_Hand'],\\n # 3: ['Chest', \\\"L_Shoulder\\\", \\\"R_Shoulder\\\"]\\n # }\\n\\n self.zero_pose = torch.zeros(1, 72).float()\\n\\n def forward(self, *args, **kwargs):\\n smpl_output = super(SMPL_Parser, self).forward(*args, **kwargs)\\n return smpl_output\\n\\n def get_joints_verts(self, pose, th_betas=None, th_trans=None):\\n \\\"\\\"\\\"\\n Pose should be batch_size x 72\\n \\\"\\\"\\\"\\n if pose.shape[1] != 72:\\n pose = pose.reshape(-1, 72)\\n\\n pose = pose.float()\\n if th_betas is not None:\\n th_betas = th_betas.float()\\n\\n if th_betas.shape[-1] == 16:\\n th_betas = th_betas[:, :10]\\n\\n batch_size = pose.shape[0]\\n\\n smpl_output = self.forward(\\n betas=th_betas,\\n transl=th_trans,\\n body_pose=pose[:, 3:],\\n global_orient=pose[:, :3],\\n )\\n vertices = smpl_output.vertices\\n joints = smpl_output.joints[:, :24]\\n # joints = smpl_output.joints[:,JOINST_TO_USE]\\n return vertices, joints\\n\\n def get_offsets(self, zero_pose=None, betas=torch.zeros(1, 10).float()):\\n with torch.no_grad():\\n if zero_pose is None:\\n verts, Jtr = self.get_joints_verts(self.zero_pose,\\n th_betas=betas)\\n else:\\n verts, Jtr = self.get_joints_verts(zero_pose, th_betas=betas)\\n verts_np = verts.detach().cpu().numpy()\\n jts_np = Jtr.detach().cpu().numpy()\\n parents = self.parents.cpu().numpy()\\n offsets_smpl = [np.array([0, 0, 0])]\\n for i in range(1, len(parents)):\\n p_id = parents[i]\\n p3d = jts_np[0, p_id]\\n curr_3d = jts_np[0, i]\\n offset_curr = curr_3d - p3d\\n offsets_smpl.append(offset_curr)\\n offsets_smpl = np.array(offsets_smpl)\\n joint_names = self.joint_names\\n joint_pos = Jtr[0].numpy()\\n smpl_joint_parents = self.parents.cpu().numpy()\\n joint_offsets = {\\n joint_names[c]:\\n (joint_pos[c] - joint_pos[p]) if c > 0 else joint_pos[c]\\n for c, p in enumerate(smpl_joint_parents)\\n }\\n parents_dict = {\\n joint_names[i]: joint_names[parents[i]]\\n for i in range(len(joint_names))\\n }\\n channels = [\\\"z\\\", \\\"y\\\", \\\"x\\\"]\\n skin_weights = self.lbs_weights.numpy()\\n return (verts[0], jts_np[0], skin_weights, self.joint_names,\\n joint_offsets, parents_dict, channels, self.joint_range)\\n\\n def get_mesh_offsets(self,\\n zero_pose=None,\\n betas=torch.zeros(1, 10),\\n flatfoot=False):\\n with torch.no_grad():\\n joint_names = self.joint_names\\n if zero_pose is None:\\n verts, Jtr = self.get_joints_verts(self.zero_pose,\\n th_betas=betas)\\n else:\\n verts, Jtr = self.get_joints_verts(zero_pose, th_betas=betas)\\n\\n verts_np = verts.detach().cpu().numpy()\\n verts = verts_np[0]\\n\\n if flatfoot:\\n feet_subset = verts[:, 1] < np.min(verts[:, 1]) + 0.01\\n verts[feet_subset, 1] = np.mean(verts[feet_subset][:, 1])\\n\\n smpl_joint_parents = self.parents.cpu().numpy()\\n\\n joint_pos = Jtr[0].numpy()\\n joint_offsets = {\\n joint_names[c]:\\n (joint_pos[c] - joint_pos[p]) if c > 0 else joint_pos[c]\\n for c, p in enumerate(smpl_joint_parents)\\n }\\n joint_parents = {\\n x: joint_names[i] if i >= 0 else None\\n for x, i in zip(joint_names, smpl_joint_parents)\\n }\\n\\n # skin_weights = smpl_layer.th_weights.numpy()\\n skin_weights = self.lbs_weights.numpy()\\n return (\\n verts,\\n joint_pos,\\n skin_weights,\\n joint_names,\\n joint_offsets,\\n joint_parents,\\n self.joint_axes,\\n self.joint_dofs,\\n self.joint_range,\\n self.contype,\\n self.conaffinity,\\n )\\n\\n def get_mesh_offsets_batch(self, betas=torch.zeros(1, 10), flatfoot=False):\\n with torch.no_grad():\\n joint_names = self.joint_names\\n verts, Jtr = self.get_joints_verts(self.zero_pose.repeat(\\n betas.shape[0], 1),\\n th_betas=betas)\\n verts_np = verts.detach().cpu().numpy()\\n verts = verts_np[0]\\n\\n if flatfoot:\\n feet_subset = verts[:, 1] < np.min(verts[:, 1]) + 0.01\\n verts[feet_subset, 1] = np.mean(verts[feet_subset][:, 1])\\n\\n smpl_joint_parents = self.parents.cpu().numpy()\\n\\n joint_pos = Jtr\\n joint_offsets = {\\n joint_names[c]:\\n (joint_pos[:, c] - joint_pos[:, p]) if c > 0 else joint_pos[:,\\n c]\\n for c, p in enumerate(smpl_joint_parents)\\n }\\n joint_parents = {\\n x: joint_names[i] if i >= 0 else None\\n for x, i in zip(joint_names, smpl_joint_parents)\\n }\\n\\n skin_weights = self.lbs_weights\\n return (\\n verts,\\n joint_pos,\\n skin_weights,\\n joint_names,\\n joint_offsets,\\n joint_parents,\\n self.joint_axes,\\n self.joint_dofs,\\n self.joint_range,\\n self.contype,\\n self.conaffinity,\\n )\"\n },\n {\n \"identifier\": \"SMPLH_Parser\",\n \"path\": \"uhc/smpllib/smpl_parser.py\",\n \"snippet\": \"class SMPLH_Parser(_SMPLH):\\n def __init__(self, *args, **kwargs):\\n super(SMPLH_Parser, self).__init__(*args, **kwargs)\\n self.device = next(self.parameters()).device\\n self.joint_names = SMPLH_BONE_ORDER_NAMES\\n self.joint_axes = {x: np.identity(3) for x in self.joint_names}\\n self.joint_dofs = {x: [\\\"z\\\", \\\"y\\\", \\\"x\\\"] for x in self.joint_names}\\n self.joint_range = {\\n x: np.hstack([np.ones([3, 1]) * -np.pi,\\n np.ones([3, 1]) * np.pi])\\n for x in self.joint_names\\n }\\n self.joint_range[\\\"L_Elbow\\\"] *= 4\\n self.joint_range[\\\"R_Elbow\\\"] *= 4\\n # import ipdb\\n # ipdb.set_trace()\\n\\n self.contype = {1: self.joint_names}\\n self.conaffinity = {1: self.joint_names}\\n self.zero_pose = torch.zeros(1, 156).float()\\n\\n def forward(self, *args, **kwargs):\\n smpl_output = super(SMPLH_Parser, self).forward(*args, **kwargs)\\n return smpl_output\\n\\n def get_joints_verts(self, pose, th_betas=None, th_trans=None):\\n \\\"\\\"\\\"\\n Pose should be batch_size x 156\\n \\\"\\\"\\\"\\n\\n if pose.shape[1] != 156:\\n pose = pose.reshape(-1, 156)\\n pose = pose.float()\\n if th_betas is not None:\\n th_betas = th_betas.float()\\n\\n batch_size = pose.shape[0]\\n smpl_output = self.forward(\\n body_pose=pose[:, 3:66],\\n global_orient=pose[:, :3],\\n L_hand_pose=pose[:, 66:111],\\n R_hand_pose=pose[:, 111:156],\\n betas=th_betas,\\n transl=th_trans,\\n )\\n vertices = smpl_output.vertices\\n joints = smpl_output.joints\\n # joints = smpl_output.joints[:,JOINST_TO_USE]\\n return vertices, joints\\n\\n def get_offsets(self, betas=torch.zeros(1, 16).float()):\\n with torch.no_grad():\\n verts, jts = self.get_joints_verts(self.zero_pose, th_betas=betas)\\n verts_np = verts.detach().cpu().numpy()\\n jts_np = jts.detach().cpu().numpy()\\n\\n parents = self.parents.cpu().numpy()\\n offsets_smpl = [np.array([0, 0, 0])]\\n for i in range(1, len(parents)):\\n p_id = parents[i]\\n p3d = jts_np[0, p_id]\\n curr_3d = jts_np[0, i]\\n offset_curr = curr_3d - p3d\\n offsets_smpl.append(offset_curr)\\n offsets_smpl = np.array(offsets_smpl)\\n names_smpl = self.joint_names\\n offset_smpl_dict = {\\n names_smpl[i]: offsets_smpl[i]\\n for i in range(len(names_smpl))\\n }\\n parents_dict = {\\n names_smpl[i]: names_smpl[parents[i]]\\n for i in range(len(names_smpl))\\n }\\n parents_dict[\\\"Hips\\\"] = \\\"None\\\"\\n channels = [\\\"z\\\", \\\"y\\\", \\\"x\\\"]\\n\\n return offset_smpl_dict, parents_dict, channels\\n\\n def get_mesh_offsets(self, betas=torch.zeros(1, 16), flatfoot=False):\\n with torch.no_grad():\\n joint_names = self.joint_names\\n verts, Jtr = self.get_joints_verts(self.zero_pose, th_betas=betas)\\n\\n verts_np = verts.detach().cpu().numpy()\\n verts = verts_np[0]\\n\\n if flatfoot:\\n feet_subset = verts[:, 1] < np.min(verts[:, 1]) + 0.01\\n verts[feet_subset, 1] = np.mean(verts[feet_subset][:, 1])\\n\\n smpl_joint_parents = self.parents.cpu().numpy()\\n joint_pos = Jtr[0].numpy()\\n joint_offsets = {\\n joint_names[c]:\\n (joint_pos[c] - joint_pos[p]) if c > 0 else joint_pos[c]\\n for c, p in enumerate(smpl_joint_parents)\\n }\\n joint_parents = {\\n x: joint_names[i] if i >= 0 else None\\n for x, i in zip(joint_names, smpl_joint_parents)\\n }\\n\\n # skin_weights = smpl_layer.th_weights.numpy()\\n skin_weights = self.lbs_weights.numpy()\\n return (\\n verts,\\n joint_pos,\\n skin_weights,\\n joint_names,\\n joint_offsets,\\n joint_parents,\\n self.joint_axes,\\n self.joint_dofs,\\n self.joint_range,\\n self.contype,\\n self.conaffinity,\\n )\"\n },\n {\n \"identifier\": \"SMPLX_Parser\",\n \"path\": \"uhc/smpllib/smpl_parser.py\",\n \"snippet\": \"class SMPLX_Parser(_SMPLX):\\n def __init__(self, *args, **kwargs):\\n super(SMPLX_Parser, self).__init__(*args, **kwargs)\\n self.device = next(self.parameters()).device\\n self.joint_names = SMPLH_BONE_ORDER_NAMES\\n self.joint_axes = {x: np.identity(3) for x in self.joint_names}\\n self.joint_dofs = {x: [\\\"z\\\", \\\"y\\\", \\\"x\\\"] for x in self.joint_names}\\n self.joint_range = {\\n x: np.hstack([np.ones([3, 1]) * -np.pi,\\n np.ones([3, 1]) * np.pi])\\n for x in self.joint_names\\n }\\n self.joint_range[\\\"L_Elbow\\\"] *= 4\\n self.joint_range[\\\"R_Elbow\\\"] *= 4\\n # import ipdb\\n # ipdb.set_trace()\\n\\n self.contype = {1: self.joint_names}\\n self.conaffinity = {1: self.joint_names}\\n self.zero_pose = torch.zeros(1, 156).float()\\n self.joint_to_use = [\\n SMPLX_BONE_ORDER_NAMES.index(i) for i in SMPLH_BONE_ORDER_NAMES\\n ]\\n self.parents_to_use = np.concatenate(\\n [np.arange(0, 22), np.arange(25, 55)])\\n\\n def forward(self, *args, **kwargs):\\n smpl_output = super(SMPLX_Parser, self).forward(*args, **kwargs)\\n return smpl_output\\n\\n def get_joints_verts(self, pose, th_betas=None, th_trans=None):\\n \\\"\\\"\\\"\\n Pose should be batch_size x 156\\n \\\"\\\"\\\"\\n\\n if pose.shape[1] != 156:\\n pose = pose.reshape(-1, 156)\\n pose = pose.float()\\n if th_betas is not None:\\n th_betas = th_betas.float()\\n\\n batch_size = pose.shape[0]\\n smpl_output = self.forward(\\n body_pose=pose[:, 3:66],\\n global_orient=pose[:, :3],\\n left_hand_pose=pose[:, 66:111],\\n right_hand_pose=pose[:, 111:156],\\n betas=th_betas,\\n transl=th_trans,\\n )\\n vertices = smpl_output.vertices\\n joints = smpl_output.joints\\n # return vertices, joints\\n return vertices, joints\\n\\n def get_offsets(self, v_template=None):\\n if not v_template is None:\\n self.v_template = v_template\\n with torch.no_grad():\\n verts, jts = self.get_joints_verts(self.zero_pose)\\n verts_np = verts.detach().cpu().numpy()\\n jts_np = jts.detach().cpu().numpy()\\n\\n parents = self.parents.cpu().numpy()\\n offsets_smpl = [np.array([0, 0, 0])]\\n for i in range(1, len(parents)):\\n p_id = parents[i]\\n p3d = jts_np[0, p_id]\\n curr_3d = jts_np[0, i]\\n offset_curr = curr_3d - p3d\\n offsets_smpl.append(offset_curr)\\n offsets_smpl = np.array(offsets_smpl)\\n names_smpl = self.joint_names\\n offset_smpl_dict = {\\n names_smpl[i]: offsets_smpl[i]\\n for i in range(len(names_smpl))\\n }\\n parents_dict = {\\n names_smpl[i]: names_smpl[parents[i]]\\n for i in range(len(names_smpl))\\n }\\n parents_dict[\\\"Hips\\\"] = \\\"None\\\"\\n channels = [\\\"z\\\", \\\"y\\\", \\\"x\\\"]\\n return offset_smpl_dict, parents_dict, channels\\n\\n def get_mesh_offsets(self, v_template=None):\\n if not v_template is None:\\n self.v_template = v_template\\n with torch.no_grad():\\n # joint_names = self.joint_names\\n joint_names = SMPLX_BONE_ORDER_NAMES\\n verts, Jtr = self.get_joints_verts(self.zero_pose)\\n\\n smpl_joint_parents = self.parents.cpu().numpy()\\n joint_pos = Jtr[0].numpy()\\n # print(\\n # joint_pos.shape,\\n # smpl_joint_parents.shape,\\n # len(self.parents_to_use),\\n # self.parents.cpu().numpy().shape,\\n # )\\n joint_offsets = {\\n joint_names[c]:\\n (joint_pos[c] - joint_pos[p]) if c > 0 else joint_pos[c]\\n for c, p in enumerate(smpl_joint_parents)\\n if joint_names[c] in self.joint_names\\n }\\n joint_parents = {\\n x: joint_names[i] if i >= 0 else None\\n for x, i in zip(joint_names, smpl_joint_parents)\\n if joint_names[i] in self.joint_names\\n }\\n\\n verts = verts[0].numpy()\\n # skin_weights = smpl_layer.th_weights.numpy()\\n skin_weights = self.lbs_weights.numpy()[:, self.parents_to_use]\\n return (\\n verts,\\n joint_pos,\\n skin_weights,\\n self.joint_names,\\n joint_offsets,\\n joint_parents,\\n self.joint_axes,\\n self.joint_dofs,\\n self.joint_range,\\n self.contype,\\n self.conaffinity,\\n )\"\n },\n {\n \"identifier\": \"flags\",\n \"path\": \"pacer/utils/flags.py\",\n \"snippet\": \"class Flags(object):\\n def __init__(self, items):\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from ast import Try\nfrom enum import Enum\nfrom matplotlib.pyplot import flag\nfrom torch import Tensor\nfrom typing import Dict, Optional\nfrom isaacgym import gymapi\nfrom isaacgym import gymtorch\nfrom env.tasks.humanoid import Humanoid, dof_to_obs, remove_base_rot, dof_to_obs_smpl\nfrom env.util import gym_util\nfrom pacer.utils.motion_lib import MotionLib\nfrom pacer.utils.motion_lib_smpl import MotionLib as MotionLibSMPL\nfrom isaacgym.torch_utils import *\nfrom utils import torch_utils\nfrom uhc.smpllib.smpl_parser import (\n SMPL_Parser,\n SMPLH_Parser,\n SMPLX_Parser,\n)\nfrom pacer.utils.flags import flags\n from poselib.poselib.skeleton.skeleton3d import SkeletonMotion, SkeletonState\n from poselib.poselib.visualization.common import plot_skeleton_motion_interactive\nimport glob\nimport os\nimport sys\nimport pdb\nimport os.path as osp\nimport numpy as np\nimport torch\nimport gc"},"token_num":{"kind":"number","value":15851,"string":"15,851"},"cropped_code":{"kind":"string","value":"# Copyright (c) 2023, 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.\nsys.path.append(os.getcwd())\n\n\n\n\n\nHACK_MOTION_SYNC = False\n# HACK_MOTION_SYNC = True\nHACK_CONSISTENCY_TEST = False\nHACK_OUTPUT_MOTION = False\nHACK_OUTPUT_MOTION_ALL = False\n\n\nclass HumanoidAMP(Humanoid):\n class StateInit(Enum):\n Default = 0\n Start = 1\n Random = 2\n Hybrid = 3\n\n def __init__(self, cfg, sim_params, physics_engine, device_type, device_id,\n headless):\n # jp hack\n if (HACK_MOTION_SYNC or HACK_CONSISTENCY_TEST):\n control_freq_inv = cfg[\"env\"][\"controlFrequencyInv\"]\n self._motion_sync_dt = control_freq_inv * sim_params.dt\n cfg[\"env\"][\"controlFrequencyInv\"] = 1\n cfg[\"env\"][\"pdControl\"] = False\n\n state_init = cfg[\"env\"][\"stateInit\"]\n self._state_init = HumanoidAMP.StateInit[state_init]\n self._hybrid_init_prob = cfg[\"env\"][\"hybridInitProb\"]\n self._num_amp_obs_steps = cfg[\"env\"][\"numAMPObsSteps\"]\n self._amp_root_height_obs = cfg[\"env\"].get(\"ampRootHeightObs\", False)\n\n assert (self._num_amp_obs_steps >= 2)\n\n if (\"enableHistObs\" in cfg[\"env\"]):\n self._enable_hist_obs = cfg[\"env\"][\"enableHistObs\"]\n else:\n self._enable_hist_obs = False\n\n self._reset_default_env_ids = []\n self._reset_ref_env_ids = []\n self._state_reset_happened = False\n\n super().__init__(cfg=cfg,\n sim_params=sim_params,\n physics_engine=physics_engine,\n device_type=device_type,\n device_id=device_id,\n headless=headless)\n\n self._motion_start_times = torch.zeros(self.num_envs).to(self.device)\n self._sampled_motion_ids = torch.zeros(self.num_envs).long().to(self.device)\n motion_file = cfg['env']['motion_file']\n self._load_motion(motion_file)\n\n self._amp_obs_buf = torch.zeros(\n (self.num_envs, self._num_amp_obs_steps,\n self._num_amp_obs_per_step),\n device=self.device,\n dtype=torch.float)\n self._curr_amp_obs_buf = self._amp_obs_buf[:, 0]\n self._hist_amp_obs_buf = self._amp_obs_buf[:, 1:]\n\n self._amp_obs_demo_buf = None\n\n data_dir = \"data/smpl\"\n self.smpl_parser_n = SMPL_Parser(model_path=data_dir,\n gender=\"neutral\").to(self.device)\n self.smpl_parser_m = SMPL_Parser(model_path=data_dir,\n gender=\"male\").to(self.device)\n self.smpl_parser_f = SMPL_Parser(model_path=data_dir,\n gender=\"female\").to(self.device)\n\n self.start = True # camera flag\n self.ref_motion_cache = {}\n return\n\n def resample_motions(self):\n # self.gym.destroy_sim(self.sim)\n # del self.sim\n # if not self.headless:\n # self.gym.destroy_viewer(self.viewer)\n # self.create_sim()\n # self.gym.prepare_sim(self.sim)\n # self.create_viewer()\n # self._setup_tensors()\n print(\"Partial solution, only resample motions...\")\n self._motion_lib.load_motions(skeleton_trees = self.skeleton_trees, limb_weights = self.humanoid_limb_and_weights.cpu(), gender_betas = self.humanoid_betas.cpu()) # For now, only need to sample motions since there are only 400 hmanoids\n # self.reset()\n # torch.cuda.empty_cache()\n # gc.collect()\n\n def pre_physics_step(self, actions):\n if (HACK_MOTION_SYNC or HACK_CONSISTENCY_TEST):\n actions *= 0\n\n"},"all_code":{"kind":"string","value":"# Copyright (c) 2023, 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.\nsys.path.append(os.getcwd())\n\n\n\n\n\nHACK_MOTION_SYNC = False\n# HACK_MOTION_SYNC = True\nHACK_CONSISTENCY_TEST = False\nHACK_OUTPUT_MOTION = False\nHACK_OUTPUT_MOTION_ALL = False\n\n\nclass HumanoidAMP(Humanoid):\n class StateInit(Enum):\n Default = 0\n Start = 1\n Random = 2\n Hybrid = 3\n\n def __init__(self, cfg, sim_params, physics_engine, device_type, device_id,\n headless):\n # jp hack\n if (HACK_MOTION_SYNC or HACK_CONSISTENCY_TEST):\n control_freq_inv = cfg[\"env\"][\"controlFrequencyInv\"]\n self._motion_sync_dt = control_freq_inv * sim_params.dt\n cfg[\"env\"][\"controlFrequencyInv\"] = 1\n cfg[\"env\"][\"pdControl\"] = False\n\n state_init = cfg[\"env\"][\"stateInit\"]\n self._state_init = HumanoidAMP.StateInit[state_init]\n self._hybrid_init_prob = cfg[\"env\"][\"hybridInitProb\"]\n self._num_amp_obs_steps = cfg[\"env\"][\"numAMPObsSteps\"]\n self._amp_root_height_obs = cfg[\"env\"].get(\"ampRootHeightObs\", False)\n\n assert (self._num_amp_obs_steps >= 2)\n\n if (\"enableHistObs\" in cfg[\"env\"]):\n self._enable_hist_obs = cfg[\"env\"][\"enableHistObs\"]\n else:\n self._enable_hist_obs = False\n\n self._reset_default_env_ids = []\n self._reset_ref_env_ids = []\n self._state_reset_happened = False\n\n super().__init__(cfg=cfg,\n sim_params=sim_params,\n physics_engine=physics_engine,\n device_type=device_type,\n device_id=device_id,\n headless=headless)\n\n self._motion_start_times = torch.zeros(self.num_envs).to(self.device)\n self._sampled_motion_ids = torch.zeros(self.num_envs).long().to(self.device)\n motion_file = cfg['env']['motion_file']\n self._load_motion(motion_file)\n\n self._amp_obs_buf = torch.zeros(\n (self.num_envs, self._num_amp_obs_steps,\n self._num_amp_obs_per_step),\n device=self.device,\n dtype=torch.float)\n self._curr_amp_obs_buf = self._amp_obs_buf[:, 0]\n self._hist_amp_obs_buf = self._amp_obs_buf[:, 1:]\n\n self._amp_obs_demo_buf = None\n\n data_dir = \"data/smpl\"\n self.smpl_parser_n = SMPL_Parser(model_path=data_dir,\n gender=\"neutral\").to(self.device)\n self.smpl_parser_m = SMPL_Parser(model_path=data_dir,\n gender=\"male\").to(self.device)\n self.smpl_parser_f = SMPL_Parser(model_path=data_dir,\n gender=\"female\").to(self.device)\n\n self.start = True # camera flag\n self.ref_motion_cache = {}\n return\n\n def resample_motions(self):\n # self.gym.destroy_sim(self.sim)\n # del self.sim\n # if not self.headless:\n # self.gym.destroy_viewer(self.viewer)\n # self.create_sim()\n # self.gym.prepare_sim(self.sim)\n # self.create_viewer()\n # self._setup_tensors()\n print(\"Partial solution, only resample motions...\")\n self._motion_lib.load_motions(skeleton_trees = self.skeleton_trees, limb_weights = self.humanoid_limb_and_weights.cpu(), gender_betas = self.humanoid_betas.cpu()) # For now, only need to sample motions since there are only 400 hmanoids\n # self.reset()\n # torch.cuda.empty_cache()\n # gc.collect()\n\n def pre_physics_step(self, actions):\n if (HACK_MOTION_SYNC or HACK_CONSISTENCY_TEST):\n actions *= 0\n"},"next_line":{"kind":"string","value":" if flags.debug:"},"gold_snippet_index":{"kind":"number","value":5,"string":"5"},"created_at":{"kind":"string","value":"2023-10-31 20:47:12+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5999,"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":17931,"string":"17,931"},"cropped_code":{"kind":"string","value":" def test_gets_loss_and_correct_activations(\n self,\n full_activation_store: ActivationStore,\n autoencoder_model: SparseAutoencoder,\n ) -> None:\n \"\"\"Test it gets loss and also returns the input activations.\"\"\"\n resampler = ActivationResampler(\n n_components=DEFAULT_N_COMPONENTS,\n n_learned_features=DEFAULT_N_LEARNED_FEATURES,\n resample_dataset_size=DEFAULT_N_ACTIVATIONS_STORE,\n )\n loss, input_activations = resampler.compute_loss_and_get_activations(\n store=full_activation_store,\n autoencoder=autoencoder_model,\n loss_fn=L2ReconstructionLoss(),\n train_batch_size=DEFAULT_N_ACTIVATIONS_STORE,\n )\n\n assert isinstance(loss, Tensor)\n assert isinstance(input_activations, Tensor)\n\n # Check that the activations are the same as the input data\n assert torch.equal(input_activations, full_activation_store._data) # type: ignore # noqa: SLF001\n\n def test_more_items_than_in_store_error(\n self,\n full_activation_store: ActivationStore,\n autoencoder_model: SparseAutoencoder,\n ) -> None:\n \"\"\"Test that an error is raised if there are more items than in the store.\"\"\"\n with pytest.raises(\n ValueError,\n match=r\"Cannot get \\d+ items from the store, as only \\d+ were available.\",\n ):\n ActivationResampler(\n resample_dataset_size=DEFAULT_N_ACTIVATIONS_STORE + 1,\n n_learned_features=DEFAULT_N_LEARNED_FEATURES,\n ).compute_loss_and_get_activations(\n store=full_activation_store,\n autoencoder=autoencoder_model,\n loss_fn=L2ReconstructionLoss(),\n train_batch_size=DEFAULT_N_ACTIVATIONS_STORE + 1,\n )\n\n\nclass TestAssignSamplingProbabilities:\n \"\"\"Test the assign sampling probabilities method.\"\"\"\n\n @pytest.mark.parametrize(\n (\"loss\"),\n [\n (torch.tensor([1.0, 2.0, 3.0])),\n (torch.tensor([2.0, 3.0, 5.0])),\n (torch.tensor([0.0, 100.0])),\n ],\n )\n def test_assign_sampling_probabilities(self, loss: Tensor) -> None:\n \"\"\"Test that sampling probabilities are correctly assigned based on loss.\"\"\"\n probabilities = ActivationResampler.assign_sampling_probabilities(loss)\n\n # Compare against non-vectorized implementation\n squared_loss = [batch_item_loss.item() ** 2 for batch_item_loss in loss]\n sum_squared = sum(squared_loss)\n proportions = [item / sum_squared for item in squared_loss]\n expected_probabilities = torch.tensor(proportions)\n\n assert torch.allclose(\n probabilities, expected_probabilities, atol=1e-4\n ), f\"Expected probabilities {expected_probabilities} but got {probabilities}\"\n\n\nclass TestSampleInput:\n \"\"\"Tests for sample_input.\"\"\"\n\n def test_distribution(self) -> None:\n \"\"\"Test that sample approximately matches a multinomial distribution.\"\"\"\n torch.manual_seed(0)\n\n probabilities = torch.tensor([0.1, 0.2, 0.7])\n\n results = [0, 0, 0]\n for _ in range(10_000):\n input_activations = torch.tensor([[0.0, 0], [1, 1], [2, 2]])\n sampled_input = ActivationResampler.sample_input(probabilities, input_activations, [1])\n\n # Get the input activation index (the first element is also the index)\n sampled_activation_idx = sampled_input[0][0, 0].item()\n\n results[int(sampled_activation_idx)] += 1\n\n resulting_probabilities = torch.tensor([item / sum(results) for item in results])\n\n assert torch.allclose(\n resulting_probabilities, probabilities, atol=1e-2\n ), f\"Expected probabilities {probabilities} but got {resulting_probabilities}\"\n\n def test_zero_probabilities(self) -> None:\n \"\"\"Test where there are no dead neurons.\"\"\"\n probabilities = torch.tensor([[0.0], [0.0], [1.0]])\n input_activations = torch.tensor([[[0.0, 0]], [[1, 1]], [[2, 2]]])\n sampled_input = ActivationResampler.sample_input(probabilities, input_activations, [0])\n assert sampled_input[0].shape == (0, 2), \"Should return an empty tensor\"\n\n def test_sample_input_raises_value_error(self) -> None:\n \"\"\"Test that ValueError is raised on length miss-match.\"\"\"\n probabilities = torch.tensor([0.1, 0.2, 0.7])\n input_activations = torch.tensor([[1.0, 2], [3, 4], [5, 6]])\n n_samples = [4] # More than the number of input activations\n\n with pytest.raises(\n ValueError, match=r\"Cannot sample \\d+ inputs from \\d+ input activations.\"\n ):\n ActivationResampler.sample_input(probabilities, input_activations, n_samples)\n\n\nclass TestRenormalizeAndScale:\n \"\"\"Tests for renormalize_and_scale.\"\"\"\n\n @staticmethod\n def calculate_expected_output(\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(\n SparseAutoencoderConfig(\n n_input_features=DEFAULT_N_INPUT_FEATURES,\n n_learned_features=DEFAULT_N_LEARNED_FEATURES,\n n_components=DEFAULT_N_COMPONENTS,\n )\n )\n\n\n@pytest.fixture()\ndef loss_fn() -> LossReducer:\n \"\"\"Loss function fixture.\"\"\"\n return LossReducer(LearnedActivationsL1Loss(0.01), L2ReconstructionLoss())\n\n\n@pytest.fixture()\ndef activation_resampler_single_item_triggers() -> ActivationResampler:\n \"\"\"Activation resampler where any call to step will result in resampling.\"\"\"\n return ActivationResampler(\n n_activations_activity_collate=1,\n n_learned_features=DEFAULT_N_LEARNED_FEATURES,\n resample_dataset_size=1,\n resample_interval=1,\n threshold_is_dead_portion_fires=0.0,\n )\n\n\nclass TestInit:\n \"\"\"Tests for the activation resampler initialisation.\"\"\"\n\n @pytest.mark.parametrize(\n (\"resample_interval\", \"n_steps_collate\", \"expected_window_start\"),\n [(100, 50, 50), (100, 100, 0)],\n )\n def test_neuron_activity_window_start(\n self, resample_interval: int, n_steps_collate: int, expected_window_start: int\n ) -> None:\n \"\"\"Test the neuron activity window start is set correctly.\"\"\"\n resampler = ActivationResampler(\n n_learned_features=10,\n resample_interval=resample_interval,\n n_activations_activity_collate=n_steps_collate,\n )\n\n assert resampler.neuron_activity_window_start == expected_window_start\n\n\nclass TestComputeLossAndGetActivations:\n \"\"\"Tests for compute_loss_and_get_activations.\"\"\"\n\n def test_gets_loss_and_correct_activations(\n self,\n full_activation_store: ActivationStore,\n autoencoder_model: SparseAutoencoder,\n ) -> None:\n \"\"\"Test it gets loss and also returns the input activations.\"\"\"\n resampler = ActivationResampler(\n n_components=DEFAULT_N_COMPONENTS,\n n_learned_features=DEFAULT_N_LEARNED_FEATURES,\n resample_dataset_size=DEFAULT_N_ACTIVATIONS_STORE,\n )\n loss, input_activations = resampler.compute_loss_and_get_activations(\n store=full_activation_store,\n autoencoder=autoencoder_model,\n loss_fn=L2ReconstructionLoss(),\n train_batch_size=DEFAULT_N_ACTIVATIONS_STORE,\n )\n\n assert isinstance(loss, Tensor)\n assert isinstance(input_activations, Tensor)\n\n # Check that the activations are the same as the input data\n assert torch.equal(input_activations, full_activation_store._data) # type: ignore # noqa: SLF001\n\n def test_more_items_than_in_store_error(\n self,\n full_activation_store: ActivationStore,\n autoencoder_model: SparseAutoencoder,\n ) -> None:\n \"\"\"Test that an error is raised if there are more items than in the store.\"\"\"\n with pytest.raises(\n ValueError,\n match=r\"Cannot get \\d+ items from the store, as only \\d+ were available.\",\n ):\n ActivationResampler(\n resample_dataset_size=DEFAULT_N_ACTIVATIONS_STORE + 1,\n n_learned_features=DEFAULT_N_LEARNED_FEATURES,\n ).compute_loss_and_get_activations(\n store=full_activation_store,\n autoencoder=autoencoder_model,\n loss_fn=L2ReconstructionLoss(),\n train_batch_size=DEFAULT_N_ACTIVATIONS_STORE + 1,\n )\n\n\nclass TestAssignSamplingProbabilities:\n \"\"\"Test the assign sampling probabilities method.\"\"\"\n\n @pytest.mark.parametrize(\n (\"loss\"),\n [\n (torch.tensor([1.0, 2.0, 3.0])),\n (torch.tensor([2.0, 3.0, 5.0])),\n (torch.tensor([0.0, 100.0])),\n ],\n )\n def test_assign_sampling_probabilities(self, loss: Tensor) -> None:\n \"\"\"Test that sampling probabilities are correctly assigned based on loss.\"\"\"\n probabilities = ActivationResampler.assign_sampling_probabilities(loss)\n\n # Compare against non-vectorized implementation\n squared_loss = [batch_item_loss.item() ** 2 for batch_item_loss in loss]\n sum_squared = sum(squared_loss)\n proportions = [item / sum_squared for item in squared_loss]\n expected_probabilities = torch.tensor(proportions)\n\n assert torch.allclose(\n probabilities, expected_probabilities, atol=1e-4\n ), f\"Expected probabilities {expected_probabilities} but got {probabilities}\"\n\n\nclass TestSampleInput:\n \"\"\"Tests for sample_input.\"\"\"\n\n def test_distribution(self) -> None:\n \"\"\"Test that sample approximately matches a multinomial distribution.\"\"\"\n torch.manual_seed(0)\n\n probabilities = torch.tensor([0.1, 0.2, 0.7])\n\n results = [0, 0, 0]\n for _ in range(10_000):\n input_activations = torch.tensor([[0.0, 0], [1, 1], [2, 2]])\n sampled_input = ActivationResampler.sample_input(probabilities, input_activations, [1])\n\n # Get the input activation index (the first element is also the index)\n sampled_activation_idx = sampled_input[0][0, 0].item()\n\n results[int(sampled_activation_idx)] += 1\n\n resulting_probabilities = torch.tensor([item / sum(results) for item in results])\n\n assert torch.allclose(\n resulting_probabilities, probabilities, atol=1e-2\n ), f\"Expected probabilities {probabilities} but got {resulting_probabilities}\"\n\n def test_zero_probabilities(self) -> None:\n \"\"\"Test where there are no dead neurons.\"\"\"\n probabilities = torch.tensor([[0.0], [0.0], [1.0]])\n input_activations = torch.tensor([[[0.0, 0]], [[1, 1]], [[2, 2]]])\n sampled_input = ActivationResampler.sample_input(probabilities, input_activations, [0])\n assert sampled_input[0].shape == (0, 2), \"Should return an empty tensor\"\n\n def test_sample_input_raises_value_error(self) -> None:\n \"\"\"Test that ValueError is raised on length miss-match.\"\"\"\n probabilities = torch.tensor([0.1, 0.2, 0.7])\n input_activations = torch.tensor([[1.0, 2], [3, 4], [5, 6]])\n n_samples = [4] # More than the number of input activations\n\n with pytest.raises(\n ValueError, match=r\"Cannot sample \\d+ inputs from \\d+ input activations.\"\n ):\n ActivationResampler.sample_input(probabilities, input_activations, n_samples)\n\n\nclass TestRenormalizeAndScale:\n \"\"\"Tests for renormalize_and_scale.\"\"\"\n\n @staticmethod\n def calculate_expected_output("},"next_line":{"kind":"string","value":" sampled_input: Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)],"},"gold_snippet_index":{"kind":"number","value":8,"string":"8"},"created_at":{"kind":"string","value":"2023-10-27 07:37:15+00:00"},"level":{"kind":"string","value":"24k"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":59,"numItemsPerPage":100,"numTotalItems":8033,"offset":5900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDE3NTM1Mywic3ViIjoiL2RhdGFzZXRzL3RpYW55YW5nL3JlcG9iZW5jaF9weXRob25fdjEuMSIsImV4cCI6MTc3NDE3ODk1MywiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.vHiOYgK0scN_zxoxW1px_NThNr2hz7SMt4H_dkNxVj6EjhDViqkZHAZAS6ROjAYZTfTBGMjTm8iNpYdqZyNECg","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 |
|---|---|---|---|---|---|---|---|---|---|---|
aliyun/pai-python-sdk | pai/model.py | [
{
"identifier": "git_utils",
"path": "pai/common/git_utils.py",
"snippet": "def git_clone_repo(git_config: Dict[str, str], source_dir: Optional[str] = None):\ndef _validate_git_config(git_config):\ndef _build_and_run_clone_command(git_config, dest_dir):\ndef _clone_command_for_codeup(git_config, dest_di... | import copy
import distutils.dir_util
import json
import logging
import os.path
import posixpath
import shlex
import shutil
import tempfile
import textwrap
import time
import requests
from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
from addict import Dict as AttrDict
from oss2 import ObjectIterator
from .common import git_utils
from .common.consts import INSTANCE_TYPE_LOCAL_GPU, ModelFormat
from .common.docker_utils import ContainerRun, run_container
from .common.oss_utils import OssUriObj, download, is_oss_uri, upload
from .common.utils import (
generate_repr,
is_local_run_instance_type,
random_str,
to_plain_text,
)
from .exception import DuplicatedMountException, MountPathIsOccupiedException
from .image import ImageInfo
from .predictor import AsyncPredictor, LocalPredictor, Predictor, ServiceType
from .serializers import SerializerBase
from .session import Session, get_default_session
from .estimator import AlgorithmEstimator | 17,210 |
if instance_count:
inference_spec.add_option("metadata.instance", instance_count)
if instance_type:
inference_spec.add_option("cloud.computing.instance_type", instance_type)
elif resource_config:
inference_spec.add_option("metadata.cpu", resource_config.cpu)
inference_spec.add_option("metadata.memory", resource_config.memory)
if resource_config.gpu:
inference_spec.add_option("metadata.gpu", resource_config.gpu)
if resource_config.gpu_memory:
inference_spec.add_option(
"metadata.gpu_memory", resource_config.gpu_memory
)
if resource_config.gpu:
logger.warning(
"Parameters 'gpu' is set, the 'gpu_memory' parameter "
"does not take effect."
)
if resource_id:
inference_spec.add_option("metadata.resource", resource_id)
if options:
inference_spec.merge_options(options=options)
return inference_spec.to_dict()
def _deploy_local(
self,
instance_type: str,
serializer: SerializerBase = None,
wait: bool = True,
) -> LocalPredictor:
"""Deploy the model in local using docker."""
if not self.inference_spec.is_container_serving():
raise RuntimeError(
"Currently, only model using the InferenceSpec that serving with"
" container support local run."
)
if len(self.inference_spec.containers) > 1:
raise RuntimeError(
"InferenceSpec that serving with multiple container "
"does not support local run."
)
# prepare model data to local
work_dir = tempfile.mkdtemp()
model_dir = os.path.join(work_dir, "model")
self._download_model_data(target_dir=model_dir)
volumes = {
model_dir: {
"bind": DefaultServiceConfig.model_path,
"mode": "rw",
}
}
# prepare used storage to local directory.
if "storage" in self.inference_spec:
# only OSS storage config support local run.
if any(s for s in self.inference_spec.storage if "oss" not in s):
raise ValueError(
f"Local run only support InferenceSpec using OSS storage config: "
f"{self.inference_spec.to_dict()}"
)
for idx, storage in enumerate(self.inference_spec.storage):
store_dir = os.path.join(work_dir, f"storage_{idx}")
os.makedirs(store_dir, exist_ok=True)
oss_uri = OssUriObj(storage.oss.path)
download(
oss_path=oss_uri.object_key,
local_path=store_dir,
bucket=self.session.get_oss_bucket(oss_uri.bucket_name),
)
volumes[store_dir] = {"bind": storage.mount_path, "mode": "rw"}
container_spec = self.inference_spec.containers[0].to_dict()
env_vars = {
item["name"]: item["value"] for item in container_spec.get("env", [])
}
# build local launch script
requirements_list = container_spec.get("prepare", dict()).get(
"pythonRequirements", []
)
requirements_path = container_spec.get("prepare", dict()).get(
"pythonRequirementsPath", None
)
# build command to install requirements
if requirements_list:
install_requirements = " ".join(
[
shlex.quote(s)
for s in ["python", "-m", "pip", "install"] + requirements_list
]
)
elif requirements_path:
install_requirements = " ".join(
[
shlex.quote(s)
for s in ["python", "-m", "pip", "install", "-r", requirements_path]
]
)
else:
install_requirements = ""
user_scripts = container_spec.get("script", "")
launch_script = textwrap.dedent(
f"""\
set -e
{install_requirements}
{user_scripts}
"""
)
| # Copyright 2023 Alibaba, Inc. or its affiliates.
#
# 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
#
# https://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.
logger = logging.getLogger(__name__)
# Reserved ports for internal use, do not use them for service
_RESERVED_PORTS = [8080, 9090]
class DefaultServiceConfig(object):
"""Default configuration used in creating prediction service."""
# Listen Port
listen_port = 8000
# Default model path in container
model_path = "/eas/workspace/model/"
# Default user code path in container
code_path = "/ml/usercode/"
class ResourceConfig(object):
"""A class that represents the resource used by a PAI prediction service
instance."""
def __init__(self, cpu: int, memory: int, gpu: int = None, gpu_memory: int = None):
"""ResourceConfig initializer.
The public resource group does not support requesting GPU resources with
`ResourceConfig`. Use the 'gpu' and 'gpu_memory' parameter only for services
deployed to dedicated resource groups that provide GPU machine instances.
Args:
cpu (int): The number of CPUs that each instance requires.
memory (int): The amount of memory that each instance requires,
must be an integer, Unit: MB.
gpu (int): The number of GPUs that each instance requires.
gpu_memory (int): The amount of GPU memory that each instance requires.
The value must be an integer, Unit: GB.
PAI allows memory resources of a GPU to be allocated to multiple instances.
If you want multiple instances to share the memory resources of a GPU,
set the gpu parameter to 0. If you set the ``gpu`` parameter to 1, each
instance occupies a GPU and the gpu_memory parameter does not take effect.
.. note::
**Important** PAI does not enable the strict isolation of GPU memory.
To prevent out of memory (OOM) errors, make sure that the GPU memory
used by each instance does not exceed the requested amount.
"""
self.cpu = cpu
self.memory = memory
self.gpu = gpu
self.gpu_memory = gpu_memory
def __repr__(self):
return (
f"ResourceConfig(cpu={self.cpu}, memory={self.memory}MB, gpu={self.gpu or 0},"
f" gpu_memory={self.gpu_memory or 0}GB)"
)
def __str__(self):
return self.__repr__()
def to_dict(self):
"""Transform the ResourceConfig instance to a dictionary.
Returns:
dict:
"""
res = {
"cpu": self.cpu,
"gpu": self.gpu,
"gpu_memory": self.gpu_memory,
"memory": self.memory,
}
return {k: v for k, v in res.items() if v is not None}
class InferenceSpec(object):
"""A class used to describe how to create a prediction service.
InferenceSpec is using to describe how the model is serving in PAI. To view the
full supported parameters, please see the following hyperlink:
`Parameters of model services <https://help.aliyun.com/document_detail/450525.htm>`_.
Example of how to config a InferneceSpec::
>>> # build an inference_spec that using XGBoost processor.
>>> infer_spec = InferenceSpec(processor="xgboost")
>>> infer_spec.metadata.rpc.keepalive = 1000
>>> infer_spec.warm_up_data_path = "oss://bucket-name/path/to/warmup-data"
>>> infer_spec.add_option("metadata.rpc.max_batch_size", 8)
>>> print(infer_spec.processor)
xgboost
>>> print(infer_spec.metadata.rpc.keepalive)
1000
>>> print(infer_spec.metadata.rpc.max_batch_size)
8
>>> print(infer_spec.to_dict())
{'processor': 'xgboost', 'metadata': {'rpc': {'keepalive': 1000, 'max_batch_size': 8}},
'warm_up_data_path': 'oss://bucket-name/path/to/warmup-data'}
"""
def __init__(self, *args, **kwargs):
"""InferenceSpec initializer.
Args:
**kwargs: Parameters of the inference spec.
"""
properties = kwargs.pop("__properties", [])
cfg_dict = copy.deepcopy(kwargs)
cfg_dict = {k: v for k, v in cfg_dict.items() if not k.startswith("_")}
if args:
if len(args) > 1:
raise TypeError()
cfg_dict.update(args[0])
super(InferenceSpec, self).__setattr__(
"_cfg_dict", self._transform_value(cfg_dict)
)
super(InferenceSpec, self).__setattr__("__properties", properties)
def __repr__(self):
return json.dumps(self.to_dict(), sort_keys=True, indent=4)
def _transform_value(self, value):
if isinstance(value, (List, Tuple)):
return [self._transform_value(item) for item in value]
elif isinstance(value, (Dict, AttrDict)):
return AttrDict(
{key: self._transform_value(value) for key, value in value.items()}
)
return value
def __missing__(self, name):
return self._cfg_dict.__missing__(name)
def __setitem__(self, name, value):
return self._cfg_dict.__setitem__(name, self._transform_value(value))
def __setattr__(self, name, value):
if name in getattr(self, "__properties"):
super(InferenceSpec, self).__setattr__(name, self._transform_value(value))
else:
self._cfg_dict.__setattr__(name, self._transform_value(value))
def __getattr__(self, item):
if item.startswith("_"):
return getattr(self, item)
return self._cfg_dict.__getitem__(item)
def __contains__(self, item):
return item in self._cfg_dict
def to_dict(self) -> Dict:
"""Return a dictionary that represent the InferenceSpec."""
return self._cfg_dict.to_dict()
def add_option(self, name: str, value):
"""Add an option to the inference_spec instance.
Args:
name (str): Name of the option to set, represented as the JSON path of the
parameter for the InferenceSpec. To view the full supported parameters,
please see the following hyperlink: `Parameters of model services
<https://help.aliyun.com/document_detail/450525.htm>`_.
value: Value for the option.
Examples:
>>> infer_spec = InferenceSpec(processor="tensorflow_gpu_1.12")
>>> infer_spec.add_option("metadata.rpc.keepalive", 10000)
>>> infer_spec.metadata.rpc.keepalive
10000
>>> infer_spec.to_dict()
{'processor': 'tensorflow_gpu_1.12', 'metadata': {'rpc': {'keepalive': 10000}}}
"""
src = self._transform_value(value)
for k in reversed(name.split(".")):
src = {k: src}
self._cfg_dict.update(AttrDict(src))
def merge_options(self, options: Dict[str, Any]):
"""Merge options from a dictionary."""
for key, value in options.items():
self.add_option(key, value)
@classmethod
def from_dict(cls, config: Dict[str, Any]) -> "InferenceSpec":
"""Initialize a InferenceSpec from a dictionary.
You can use this method to initialize a InferenceSpec instance
from a dictionary.
Returns:
:class:`pai.model.InferenceSpec`: A InferenceSpec instance.
"""
config = config or dict()
return cls(**config)
def is_container_serving(self):
return "containers" in self._cfg_dict
@classmethod
def _upload_source_dir(cls, source_dir, session):
"""Upload source files to OSS bucket."""
if not os.path.exists(source_dir):
raise ValueError(f"Input source code path does not exist: {source_dir}.")
if not os.path.isdir(source_dir):
raise ValueError(
f"Input source code path should be a directory: {source_dir}."
)
target_dir = session.get_storage_path_by_category(category="inference_src")
# upload local script data to the OSS bucket.
uploaded_source_code = upload(
source_dir,
target_dir,
session.oss_bucket,
)
logger.debug("Uploaded source code to OSS: %s", uploaded_source_code)
return uploaded_source_code
def mount(
self,
source: str,
mount_path: str,
session: Session = None,
) -> Dict[str, Any]:
"""Mount a source storage to the running container.
.. note::
If source is a local path, it will be uploaded to the OSS bucket and
mounted. If source is a OSS path, it will be mounted directly.
Args:
source (str): The source storage to be attached, currently only support OSS
path in OSS URI format and local path.
mount_path (str): The mount path in the container.
session (Session, optional): A PAI session instance used for communicating
with PAI service.
Returns:
Dict[str, Any]: The storage config.
Raises:
DuplicateMountException: If the mount path is already used or source OSS
path is mounted to the container.
Examples::
# Mount a OSS storage path to the running container.
>>> inference_spec.mount("oss://<YourOssBucket>/path/to/directory/model.json",
... "/ml/model/")
# 'Mount' a local path to the running container.
>>> inference_spec.mount("/path/to/your/data/", "/ml/model/")
"""
session = session or get_default_session()
# TODO: supports more storages, such as NAS, PAI Dataset, PAI CodeSource, etc.
if not isinstance(source, str):
raise ValueError(
"Parameter should be a string which represents an OSS storage path"
" or a local file path."
)
if "storage" in self._cfg_dict:
configs = self._cfg_dict.get("storage", [])
else:
configs = []
uris = set()
for conf in configs:
# check if target mount path is already used.
if conf.get("mount_path") == mount_path:
raise MountPathIsOccupiedException(
f"The mount path '{mount_path}' has already been used."
)
mount_uri = conf.get("oss", {}).get("path")
uris.add(mount_uri)
if is_oss_uri(source):
oss_uri_obj = OssUriObj(source)
storage_config = {
"mount_path": mount_path,
"oss": {"path": oss_uri_obj.get_dir_uri()},
}
elif os.path.exists(source):
# if source is a local path, upload it to OSS bucket and use OSS URI
# as storage source.
oss_path = session.get_storage_path_by_category("model_data")
oss_uri = upload(
source_path=source, oss_path=oss_path, bucket=session.oss_bucket
)
oss_uri_obj = OssUriObj(oss_uri)
storage_config = {
"mount_path": mount_path,
"oss": {"path": oss_uri_obj.get_dir_uri()},
}
else:
raise ValueError(
"Source path is not a valid OSS URI or a existing local path."
)
# check if the source OSS Path is already mounted to the container.
if oss_uri_obj.get_dir_uri() in uris:
raise DuplicatedMountException(
f"Source OSS path '{oss_uri_obj.get_dir_uri()}' is already "
f"mounted to the container."
)
configs.append(storage_config)
self.storage = configs
return storage_config
def container_serving_spec(
command: str,
image_uri: Union[str, ImageInfo],
source_dir: Optional[str] = None,
git_config: Optional[Dict[str, Any]] = None,
port: Optional[int] = None,
environment_variables: Optional[Dict[str, str]] = None,
requirements: Optional[List[str]] = None,
requirements_path: Optional[str] = None,
health_check: Optional[Dict[str, Any]] = None,
session: Optional[Session] = None,
) -> InferenceSpec:
"""A convenient function to create an InferenceSpec instance that serving the model
with given container and script.
Examples::
infer_spec: InferenceSpec = container_serving_spec(
command="python run.py",
source_dir="./model_server/",
image_uri="<ServingImageUri>",
)
m = Model(
model_data="oss://<YourOssBucket>/path/to/your/model",
inference_spec=infer_spec,
)
m.deploy(
instance_type="ecs.c6.xlarge"
)
Args:
command (str): The command used to launch the Model server.
source_dir (str): A relative path or an absolute path to the source code
directory used to load model and launch the HTTP server, it will be
uploaded to the OSS bucket and mounted to the container. If there is a
``requirements.txt`` file under the directory, it will be installed before
the prediction server started.
If 'git_config' is provided, 'source_dir' should be a relative location
to a directory in the Git repo. With the following GitHub repo directory
structure:
.. code::
|----- README.md
|----- src
|----- train.py
|----- test.py
if you need 'src' directory as the source code directory, you can assign
source_dir='./src/'.
git_config (Dict[str, str]): Git configuration used to clone the repo.
Including ``repo``, ``branch``, ``commit``, ``username``, ``password`` and
``token``. The ``repo`` is required. All other fields are optional. ``repo``
specifies the Git repository. If you don't provide ``branch``, the default
value 'master' is used. If you don't provide ``commit``, the latest commit
in the specified branch is used. ``username``, ``password`` and ``token``
are for authentication purpose. For example, the following config:
.. code:: python
git_config = {
'repo': 'https://github.com/modelscope/modelscope.git',
'branch': 'master',
'commit': '9bfc4a9d83c4beaf8378d0a186261ffc1cd9f960'
}
results in cloning the repo specified in 'repo', then checking out the
'master' branch, and checking out the specified commit.
image_uri (str): The Docker image used to run the prediction service.
port (int): Expose port of the server in container, the prediction request
will be forward to the port. The environment variable ``LISTENING_PORT``
in the container will be set to this value. Default to 8000.
environment_variables (Dict[str, str], optional): Dictionary of environment
variable key-value pairs to set on the running container.
requirements (List[str], optional): A list of Python package dependency, it
will be installed before the serving container run.
requirements_path (str, optional): A absolute path to the requirements.txt in
the container.
health_check (Dict[str, Any], optional): The health check configuration. If it
not set, A TCP readiness probe will be used to check the health of the
HTTP server.
session (Session, optional): A PAI session instance used for communicating
with PAI service.
Returns:
:class:`pai.model.InferenceSpec`: An InferenceSpec instance.
"""
session = session or get_default_session()
if git_config:
updated_args = git_utils.git_clone_repo(
git_config=git_config,
source_dir=source_dir,
)
source_dir = updated_args["source_dir"]
if not port:
port = DefaultServiceConfig.listen_port
elif int(port) in _RESERVED_PORTS:
raise ValueError(
"Reserved port {} is not allowed to use as serving port.".format(port),
)
if source_dir:
if not os.path.exists(source_dir):
raise ValueError("Source directory {} does not exist.".format(source_dir))
if not os.path.isdir(source_dir):
raise ValueError(
"Source directory {} is not a directory.".format(source_dir)
)
code_mount_path = DefaultServiceConfig.code_path
# build the command for serving container.
command = textwrap.dedent(
f"""\
# change working directory to code mount path.
cd {code_mount_path}
{command}
"""
)
if not requirements_path and os.path.exists(
os.path.join(source_dir, "requirements.txt")
):
requirements_path = posixpath.join(code_mount_path, "requirements.txt")
else:
code_mount_path = None
requirements_path = None
if isinstance(image_uri, ImageInfo):
image_uri = image_uri.image_uri
environment_variables = environment_variables or dict()
container_spec = {
"image": image_uri,
"port": port,
"script": command,
"env": [
{"name": key, "value": str(value)}
for key, value in environment_variables.items()
]
if environment_variables
else [],
}
if health_check:
container_spec["health_check"] = health_check
if requirements:
container_spec["prepare"] = {"pythonRequirements": requirements}
if requirements_path:
logger.warning(
"If the parameter 'requirements' is set, the requirements_path "
"parameter will be ignored."
)
elif requirements_path:
container_spec["prepare"] = {
"pythonRequirementsPath": requirements_path,
}
inference_spec = InferenceSpec(containers=[container_spec])
# mount the uploaded serving scripts to the serving container.
if source_dir:
inference_spec.mount(
source_dir,
code_mount_path,
session=session,
)
return inference_spec
class _BuiltinProcessor(object):
"""Helper class uses for getting the builtin processor"""
PMML = "pmml"
XGBoost = "xgboost"
SupportedFrameworkAcceleratorVersionConfig = {
"tensorflow": {
"cpu": [
"1.12",
"1.14",
"1.15",
"2.3",
],
"gpu": [
"1.12",
"1.14",
"1.15",
],
},
"pytorch": {
"cpu": [
"1.6",
],
"gpu": [
"1.6",
],
},
}
# Hard code default processor for specific model format.
ModelFormatDefaultProcessorMapping = {
ModelFormat.PMML: "pmml",
ModelFormat.SavedModel: "tensorflow_cpu_2.3",
ModelFormat.TorchScript: "pytorch_cpu_1.6",
ModelFormat.FrozenPb: "pytorch_cpu_1.6",
ModelFormat.CaffePrototxt: "caffe_cpu",
ModelFormat.ONNX: "onnx_cu100",
}
@classmethod
def get_default_by_model_format(cls, model_format: str) -> str:
"""Get the default processor for a specific model format."""
if model_format in cls.ModelFormatDefaultProcessorMapping:
return cls.ModelFormatDefaultProcessorMapping[model_format]
@classmethod
def from_framework_version(
cls, framework_name, framework_version, accelerator=None
):
accelerator = accelerator or "cpu"
versions = cls.SupportedFrameworkAcceleratorVersionConfig.get(
framework_name, dict()
).get(accelerator, [])
if framework_version in versions:
return "{}_{}_{}".format(framework_name, accelerator, framework_version)
else:
logger.warning(
"Could not find the processor for the framework_version({} {}), use the"
" latest processor".format(framework_name, framework_version)
)
return "{}_{}_{}".format(framework_name, accelerator, versions[-1])
class ModelBase(object):
"""A class represent ModelBase."""
def __init__(
self,
model_data: str,
inference_spec: Optional[InferenceSpec] = None,
session: Session = None,
):
self.model_data = model_data
self.inference_spec = inference_spec
self.session = session or get_default_session()
def download(self, target_dir: str):
"""Download the model data from OSS to local directory.
Args:
target_dir (str): The target directory to download the model data.
Returns:
str: Local directory path stores the model data.
"""
if not self.model_data:
raise ValueError("Could not find the model data for this model.")
if not is_oss_uri(self.model_data):
raise RuntimeError("Download method only support model data stored in OSS.")
self._download_model_data(target_dir)
return target_dir
def _download_model_data(self, target_dir):
if not self.model_data:
return
logger.info(f"Prepare model data to local directory: {target_dir}")
if self.model_data.startswith("oss://"):
oss_uri = OssUriObj(self.model_data)
oss_bucket = self.session.get_oss_bucket(oss_uri.bucket_name)
download(
oss_path=oss_uri.object_key,
local_path=target_dir,
bucket=oss_bucket,
un_tar=True,
)
else:
if not os.path.exists(self.model_data):
raise ValueError(f"Model data path does not exist: {self.model_data}")
os.makedirs(target_dir, exist_ok=True)
if os.path.isfile(self.model_data):
shutil.copy(
self.model_data,
os.path.join(target_dir, os.path.basename(self.model_data)),
)
else:
distutils.dir_util.copy_tree(self.model_data, target_dir)
def _upload_model_data(self):
"""Upload the model artifact to OSS bucket if self.model_data is a local
file path.
"""
if not self.model_data:
return
elif is_oss_uri(self.model_data):
return self.model_data
elif not os.path.exists(self.model_data):
raise RuntimeError(f"Model data path does not exist: {self.model_data}")
dest_oss_path = self.session.get_storage_path_by_category(category="model_data")
upload_model_data = upload(
source_path=self.model_data,
oss_path=dest_oss_path,
bucket=self.session.oss_bucket,
)
return upload_model_data
def list_model_files(self, uri_format: bool = False) -> Iterator[str]:
"""List model files under the model path.
Args:
uri_format (bool): If True, return the model file path in OSS URI format.
Returns:
Iterator[str]: Iterator of model files.
"""
if not self.model_data:
raise ValueError("Model data path is not specified.")
if not is_oss_uri(self.model_data):
raise ValueError("Method only support model data stored in OSS.")
oss_uri_obj = OssUriObj(self.model_data)
bucket = self.session.get_oss_bucket(
bucket_name=oss_uri_obj.bucket_name,
)
def _get_relative_path(obj_key: str):
# if the model_data is reference an object, return the object file
# name.
if oss_uri_obj.object_key == obj_key:
return os.path.basename(obj_key)
path = obj_key[len(oss_uri_obj.object_key) :]
return path.lstrip("/") if path.startswith("/") else path
obj_iter = ObjectIterator(bucket=bucket, prefix=oss_uri_obj.object_key)
for obj_info in obj_iter:
if uri_format:
yield f"oss://{bucket.bucket_name}/{obj_info.key}"
else:
yield _get_relative_path(obj_info.key)
def _get_inference_spec(self):
return self.inference_spec
def deploy(
self,
service_name: str,
instance_count: Optional[int] = 1,
instance_type: Optional[str] = None,
resource_config: Optional[Union[Dict[str, int], ResourceConfig]] = None,
resource_id: Optional[str] = None,
options: Optional[Dict[str, Any]] = None,
service_type: Optional[str] = None,
wait: bool = True,
serializer: Optional["SerializerBase"] = None,
**kwargs,
):
"""Deploy a prediction service with the model."""
if is_local_run_instance_type(instance_type):
return self._deploy_local(
instance_type=instance_type,
serializer=serializer,
wait=wait,
)
else:
return self._deploy(
service_name=service_name,
instance_count=instance_count,
instance_type=instance_type,
resource_config=resource_config,
resource_id=resource_id,
service_type=service_type,
options=options,
wait=wait,
serializer=serializer,
)
def _generate_service_name(self):
s = os.path.basename(self.model_data.rstrip("/")) + random_str(8)
return to_plain_text(s)
def _deploy(
self,
service_name: str = None,
instance_count: int = 1,
instance_type: str = None,
resource_config: Union[Dict[str, int], ResourceConfig] = None,
resource_id: str = None,
service_type: str = None,
options: Dict[str, Any] = None,
wait: bool = True,
serializer: "SerializerBase" = None,
):
"""Create a prediction service."""
if not service_name:
service_name = self._generate_service_name()
logger.info(
"Service name is not specified, using a generated service"
f" name to create the service: service_name={service_name}"
)
config = self._build_service_config(
service_name=service_name,
instance_count=instance_count,
instance_type=instance_type,
service_type=service_type,
resource_config=resource_config,
resource_id=resource_id,
options=options,
)
service_name = self.session.service_api.create(config=config)
self._wait_service_visible(service_name)
if service_type == ServiceType.Async:
predictor = AsyncPredictor(
service_name=service_name,
session=self.session,
serializer=serializer,
)
else:
predictor = Predictor(
service_name=service_name,
session=self.session,
serializer=serializer,
)
print(
"View the service detail by accessing the console URI: \n{}".format(
predictor.console_uri
)
)
if wait:
predictor.wait_for_ready()
return predictor
def _wait_service_visible(self, service_name, attempts=3, interval=2):
"""Wait for the service to be visible in DescribeService API.
hack:
https://aone.alibaba-inc.com/v2/project/1134421/bug#viewIdentifier=5dfb195e2e2b84f6b2f24718&openWorkitemIdentifier=50192431
"""
while attempts > 0:
obj = self.session.service_api.get(service_name)
if "ServiceUid" in obj:
return
attempts -= 1
time.sleep(interval)
logger.warning("DescribeService API failed to get the Service object.")
def _build_service_config(
self,
service_name: str = None,
instance_count: int = None,
instance_type: str = None,
resource_config: Union[ResourceConfig, Dict[str, Any]] = None,
resource_id: str = None,
service_type: str = None,
options: Dict[str, Any] = None,
) -> Dict[str, Any]:
"""Build a service config dictionary used to create a PAI EAS service."""
self.model_data = self._upload_model_data()
resource_config = (
ResourceConfig(**resource_config)
if resource_config and isinstance(resource_config, dict)
else None
)
if resource_config and instance_type:
raise ValueError(
f"Only one of 'instance_type' and 'resource_config' "
f"is required, but both have been provided: instance_type"
f"={instance_type}, resource_config="
f"{resource_config}."
)
inference_spec = InferenceSpec(
self._get_inference_spec().to_dict() if self.inference_spec else dict()
)
if self.model_data:
if not inference_spec.is_container_serving():
# if model_data is an OSS URI with endpoint, truncate the endpoint.
oss_uri_obj = OssUriObj(self.model_data)
model_path_uri = "oss://{bucket_name}/{key}".format(
bucket_name=oss_uri_obj.bucket_name,
key=oss_uri_obj.object_key,
)
inference_spec.add_option("model_path", model_path_uri)
else:
try:
inference_spec.mount(
self.model_data,
mount_path=DefaultServiceConfig.model_path,
)
except DuplicatedMountException as e:
# ignore duplicated mount
logger.info("Model is already mounted the container: %s", e)
if service_type:
inference_spec.add_option("metadata.type", service_type)
if inference_spec.is_container_serving():
inference_spec.add_option("metadata.rpc.proxy_path", "/")
if service_name:
inference_spec.add_option("name", service_name)
if instance_count:
inference_spec.add_option("metadata.instance", instance_count)
if instance_type:
inference_spec.add_option("cloud.computing.instance_type", instance_type)
elif resource_config:
inference_spec.add_option("metadata.cpu", resource_config.cpu)
inference_spec.add_option("metadata.memory", resource_config.memory)
if resource_config.gpu:
inference_spec.add_option("metadata.gpu", resource_config.gpu)
if resource_config.gpu_memory:
inference_spec.add_option(
"metadata.gpu_memory", resource_config.gpu_memory
)
if resource_config.gpu:
logger.warning(
"Parameters 'gpu' is set, the 'gpu_memory' parameter "
"does not take effect."
)
if resource_id:
inference_spec.add_option("metadata.resource", resource_id)
if options:
inference_spec.merge_options(options=options)
return inference_spec.to_dict()
def _deploy_local(
self,
instance_type: str,
serializer: SerializerBase = None,
wait: bool = True,
) -> LocalPredictor:
"""Deploy the model in local using docker."""
if not self.inference_spec.is_container_serving():
raise RuntimeError(
"Currently, only model using the InferenceSpec that serving with"
" container support local run."
)
if len(self.inference_spec.containers) > 1:
raise RuntimeError(
"InferenceSpec that serving with multiple container "
"does not support local run."
)
# prepare model data to local
work_dir = tempfile.mkdtemp()
model_dir = os.path.join(work_dir, "model")
self._download_model_data(target_dir=model_dir)
volumes = {
model_dir: {
"bind": DefaultServiceConfig.model_path,
"mode": "rw",
}
}
# prepare used storage to local directory.
if "storage" in self.inference_spec:
# only OSS storage config support local run.
if any(s for s in self.inference_spec.storage if "oss" not in s):
raise ValueError(
f"Local run only support InferenceSpec using OSS storage config: "
f"{self.inference_spec.to_dict()}"
)
for idx, storage in enumerate(self.inference_spec.storage):
store_dir = os.path.join(work_dir, f"storage_{idx}")
os.makedirs(store_dir, exist_ok=True)
oss_uri = OssUriObj(storage.oss.path)
download(
oss_path=oss_uri.object_key,
local_path=store_dir,
bucket=self.session.get_oss_bucket(oss_uri.bucket_name),
)
volumes[store_dir] = {"bind": storage.mount_path, "mode": "rw"}
container_spec = self.inference_spec.containers[0].to_dict()
env_vars = {
item["name"]: item["value"] for item in container_spec.get("env", [])
}
# build local launch script
requirements_list = container_spec.get("prepare", dict()).get(
"pythonRequirements", []
)
requirements_path = container_spec.get("prepare", dict()).get(
"pythonRequirementsPath", None
)
# build command to install requirements
if requirements_list:
install_requirements = " ".join(
[
shlex.quote(s)
for s in ["python", "-m", "pip", "install"] + requirements_list
]
)
elif requirements_path:
install_requirements = " ".join(
[
shlex.quote(s)
for s in ["python", "-m", "pip", "install", "-r", requirements_path]
]
)
else:
install_requirements = ""
user_scripts = container_spec.get("script", "")
launch_script = textwrap.dedent(
f"""\
set -e
{install_requirements}
{user_scripts}
"""
)
| gpu_count = -1 if instance_type == INSTANCE_TYPE_LOCAL_GPU else None | 1 | 2023-12-01 01:40:12+00:00 | 24k |
zerolink-io/zerolink-python | zerolink/req.py | [
{
"identifier": "settings",
"path": "zerolink/settings.py",
"snippet": " CONFIG_FILE = os.path.join(os.environ[\"APPDATA\"], \"zerolink\", \"config\")\n CONFIG_FILE = os.path.join(os.environ[\"HOME\"], \".config\", \"zerolink\", \"config\")\n CONFIG_FILE = os.path.join(\n os.environ[\"HO... | from typing import Any, Optional, cast
from zerolink import settings
from zerolink.exc import APIError, AuthenticationError
from zerolink_client import Client
from zerolink_client.api.default import finetune, get_models_models_get
from zerolink_client.api.entity import (
desc_entity_id,
desc_entity_ontology,
lookup_entity,
lookup_relation,
search_entity,
)
from zerolink_client.api.extract import extract_text
from zerolink_client.api.fact import (
create_userattribute,
create_userentity,
create_userrule,
create_usertriple,
)
from zerolink_client.api.kg import get_triple
from zerolink_client.api.question import post_question
from zerolink_client.api.session import (
create_session,
get_session_entities,
get_session_facts,
get_user_session,
)
from zerolink_client.api.user import create_user
from zerolink_client.models import (
ChatSession,
CreateAttribute,
CreateEntity,
CreateRule,
CreateRuleResponse,
CreateTriple,
CreateTuneJobResponse,
Entity,
HTTPValidationError,
Question,
QuestionResponse,
TextExtract,
)
from zerolink_client.types import File, UNSET | 16,972 |
def ask_question(
session_id: Optional[int],
body: str,
assumps: Optional[dict[str, Any]] = None,
**kwargs,
) -> QuestionResponse:
"""
Ask a question.
"""
check_api_key()
rep = post_question.sync_detailed(
client=client,
session_id=(session_id or UNSET),
body=Question(body=body, **(assumps or {})),
**kwargs,
)
if rep.status_code == 200:
return cast(QuestionResponse, rep.parsed)
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_entity_id(id: str, **kwargs) -> Entity:
"""
Get the description of an entity by eid.
"""
check_api_key()
rep = desc_entity_id.sync_detailed(
client=client,
id=id,
**kwargs,
)
if rep.status_code == 200:
return cast(Entity, rep.parsed)
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_desc_entity(name: str, **kwargs):
"""
Get the description of an entity by eid.
"""
check_api_key()
rep = lookup_entity.sync_detailed(
client=client,
name=name,
**kwargs,
)
if rep.status_code == 200:
return rep.parsed
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_search_entity(name: str, **kwargs):
"""
Search for an entity.
"""
check_api_key()
rep = search_entity.sync_detailed(
client=client,
name=name,
**kwargs,
)
if rep.status_code == 200:
return rep.parsed
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_search_relation(name: str, **kwargs):
"""
Search for a relation.
"""
check_api_key()
rep = lookup_relation.sync_detailed(
client=client,
name=name,
**kwargs,
)
if rep.status_code == 200:
return rep.parsed
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_ontology(name: str, **kwargs) -> dict[str, Any]:
"""
Get the ontology of an entity.
"""
check_api_key()
rep = desc_entity_ontology.sync_detailed(
client=client,
id=name,
**kwargs,
)
if rep.status_code == 200:
return cast(dict[str, Any], rep.parsed)
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_triples(name: str, **kwargs):
"""
Get the triples of a session.
"""
check_api_key()
|
# ------------------------------------------------------------------------
# Endpoints
# ------------------------------------------------------------------------
client = Client(
base_url=settings.server_url,
raise_on_unexpected_status=False,
)
def check_api_key() -> None:
"""
Check if the API key is set.
"""
if settings.api_key is None:
raise AuthenticationError()
else:
pass
def get_user_id() -> str:
"""
Get the user ID from the server. Only used for Demo server.
"""
client._headers["Authorization"] = settings.api_key
rep = create_user.sync(client=client)
if rep is None:
raise Exception("Failed to authenticate.")
settings.api_key = rep.user_id
if isinstance(rep, HTTPValidationError):
raise APIError(str(rep))
return rep.user_id
def post_session(user_id: str, **kwargs) -> Optional[ChatSession]:
"""
Create a new session.
"""
check_api_key()
if user_id is None:
user_id = settings.api_key
rep = create_session.sync(client=client, user_id=user_id, **kwargs)
if isinstance(rep, HTTPValidationError):
raise APIError(str(rep))
return rep
def get_session_name(user_id: str, session_name: str, **kwargs):
"""
Lookup a session by user and name.
"""
check_api_key()
rep = get_user_session.sync_detailed(user_id, session_name, client=client, **kwargs)
if rep.status_code == 200:
return rep.parsed
elif rep.status_code == 404:
return None
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_session_entities_list(session_id: int, **kwargs):
"""
Get the entities of a session.
"""
check_api_key()
rep = get_session_entities.sync_detailed(session_id, client=client, **kwargs)
if rep.status_code == 200:
return rep.parsed
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_session_facts_list(session_id: int, **kwargs):
"""
Get the facts of a session.
"""
check_api_key()
rep = get_session_facts.sync_detailed(session_id, client=client, **kwargs)
if rep.status_code == 200:
return rep.parsed
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def ask_question(
session_id: Optional[int],
body: str,
assumps: Optional[dict[str, Any]] = None,
**kwargs,
) -> QuestionResponse:
"""
Ask a question.
"""
check_api_key()
rep = post_question.sync_detailed(
client=client,
session_id=(session_id or UNSET),
body=Question(body=body, **(assumps or {})),
**kwargs,
)
if rep.status_code == 200:
return cast(QuestionResponse, rep.parsed)
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_entity_id(id: str, **kwargs) -> Entity:
"""
Get the description of an entity by eid.
"""
check_api_key()
rep = desc_entity_id.sync_detailed(
client=client,
id=id,
**kwargs,
)
if rep.status_code == 200:
return cast(Entity, rep.parsed)
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_desc_entity(name: str, **kwargs):
"""
Get the description of an entity by eid.
"""
check_api_key()
rep = lookup_entity.sync_detailed(
client=client,
name=name,
**kwargs,
)
if rep.status_code == 200:
return rep.parsed
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_search_entity(name: str, **kwargs):
"""
Search for an entity.
"""
check_api_key()
rep = search_entity.sync_detailed(
client=client,
name=name,
**kwargs,
)
if rep.status_code == 200:
return rep.parsed
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_search_relation(name: str, **kwargs):
"""
Search for a relation.
"""
check_api_key()
rep = lookup_relation.sync_detailed(
client=client,
name=name,
**kwargs,
)
if rep.status_code == 200:
return rep.parsed
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_ontology(name: str, **kwargs) -> dict[str, Any]:
"""
Get the ontology of an entity.
"""
check_api_key()
rep = desc_entity_ontology.sync_detailed(
client=client,
id=name,
**kwargs,
)
if rep.status_code == 200:
return cast(dict[str, Any], rep.parsed)
else:
err = rep.content.decode("utf-8")
print(err)
raise APIError(err)
def get_triples(name: str, **kwargs):
"""
Get the triples of a session.
"""
check_api_key() | rep = get_triple.sync_detailed( | 16 | 2023-12-03 07:50:04+00:00 | 24k |
JunMa11/UHNSeg-Quiz | nnunetv2/training/nnUNetTrainer/variants/network_architecture/nnUNetTrainerNoDeepSupervision.py | [
{
"identifier": "DC_and_BCE_loss",
"path": "nnunetv2/training/loss/compound_losses.py",
"snippet": "class DC_and_BCE_loss(nn.Module):\n def __init__(self, bce_kwargs, soft_dice_kwargs, weight_ce=1, weight_dice=1, use_ignore_label: bool = False,\n dice_class=MemoryEfficientSoftDiceLoss... | import torch
from torch import autocast
from nnunetv2.training.loss.compound_losses import DC_and_BCE_loss, DC_and_CE_loss
from nnunetv2.training.loss.dice import get_tp_fp_fn_tn, MemoryEfficientSoftDiceLoss
from nnunetv2.training.nnUNetTrainer.nnUNetTrainer import nnUNetTrainer
from nnunetv2.utilities.helpers import dummy_context
from nnunetv2.utilities.label_handling.label_handling import determine_num_input_channels
from torch.nn.parallel import DistributedDataParallel as DDP | 17,173 |
class nnUNetTrainerNoDeepSupervision(nnUNetTrainer):
def _build_loss(self):
if self.label_manager.has_regions:
loss = DC_and_BCE_loss({},
{'batch_dice': self.configuration_manager.batch_dice,
'do_bg': True, 'smooth': 1e-5, 'ddp': self.is_ddp},
use_ignore_label=self.label_manager.ignore_label is not None,
|
class nnUNetTrainerNoDeepSupervision(nnUNetTrainer):
def _build_loss(self):
if self.label_manager.has_regions:
loss = DC_and_BCE_loss({},
{'batch_dice': self.configuration_manager.batch_dice,
'do_bg': True, 'smooth': 1e-5, 'ddp': self.is_ddp},
use_ignore_label=self.label_manager.ignore_label is not None, | dice_class=MemoryEfficientSoftDiceLoss) | 3 | 2023-12-04 19:43:14+00:00 | 24k |
opisaac9001/TTS-With-ooba-and-voice | TTS/tts/models/tortoise.py | [
{
"identifier": "TorchMelSpectrogram",
"path": "TTS/tts/layers/tortoise/arch_utils.py",
"snippet": "class TorchMelSpectrogram(nn.Module):\n def __init__(\n self,\n filter_length=1024,\n hop_length=256,\n win_length=1024,\n n_mel_channels=80,\n mel_fmin=0,\n ... | import os
import random
import torch
import torch.nn.functional as F
import torchaudio
from contextlib import contextmanager
from dataclasses import dataclass
from time import time
from coqpit import Coqpit
from tqdm import tqdm
from TTS.tts.layers.tortoise.arch_utils import TorchMelSpectrogram
from TTS.tts.layers.tortoise.audio_utils import denormalize_tacotron_mel, load_voice, wav_to_univnet_mel
from TTS.tts.layers.tortoise.autoregressive import UnifiedVoice
from TTS.tts.layers.tortoise.classifier import AudioMiniEncoderWithClassifierHead
from TTS.tts.layers.tortoise.clvp import CLVP
from TTS.tts.layers.tortoise.diffusion import SpacedDiffusion, get_named_beta_schedule, space_timesteps
from TTS.tts.layers.tortoise.diffusion_decoder import DiffusionTts
from TTS.tts.layers.tortoise.random_latent_generator import RandomLatentConverter
from TTS.tts.layers.tortoise.tokenizer import VoiceBpeTokenizer
from TTS.tts.layers.tortoise.vocoder import VocConf, VocType
from TTS.tts.layers.tortoise.wav2vec_alignment import Wav2VecAlignment
from TTS.tts.models.base_tts import BaseTTS
from math import ceil | 19,806 | self.ar_checkpoint = self.args.ar_checkpoint
self.diff_checkpoint = self.args.diff_checkpoint # TODO: check if this is even needed
self.models_dir = config.model_dir
self.autoregressive_batch_size = (
pick_best_batch_size_for_gpu()
if self.args.autoregressive_batch_size is None
else self.args.autoregressive_batch_size
)
self.enable_redaction = self.args.enable_redaction
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if self.enable_redaction:
self.aligner = Wav2VecAlignment()
self.tokenizer = VoiceBpeTokenizer()
self.autoregressive = UnifiedVoice(
max_mel_tokens=self.args.ar_max_mel_tokens,
max_text_tokens=self.args.ar_max_text_tokens,
max_conditioning_inputs=self.args.ar_max_conditioning_inputs,
layers=self.args.ar_layers,
model_dim=self.args.ar_model_dim,
heads=self.args.ar_heads,
number_text_tokens=self.args.ar_number_text_tokens,
start_text_token=self.args.ar_start_text_token,
checkpointing=self.args.ar_checkpointing,
train_solo_embeddings=self.args.ar_train_solo_embeddings,
).cpu()
self.diffusion = DiffusionTts(
model_channels=self.args.diff_model_channels,
num_layers=self.args.diff_num_layers,
in_channels=self.args.diff_in_channels,
out_channels=self.args.diff_out_channels,
in_latent_channels=self.args.diff_in_latent_channels,
in_tokens=self.args.diff_in_tokens,
dropout=self.args.diff_dropout,
use_fp16=self.args.diff_use_fp16,
num_heads=self.args.diff_num_heads,
layer_drop=self.args.diff_layer_drop,
unconditioned_percentage=self.args.diff_unconditioned_percentage,
).cpu()
self.clvp = CLVP(
dim_text=self.args.clvp_dim_text,
dim_speech=self.args.clvp_dim_speech,
dim_latent=self.args.clvp_dim_latent,
num_text_tokens=self.args.clvp_num_text_tokens,
text_enc_depth=self.args.clvp_text_enc_depth,
text_seq_len=self.args.clvp_text_seq_len,
text_heads=self.args.clvp_text_heads,
num_speech_tokens=self.args.clvp_num_speech_tokens,
speech_enc_depth=self.args.clvp_speech_enc_depth,
speech_heads=self.args.clvp_speech_heads,
speech_seq_len=self.args.clvp_speech_seq_len,
use_xformers=self.args.clvp_use_xformers,
).cpu()
self.vocoder = self.args.vocoder.value.constructor().cpu()
# Random latent generators (RLGs) are loaded lazily.
self.rlg_auto = None
self.rlg_diffusion = None
if self.args.high_vram:
self.autoregressive = self.autoregressive.to(self.device)
self.diffusion = self.diffusion.to(self.device)
self.clvp = self.clvp.to(self.device)
self.vocoder = self.vocoder.to(self.device)
self.high_vram = self.args.high_vram
@contextmanager
def temporary_cuda(self, model):
if self.high_vram:
yield model
else:
m = model.to(self.device)
yield m
m = model.cpu()
def get_conditioning_latents(
self,
voice_samples,
return_mels=False,
latent_averaging_mode=0,
original_tortoise=False,
):
"""
Transforms one or more voice_samples into a tuple (autoregressive_conditioning_latent, diffusion_conditioning_latent).
These are expressive learned latents that encode aspects of the provided clips like voice, intonation, and acoustic
properties.
:param voice_samples: List of arbitrary reference clips, which should be *pairs* of torch tensors containing arbitrary kHz waveform data.
:param latent_averaging_mode: 0/1/2 for following modes:
0 - latents will be generated as in original tortoise, using ~4.27s from each voice sample, averaging latent across all samples
1 - latents will be generated using (almost) entire voice samples, averaged across all the ~4.27s chunks
2 - latents will be generated using (almost) entire voice samples, averaged per voice sample
"""
assert latent_averaging_mode in [
0,
1,
2,
], "latent_averaging mode has to be one of (0, 1, 2)"
with torch.no_grad():
voice_samples = [[v.to(self.device) for v in ls] for ls in voice_samples]
auto_conds = []
for ls in voice_samples:
auto_conds.append(format_conditioning(ls[0], device=self.device, mel_norm_file=self.mel_norm_path))
auto_conds = torch.stack(auto_conds, dim=1)
with self.temporary_cuda(self.autoregressive) as ar:
auto_latent = ar.get_conditioning(auto_conds)
diffusion_conds = []
DURS_CONST = self.args.duration_const
for ls in voice_samples:
# The diffuser operates at a sample rate of 24000 (except for the latent inputs)
sample = torchaudio.functional.resample(ls[0], 22050, 24000) if original_tortoise else ls[1]
if latent_averaging_mode == 0:
sample = pad_or_truncate(sample, DURS_CONST)
|
def pad_or_truncate(t, length):
"""
Utility function for forcing <t> to have the specified sequence length, whether by clipping it or padding it with 0s.
"""
tp = t[..., :length]
if t.shape[-1] == length:
tp = t
elif t.shape[-1] < length:
tp = F.pad(t, (0, length - t.shape[-1]))
return tp
def deterministic_state(seed=None):
"""
Sets the random seeds that tortoise uses to the current time() and returns that seed so results can be
reproduced.
"""
seed = int(time()) if seed is None else seed
torch.manual_seed(seed)
random.seed(seed)
# Can't currently set this because of CUBLAS. TODO: potentially enable it if necessary.
# torch.use_deterministic_algorithms(True)
return seed
def load_discrete_vocoder_diffuser(
trained_diffusion_steps=4000,
desired_diffusion_steps=200,
cond_free=True,
cond_free_k=1,
sampler="ddim",
):
"""
Helper function to load a GaussianDiffusion instance configured for use as a vocoder.
"""
return SpacedDiffusion(
use_timesteps=space_timesteps(trained_diffusion_steps, [desired_diffusion_steps]),
model_mean_type="epsilon",
model_var_type="learned_range",
loss_type="mse",
betas=get_named_beta_schedule("linear", trained_diffusion_steps),
conditioning_free=cond_free,
conditioning_free_k=cond_free_k,
sampler=sampler,
)
def format_conditioning(clip, cond_length=132300, device="cuda", **kwargs):
"""
Converts the given conditioning signal to a MEL spectrogram and clips it as expected by the models.
"""
gap = clip.shape[-1] - cond_length
if gap < 0:
clip = F.pad(clip, pad=(0, abs(gap)))
elif gap > 0:
rand_start = random.randint(0, gap)
clip = clip[:, rand_start : rand_start + cond_length]
mel_clip = TorchMelSpectrogram(**kwargs)(clip.unsqueeze(0)).squeeze(0)
return mel_clip.unsqueeze(0).to(device)
def fix_autoregressive_output(codes, stop_token, complain=True):
"""
This function performs some padding on coded audio that fixes a mismatch issue between what the diffusion model was
trained on and what the autoregressive code generator creates (which has no padding or end).
This is highly specific to the DVAE being used, so this particular coding will not necessarily work if used with
a different DVAE. This can be inferred by feeding a audio clip padded with lots of zeros on the end through the DVAE
and copying out the last few codes.
Failing to do this padding will produce speech with a harsh end that sounds like "BLAH" or similar.
"""
# Strip off the autoregressive stop token and add padding.
stop_token_indices = (codes == stop_token).nonzero()
if len(stop_token_indices) == 0:
if complain:
print(
"No stop tokens found in one of the generated voice clips. This typically means the spoken audio is "
"too long. In some cases, the output will still be good, though. Listen to it and if it is missing words, "
"try breaking up your input text."
)
return codes
codes[stop_token_indices] = 83
stm = stop_token_indices.min().item()
codes[stm:] = 83
if stm - 3 < codes.shape[0]:
codes[-3] = 45
codes[-2] = 45
codes[-1] = 248
return codes
def do_spectrogram_diffusion(
diffusion_model,
diffuser,
latents,
conditioning_latents,
temperature=1,
verbose=True,
):
"""
Uses the specified diffusion model to convert discrete codes into a spectrogram.
"""
with torch.no_grad():
output_seq_len = (
latents.shape[1] * 4 * 24000 // 22050
) # This diffusion model converts from 22kHz spectrogram codes to a 24kHz spectrogram signal.
output_shape = (latents.shape[0], 100, output_seq_len)
precomputed_embeddings = diffusion_model.timestep_independent(
latents, conditioning_latents, output_seq_len, False
)
noise = torch.randn(output_shape, device=latents.device) * temperature
mel = diffuser.sample_loop(
diffusion_model,
output_shape,
noise=noise,
model_kwargs={"precomputed_aligned_embeddings": precomputed_embeddings},
progress=verbose,
)
return denormalize_tacotron_mel(mel)[:, :, :output_seq_len]
def classify_audio_clip(clip, model_dir):
"""
Returns whether or not Tortoises' classifier thinks the given clip came from Tortoise.
:param clip: torch tensor containing audio waveform data (get it from load_audio)
:return: True if the clip was classified as coming from Tortoise and false if it was classified as real.
"""
classifier = AudioMiniEncoderWithClassifierHead(
2,
spec_dim=1,
embedding_dim=512,
depth=5,
downsample_factor=4,
resnet_blocks=2,
attn_blocks=4,
num_attn_heads=4,
base_channels=32,
dropout=0,
kernel_size=5,
distribute_zero_label=False,
)
classifier.load_state_dict(torch.load(os.path.join(model_dir, "classifier.pth"), map_location=torch.device("cpu")))
clip = clip.cpu().unsqueeze(0)
results = F.softmax(classifier(clip), dim=-1)
return results[0][0]
def pick_best_batch_size_for_gpu():
"""
Tries to pick a batch size that will fit in your GPU. These sizes aren't guaranteed to work, but they should give
you a good shot.
"""
if torch.cuda.is_available():
_, available = torch.cuda.mem_get_info()
availableGb = available / (1024**3)
batch_size = 1
if availableGb > 14:
batch_size = 16
elif availableGb > 10:
batch_size = 8
elif availableGb > 7:
batch_size = 4
return batch_size
@dataclass
class TortoiseAudioConfig(Coqpit):
sample_rate: int = 22050
diffusion_sample_rate: int = 24000
output_sample_rate: int = 24000
@dataclass
class TortoiseArgs(Coqpit):
"""A dataclass to represent Tortoise model arguments that define the model structure.
Args:
autoregressive_batch_size (int): The size of the auto-regressive batch.
enable_redaction (bool, optional): Whether to enable redaction. Defaults to True.
high_vram (bool, optional): Whether to use high VRAM. Defaults to False.
kv_cache (bool, optional): Whether to use the kv_cache. Defaults to True.
ar_checkpoint (str, optional): The checkpoint for the autoregressive model. Defaults to None.
clvp_checkpoint (str, optional): The checkpoint for the ConditionalLatentVariablePerseq model. Defaults to None.
diff_checkpoint (str, optional): The checkpoint for the DiffTTS model. Defaults to None.
num_chars (int, optional): The maximum number of characters to generate. Defaults to 255.
vocoder (VocType, optional): The vocoder to use for synthesis. Defaults to VocConf.Univnet.
For UnifiedVoice model:
ar_max_mel_tokens (int, optional): The maximum mel tokens for the autoregressive model. Defaults to 604.
ar_max_text_tokens (int, optional): The maximum text tokens for the autoregressive model. Defaults to 402.
ar_max_conditioning_inputs (int, optional): The maximum conditioning inputs for the autoregressive model. Defaults to 2.
ar_layers (int, optional): The number of layers for the autoregressive model. Defaults to 30.
ar_model_dim (int, optional): The model dimension for the autoregressive model. Defaults to 1024.
ar_heads (int, optional): The number of heads for the autoregressive model. Defaults to 16.
ar_number_text_tokens (int, optional): The number of text tokens for the autoregressive model. Defaults to 255.
ar_start_text_token (int, optional): The start text token for the autoregressive model. Defaults to 255.
ar_checkpointing (bool, optional): Whether to use checkpointing for the autoregressive model. Defaults to False.
ar_train_solo_embeddings (bool, optional): Whether to train embeddings for the autoregressive model. Defaults to False.
For DiffTTS model:
diff_model_channels (int, optional): The number of channels for the DiffTTS model. Defaults to 1024.
diff_num_layers (int, optional): The number of layers for the DiffTTS model. Defaults to 10.
diff_in_channels (int, optional): The input channels for the DiffTTS model. Defaults to 100.
diff_out_channels (int, optional): The output channels for the DiffTTS model. Defaults to 200.
diff_in_latent_channels (int, optional): The input latent channels for the DiffTTS model. Defaults to 1024.
diff_in_tokens (int, optional): The input tokens for the DiffTTS model. Defaults to 8193.
diff_dropout (int, optional): The dropout percentage for the DiffTTS model. Defaults to 0.
diff_use_fp16 (bool, optional): Whether to use fp16 for the DiffTTS model. Defaults to False.
diff_num_heads (int, optional): The number of heads for the DiffTTS model. Defaults to 16.
diff_layer_drop (int, optional): The layer dropout percentage for the DiffTTS model. Defaults to 0.
diff_unconditioned_percentage (int, optional): The percentage of unconditioned inputs for the DiffTTS model. Defaults to 0.
For ConditionalLatentVariablePerseq model:
clvp_dim_text (int): The dimension of the text input for the CLVP module. Defaults to 768.
clvp_dim_speech (int): The dimension of the speech input for the CLVP module. Defaults to 768.
clvp_dim_latent (int): The dimension of the latent representation for the CLVP module. Defaults to 768.
clvp_num_text_tokens (int): The number of text tokens used by the CLVP module. Defaults to 256.
clvp_text_enc_depth (int): The depth of the text encoder in the CLVP module. Defaults to 20.
clvp_text_seq_len (int): The maximum sequence length of the text input for the CLVP module. Defaults to 350.
clvp_text_heads (int): The number of attention heads used by the text encoder in the CLVP module. Defaults to 12.
clvp_num_speech_tokens (int): The number of speech tokens used by the CLVP module. Defaults to 8192.
clvp_speech_enc_depth (int): The depth of the speech encoder in the CLVP module. Defaults to 20.
clvp_speech_heads (int): The number of attention heads used by the speech encoder in the CLVP module. Defaults to 12.
clvp_speech_seq_len (int): The maximum sequence length of the speech input for the CLVP module. Defaults to 430.
clvp_use_xformers (bool): A flag indicating whether the model uses transformers in the CLVP module. Defaults to True.
duration_const (int): A constant value used in the model. Defaults to 102400.
"""
autoregressive_batch_size: int = 1
enable_redaction: bool = False
high_vram: bool = False
kv_cache: bool = True
ar_checkpoint: str = None
clvp_checkpoint: str = None
diff_checkpoint: str = None
num_chars: int = 255
vocoder: VocType = VocConf.Univnet
# UnifiedVoice params
ar_max_mel_tokens: int = 604
ar_max_text_tokens: int = 402
ar_max_conditioning_inputs: int = 2
ar_layers: int = 30
ar_model_dim: int = 1024
ar_heads: int = 16
ar_number_text_tokens: int = 255
ar_start_text_token: int = 255
ar_checkpointing: bool = False
ar_train_solo_embeddings: bool = False
# DiffTTS params
diff_model_channels: int = 1024
diff_num_layers: int = 10
diff_in_channels: int = 100
diff_out_channels: int = 200
diff_in_latent_channels: int = 1024
diff_in_tokens: int = 8193
diff_dropout: int = 0
diff_use_fp16: bool = False
diff_num_heads: int = 16
diff_layer_drop: int = 0
diff_unconditioned_percentage: int = 0
# clvp params
clvp_dim_text: int = 768
clvp_dim_speech: int = 768
clvp_dim_latent: int = 768
clvp_num_text_tokens: int = 256
clvp_text_enc_depth: int = 20
clvp_text_seq_len: int = 350
clvp_text_heads: int = 12
clvp_num_speech_tokens: int = 8192
clvp_speech_enc_depth: int = 20
clvp_speech_heads: int = 12
clvp_speech_seq_len: int = 430
clvp_use_xformers: bool = True
# constants
duration_const: int = 102400
class Tortoise(BaseTTS):
"""Tortoise model class.
Currently only supports inference.
Examples:
>>> from TTS.tts.configs.tortoise_config import TortoiseConfig
>>> from TTS.tts.models.tortoise import Tortoise
>>> config = TortoiseConfig()
>>> model = Tortoise.inif_from_config(config)
>>> model.load_checkpoint(config, checkpoint_dir="paths/to/models_dir/", eval=True)
"""
def __init__(self, config: Coqpit):
super().__init__(config, ap=None, tokenizer=None)
self.mel_norm_path = None
self.config = config
self.ar_checkpoint = self.args.ar_checkpoint
self.diff_checkpoint = self.args.diff_checkpoint # TODO: check if this is even needed
self.models_dir = config.model_dir
self.autoregressive_batch_size = (
pick_best_batch_size_for_gpu()
if self.args.autoregressive_batch_size is None
else self.args.autoregressive_batch_size
)
self.enable_redaction = self.args.enable_redaction
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if self.enable_redaction:
self.aligner = Wav2VecAlignment()
self.tokenizer = VoiceBpeTokenizer()
self.autoregressive = UnifiedVoice(
max_mel_tokens=self.args.ar_max_mel_tokens,
max_text_tokens=self.args.ar_max_text_tokens,
max_conditioning_inputs=self.args.ar_max_conditioning_inputs,
layers=self.args.ar_layers,
model_dim=self.args.ar_model_dim,
heads=self.args.ar_heads,
number_text_tokens=self.args.ar_number_text_tokens,
start_text_token=self.args.ar_start_text_token,
checkpointing=self.args.ar_checkpointing,
train_solo_embeddings=self.args.ar_train_solo_embeddings,
).cpu()
self.diffusion = DiffusionTts(
model_channels=self.args.diff_model_channels,
num_layers=self.args.diff_num_layers,
in_channels=self.args.diff_in_channels,
out_channels=self.args.diff_out_channels,
in_latent_channels=self.args.diff_in_latent_channels,
in_tokens=self.args.diff_in_tokens,
dropout=self.args.diff_dropout,
use_fp16=self.args.diff_use_fp16,
num_heads=self.args.diff_num_heads,
layer_drop=self.args.diff_layer_drop,
unconditioned_percentage=self.args.diff_unconditioned_percentage,
).cpu()
self.clvp = CLVP(
dim_text=self.args.clvp_dim_text,
dim_speech=self.args.clvp_dim_speech,
dim_latent=self.args.clvp_dim_latent,
num_text_tokens=self.args.clvp_num_text_tokens,
text_enc_depth=self.args.clvp_text_enc_depth,
text_seq_len=self.args.clvp_text_seq_len,
text_heads=self.args.clvp_text_heads,
num_speech_tokens=self.args.clvp_num_speech_tokens,
speech_enc_depth=self.args.clvp_speech_enc_depth,
speech_heads=self.args.clvp_speech_heads,
speech_seq_len=self.args.clvp_speech_seq_len,
use_xformers=self.args.clvp_use_xformers,
).cpu()
self.vocoder = self.args.vocoder.value.constructor().cpu()
# Random latent generators (RLGs) are loaded lazily.
self.rlg_auto = None
self.rlg_diffusion = None
if self.args.high_vram:
self.autoregressive = self.autoregressive.to(self.device)
self.diffusion = self.diffusion.to(self.device)
self.clvp = self.clvp.to(self.device)
self.vocoder = self.vocoder.to(self.device)
self.high_vram = self.args.high_vram
@contextmanager
def temporary_cuda(self, model):
if self.high_vram:
yield model
else:
m = model.to(self.device)
yield m
m = model.cpu()
def get_conditioning_latents(
self,
voice_samples,
return_mels=False,
latent_averaging_mode=0,
original_tortoise=False,
):
"""
Transforms one or more voice_samples into a tuple (autoregressive_conditioning_latent, diffusion_conditioning_latent).
These are expressive learned latents that encode aspects of the provided clips like voice, intonation, and acoustic
properties.
:param voice_samples: List of arbitrary reference clips, which should be *pairs* of torch tensors containing arbitrary kHz waveform data.
:param latent_averaging_mode: 0/1/2 for following modes:
0 - latents will be generated as in original tortoise, using ~4.27s from each voice sample, averaging latent across all samples
1 - latents will be generated using (almost) entire voice samples, averaged across all the ~4.27s chunks
2 - latents will be generated using (almost) entire voice samples, averaged per voice sample
"""
assert latent_averaging_mode in [
0,
1,
2,
], "latent_averaging mode has to be one of (0, 1, 2)"
with torch.no_grad():
voice_samples = [[v.to(self.device) for v in ls] for ls in voice_samples]
auto_conds = []
for ls in voice_samples:
auto_conds.append(format_conditioning(ls[0], device=self.device, mel_norm_file=self.mel_norm_path))
auto_conds = torch.stack(auto_conds, dim=1)
with self.temporary_cuda(self.autoregressive) as ar:
auto_latent = ar.get_conditioning(auto_conds)
diffusion_conds = []
DURS_CONST = self.args.duration_const
for ls in voice_samples:
# The diffuser operates at a sample rate of 24000 (except for the latent inputs)
sample = torchaudio.functional.resample(ls[0], 22050, 24000) if original_tortoise else ls[1]
if latent_averaging_mode == 0:
sample = pad_or_truncate(sample, DURS_CONST) | cond_mel = wav_to_univnet_mel( | 3 | 2023-11-29 08:15:06+00:00 | 24k |
magic-research/magic-animate | 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.controlnet import ControlNetModel
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 | 19,344 | generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
latents: Optional[torch.FloatTensor] = None,
output_type: Optional[str] = "tensor",
return_dict: bool = True,
callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
callback_steps: Optional[int] = 1,
controlnet_condition: list = None,
controlnet_conditioning_scale: float = 1.0,
context_frames: int = 16,
context_stride: int = 1,
context_overlap: int = 4,
context_batch_size: int = 1,
context_schedule: str = "uniform",
init_latents: Optional[torch.FloatTensor] = None,
num_actual_inference_steps: Optional[int] = None,
appearance_encoder = None,
reference_control_writer = None,
reference_control_reader = None,
source_image: str = None,
decoder_consistency = None,
**kwargs,
):
"""
New args:
- controlnet_condition : condition map (e.g., depth, canny, keypoints) for controlnet
- controlnet_conditioning_scale : conditioning scale for controlnet
- init_latents : initial latents to begin with (used along with invert())
- num_actual_inference_steps : number of actual inference steps (while total steps is num_inference_steps)
"""
controlnet = self.controlnet
# Default height and width to unet
height = height or self.unet.config.sample_size * self.vae_scale_factor
width = width or self.unet.config.sample_size * self.vae_scale_factor
# Check inputs. Raise error if not correct
self.check_inputs(prompt, height, width, callback_steps)
# Define call parameters
# batch_size = 1 if isinstance(prompt, str) else len(prompt)
batch_size = 1
if latents is not None:
batch_size = latents.shape[0]
if isinstance(prompt, list):
batch_size = len(prompt)
device = self._execution_device
# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
# corresponds to doing no classifier free guidance.
do_classifier_free_guidance = guidance_scale > 1.0
# Encode input prompt
prompt = prompt if isinstance(prompt, list) else [prompt] * batch_size
if negative_prompt is not None:
negative_prompt = negative_prompt if isinstance(negative_prompt, list) else [negative_prompt] * batch_size
text_embeddings = self._encode_prompt(
prompt, device, num_videos_per_prompt, do_classifier_free_guidance, negative_prompt
)
text_embeddings = torch.cat([text_embeddings] * context_batch_size)
reference_control_writer = ReferenceAttentionControl(appearance_encoder, do_classifier_free_guidance=True, mode='write', batch_size=context_batch_size)
reference_control_reader = ReferenceAttentionControl(self.unet, do_classifier_free_guidance=True, mode='read', batch_size=context_batch_size)
is_dist_initialized = kwargs.get("dist", False)
rank = kwargs.get("rank", 0)
world_size = kwargs.get("world_size", 1)
# Prepare video
assert num_videos_per_prompt == 1 # FIXME: verify if num_videos_per_prompt > 1 works
assert batch_size == 1 # FIXME: verify if batch_size > 1 works
control = self.prepare_condition(
condition=controlnet_condition,
device=device,
dtype=controlnet.dtype,
num_videos_per_prompt=num_videos_per_prompt,
do_classifier_free_guidance=do_classifier_free_guidance,
)
controlnet_uncond_images, controlnet_cond_images = control.chunk(2)
# Prepare timesteps
self.scheduler.set_timesteps(num_inference_steps, device=device)
timesteps = self.scheduler.timesteps
# Prepare latent variables
if init_latents is not None:
latents = rearrange(init_latents, "(b f) c h w -> b c f h w", f=video_length)
else:
num_channels_latents = self.unet.in_channels
latents = self.prepare_latents(
batch_size * num_videos_per_prompt,
num_channels_latents,
video_length,
height,
width,
text_embeddings.dtype,
device,
generator,
latents,
)
latents_dtype = latents.dtype
# Prepare extra step kwargs.
extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
# Prepare text embeddings for controlnet
controlnet_text_embeddings = text_embeddings.repeat_interleave(video_length, 0)
_, controlnet_text_embeddings_c = controlnet_text_embeddings.chunk(2)
controlnet_res_samples_cache_dict = {i:None for i in range(video_length)}
# For img2img setting
if num_actual_inference_steps is None:
num_actual_inference_steps = num_inference_steps
if isinstance(source_image, str):
ref_image_latents = self.images2latents(np.array(Image.open(source_image).resize((width, height)))[None, :], latents_dtype).cuda()
elif isinstance(source_image, np.ndarray):
ref_image_latents = self.images2latents(source_image[None, :], latents_dtype).cuda()
| # *************************************************************************
# 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,
controlnet: ControlNetModel,
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,
controlnet=controlnet,
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, condition, num_videos_per_prompt, device, dtype, do_classifier_free_guidance):
# prepare conditions for controlnet
condition = torch.from_numpy(condition.copy()).to(device=device, dtype=dtype) / 255.0
condition = torch.stack([condition for _ in range(num_videos_per_prompt)], dim=0)
condition = rearrange(condition, 'b f h w c -> (b f) c h w').clone()
if do_classifier_free_guidance:
condition = torch.cat([condition] * 2)
return 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)
new_latents[:,:,new_index,:,:] = v.to(latents.device)
new_index += 1
new_latents[:,:,new_index,:,:] = v1
new_index += 1
return new_latents
def select_controlnet_res_samples(self, controlnet_res_samples_cache_dict, context, do_classifier_free_guidance, b, f):
_down_block_res_samples = []
_mid_block_res_sample = []
for i in np.concatenate(np.array(context)):
_down_block_res_samples.append(controlnet_res_samples_cache_dict[i][0])
_mid_block_res_sample.append(controlnet_res_samples_cache_dict[i][1])
down_block_res_samples = [[] for _ in range(len(controlnet_res_samples_cache_dict[i][0]))]
for res_t in _down_block_res_samples:
for i, res in enumerate(res_t):
down_block_res_samples[i].append(res)
down_block_res_samples = [torch.cat(res) for res in down_block_res_samples]
mid_block_res_sample = torch.cat(_mid_block_res_sample)
# reshape controlnet output to match the unet3d inputs
b = b // 2 if do_classifier_free_guidance else b
_down_block_res_samples = []
for sample in down_block_res_samples:
sample = rearrange(sample, '(b f) c h w -> b c f h w', b=b, f=f)
if do_classifier_free_guidance:
sample = sample.repeat(2, 1, 1, 1, 1)
_down_block_res_samples.append(sample)
down_block_res_samples = _down_block_res_samples
mid_block_res_sample = rearrange(mid_block_res_sample, '(b f) c h w -> b c f h w', b=b, f=f)
if do_classifier_free_guidance:
mid_block_res_sample = mid_block_res_sample.repeat(2, 1, 1, 1, 1)
return down_block_res_samples, mid_block_res_sample
@torch.no_grad()
def __call__(
self,
prompt: Union[str, List[str]],
video_length: Optional[int],
height: Optional[int] = None,
width: Optional[int] = None,
num_inference_steps: int = 50,
guidance_scale: float = 7.5,
negative_prompt: Optional[Union[str, List[str]]] = None,
num_videos_per_prompt: Optional[int] = 1,
eta: float = 0.0,
generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
latents: Optional[torch.FloatTensor] = None,
output_type: Optional[str] = "tensor",
return_dict: bool = True,
callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
callback_steps: Optional[int] = 1,
controlnet_condition: list = None,
controlnet_conditioning_scale: float = 1.0,
context_frames: int = 16,
context_stride: int = 1,
context_overlap: int = 4,
context_batch_size: int = 1,
context_schedule: str = "uniform",
init_latents: Optional[torch.FloatTensor] = None,
num_actual_inference_steps: Optional[int] = None,
appearance_encoder = None,
reference_control_writer = None,
reference_control_reader = None,
source_image: str = None,
decoder_consistency = None,
**kwargs,
):
"""
New args:
- controlnet_condition : condition map (e.g., depth, canny, keypoints) for controlnet
- controlnet_conditioning_scale : conditioning scale for controlnet
- init_latents : initial latents to begin with (used along with invert())
- num_actual_inference_steps : number of actual inference steps (while total steps is num_inference_steps)
"""
controlnet = self.controlnet
# Default height and width to unet
height = height or self.unet.config.sample_size * self.vae_scale_factor
width = width or self.unet.config.sample_size * self.vae_scale_factor
# Check inputs. Raise error if not correct
self.check_inputs(prompt, height, width, callback_steps)
# Define call parameters
# batch_size = 1 if isinstance(prompt, str) else len(prompt)
batch_size = 1
if latents is not None:
batch_size = latents.shape[0]
if isinstance(prompt, list):
batch_size = len(prompt)
device = self._execution_device
# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
# corresponds to doing no classifier free guidance.
do_classifier_free_guidance = guidance_scale > 1.0
# Encode input prompt
prompt = prompt if isinstance(prompt, list) else [prompt] * batch_size
if negative_prompt is not None:
negative_prompt = negative_prompt if isinstance(negative_prompt, list) else [negative_prompt] * batch_size
text_embeddings = self._encode_prompt(
prompt, device, num_videos_per_prompt, do_classifier_free_guidance, negative_prompt
)
text_embeddings = torch.cat([text_embeddings] * context_batch_size)
reference_control_writer = ReferenceAttentionControl(appearance_encoder, do_classifier_free_guidance=True, mode='write', batch_size=context_batch_size)
reference_control_reader = ReferenceAttentionControl(self.unet, do_classifier_free_guidance=True, mode='read', batch_size=context_batch_size)
is_dist_initialized = kwargs.get("dist", False)
rank = kwargs.get("rank", 0)
world_size = kwargs.get("world_size", 1)
# Prepare video
assert num_videos_per_prompt == 1 # FIXME: verify if num_videos_per_prompt > 1 works
assert batch_size == 1 # FIXME: verify if batch_size > 1 works
control = self.prepare_condition(
condition=controlnet_condition,
device=device,
dtype=controlnet.dtype,
num_videos_per_prompt=num_videos_per_prompt,
do_classifier_free_guidance=do_classifier_free_guidance,
)
controlnet_uncond_images, controlnet_cond_images = control.chunk(2)
# Prepare timesteps
self.scheduler.set_timesteps(num_inference_steps, device=device)
timesteps = self.scheduler.timesteps
# Prepare latent variables
if init_latents is not None:
latents = rearrange(init_latents, "(b f) c h w -> b c f h w", f=video_length)
else:
num_channels_latents = self.unet.in_channels
latents = self.prepare_latents(
batch_size * num_videos_per_prompt,
num_channels_latents,
video_length,
height,
width,
text_embeddings.dtype,
device,
generator,
latents,
)
latents_dtype = latents.dtype
# Prepare extra step kwargs.
extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
# Prepare text embeddings for controlnet
controlnet_text_embeddings = text_embeddings.repeat_interleave(video_length, 0)
_, controlnet_text_embeddings_c = controlnet_text_embeddings.chunk(2)
controlnet_res_samples_cache_dict = {i:None for i in range(video_length)}
# For img2img setting
if num_actual_inference_steps is None:
num_actual_inference_steps = num_inference_steps
if isinstance(source_image, str):
ref_image_latents = self.images2latents(np.array(Image.open(source_image).resize((width, height)))[None, :], latents_dtype).cuda()
elif isinstance(source_image, np.ndarray):
ref_image_latents = self.images2latents(source_image[None, :], latents_dtype).cuda()
| context_scheduler = get_context_scheduler(context_schedule) | 3 | 2023-11-21 08:33:54+00:00 | 24k |
alexzhou907/DreamPropeller | threestudio/systems/base.py | [
{
"identifier": "Exporter",
"path": "threestudio/models/exporters/base.py",
"snippet": "class Exporter(BaseObject):\n @dataclass\n class Config(BaseObject.Config):\n save_video: bool = False\n\n cfg: Config\n\n def configure(\n self,\n geometry: BaseImplicitGeometry,\n ... | import os
import pytorch_lightning as pl
import torch.nn.functional as F
import threestudio
import torch
import numpy as np
import copy
from dataclasses import dataclass, field
from threestudio.models.exporters.base import Exporter, ExporterOutput
from threestudio.systems.utils import parse_optimizer, parse_scheduler
from threestudio.utils.base import (
Updateable,
update_end_if_possible,
update_if_possible,
)
from threestudio.utils.config import parse_structured
from threestudio.utils.misc import C, cleanup, get_device, load_module_weights
from threestudio.utils.saving import SaverMixin
from threestudio.utils.typing import *
from threestudio.models.geometry.implicit_sdf import ImplicitSDF
from threestudio.utils.config import load_config, parse_structured | 15,408 | # other.prompt_utils = self.prompt_utils
# if hasattr(self, "guidance"):
# other.guidance = self.guidance
# other.geometry = type(self.geometry)(self.cfg.geometry)
# other.background = type(self.background)(
# self.cfg.background
# )
with torch.no_grad():
for parameter_to, parameter_from in zip(other.geometry.parameters(), self.geometry.parameters()):
parameter_to.data = parameter_from.data.clone()
for parameter_to, parameter_from in zip(other.material.parameters(), self.material.parameters()):
parameter_to.data = parameter_from.data.clone()
for parameter_to, parameter_from in zip(other.background.parameters(), self.background.parameters()):
parameter_to.data = parameter_from.data.clone()
for parameter_to, parameter_from in zip(other.renderer.parameters(), self.renderer.parameters()):
parameter_to.data = parameter_from.data.clone()
if self.renderer.cfg.get('grid_prune', False):
other.renderer.estimator.occs = self.renderer.estimator.occs.clone()
other.renderer.estimator.binaries = self.renderer.estimator.binaries.clone()
# if isinstance(self.geometry, ImplicitSDF):
# other.geometry.finite_difference_normal_eps = self.geometry.finite_difference_normal_eps
return other.to(device, non_blocking=True)
def get_aux_params(self):
aux = {}
if self.renderer.cfg.get('grid_prune', False):
aux['occs'] = self.renderer.estimator.occs
# aux['binaries'] = self.renderer.estimator.binaries
return aux
def get_params(self,include_occs=True, include_binaries=False):
# myparams = {**dict(self.geometry.named_parameters()), **dict(self.material.named_parameters()) , **dict(self.background.named_parameters())}
# if hasattr(self.guidance, 'unet_lora'):
# myparams.update(dict(self.guidance.unet_lora.named_parameters()))
myparams = list(self.geometry.parameters())+list(self.material.parameters())+list(self.background.parameters())+list(self.renderer.parameters())
if self.renderer.cfg.get('grid_prune', False) and include_occs:
myparams += [self.renderer.estimator.occs]#, self.renderer.estimator.binaries]
if self.renderer.cfg.get('grid_prune', False) and include_binaries:
myparams += [self.renderer.estimator.binaries]#, self.renderer.estimator.binaries]
return myparams
def set_renderer_binaries(self):
if self.renderer.cfg.get('grid_prune', False):
thre = torch.clamp(self.renderer.estimator.occs[self.renderer.estimator.occs >= 0].mean(), max=0.01)
self.renderer.estimator.binaries = (self.renderer.estimator.occs > thre).view(self.renderer.estimator.binaries.shape)
def set_aux_params(self, aux):
if self.renderer.cfg.get('grid_prune', False):
self.renderer.estimator.occs = aux['occs'].to(self.renderer.estimator.occs.device, non_blocking=True)
# self.renderer.estimator.binaries = aux['binaries'].to(self.renderer.estimator.binaries.device, non_blocking=True)
def set_params(self, params, clone=True):
myparams = self.get_params(include_occs=True, include_binaries=True)
# if isinstance(self.geometry, ImplicitSDF):
# self.geometry.finite_difference_normal_eps = aux['finite_difference_normal_eps']
for p, q in zip(myparams, params):
if clone:
p.data = q.data.clone().to(p.device, non_blocking=True)
else:
p.data = q.to(p.device, non_blocking=True)
# for p, q in zip(myparams[-2:], params[-2:]):
# p.data = q.data.clone().to(p.device, non_blocking=True)
# self.set_renderer_binaries()
def set_grads_from_grads(self, grads):
# myparams = {**dict(self.geometry.named_parameters()), **dict(self.material.named_parameters()) , **dict(self.background.named_parameters())}
# if hasattr(self.guidance, 'unet_lora'):
# myparams.update(dict(self.guidance.unet_lora.named_parameters()))
myparams = self.get_params(include_occs=False)
# assert len(myparams) == len(grads)
for p, grad in zip(myparams, grads):
if grad is not None:
p.grad = grad.to(p.device, non_blocking=True)
def compute_error_from_system(self, other):
myparams = self.get_params(include_occs=False)
otherparams = other.get_params(include_occs=False)
with torch.no_grad():
error = 0.0
total_num = 0
for p, q in zip(myparams, otherparams):
error += torch.linalg.norm(p-q).pow(2).item()
total_num += np.prod(list(q.shape))
return error / total_num * 1e6
def on_fit_start(self) -> None:
if self._save_dir is not None:
threestudio.info(f"Validation results will be saved to {self._save_dir}")
else:
threestudio.warn(
f"Saving directory not set for the system, visualization results will not be saved"
)
def on_test_end(self) -> None:
if self._save_dir is not None:
threestudio.info(f"Test results saved to {self._save_dir}")
def on_predict_start(self) -> None:
self.exporter: Exporter = threestudio.find(self.cfg.exporter_type)(
self.cfg.exporter,
geometry=self.geometry,
material=self.material,
background=self.background,
)
def predict_step(self, batch, batch_idx):
if self.exporter.cfg.save_video:
self.test_step(batch, batch_idx)
def on_predict_epoch_end(self) -> None:
if self.exporter.cfg.save_video:
self.on_test_epoch_end()
|
class BaseSystem(pl.LightningModule, Updateable, SaverMixin):
@dataclass
class Config:
loggers: dict = field(default_factory=dict)
loss: dict = field(default_factory=dict)
optimizer: dict = field(default_factory=dict)
scheduler: Optional[dict] = None
weights: Optional[str] = None
weights_ignore_modules: Optional[List[str]] = None
cleanup_after_validation_step: bool = False
cleanup_after_test_step: bool = False
cfg: Config
def __init__(self, cfg, device=get_device(), resumed=False, configure=True) -> None:
super().__init__()
self.cfg = parse_structured(self.Config, cfg)
self._save_dir: Optional[str] = None
self._resumed: bool = resumed
self._resumed_eval: bool = False
self._resumed_eval_status: dict = {"global_step": 0, "current_epoch": 0}
if "loggers" in cfg:
self.create_loggers(cfg.loggers)
if configure:
self.base_configure(device)
def base_configure(self, device):
self.configure(device)
if self.cfg.weights is not None:
self.load_weights(self.cfg.weights, self.cfg.weights_ignore_modules)
self.post_configure()
def load_weights(self, weights: str, ignore_modules: Optional[List[str]] = None):
state_dict, epoch, global_step = load_module_weights(
weights, ignore_modules=ignore_modules, map_location="cpu"
)
self.load_state_dict(state_dict, strict=False)
# restore step-dependent states
self.do_update_step(epoch, global_step, on_load_weights=True)
def set_resume_status(self, current_epoch: int, global_step: int):
# restore correct epoch and global step in eval
self._resumed_eval = True
self._resumed_eval_status["current_epoch"] = current_epoch
self._resumed_eval_status["global_step"] = global_step
@property
def resumed(self):
# whether from resumed checkpoint
return self._resumed
@property
def true_global_step(self):
if self._resumed_eval:
return self._resumed_eval_status["global_step"]
else:
return self.global_step
@property
def true_current_epoch(self):
if self._resumed_eval:
return self._resumed_eval_status["current_epoch"]
else:
return self.current_epoch
def configure(self) -> None:
pass
def post_configure(self) -> None:
"""
executed after weights are loaded
"""
pass
def C(self, value: Any) -> float:
return C(value, self.true_current_epoch, self.true_global_step)
def configure_optimizers(self):
optim = parse_optimizer(self.cfg.optimizer, self)
ret = {
"optimizer": optim,
}
if self.cfg.scheduler is not None:
ret.update(
{
"lr_scheduler": parse_scheduler(self.cfg.scheduler, optim),
}
)
return ret
def training_step(self, batch, batch_idx):
raise NotImplementedError
def validation_step(self, batch, batch_idx):
raise NotImplementedError
def on_train_batch_end(self, outputs, batch, batch_idx):
self.dataset = self.trainer.train_dataloader.dataset
update_end_if_possible(
self.dataset, self.true_current_epoch, self.true_global_step
)
self.do_update_step_end(self.true_current_epoch, self.true_global_step)
def on_validation_batch_end(self, outputs, batch, batch_idx):
self.dataset = self.trainer.val_dataloaders.dataset
update_end_if_possible(
self.dataset, self.true_current_epoch, self.true_global_step
)
self.do_update_step_end(self.true_current_epoch, self.true_global_step)
if self.cfg.cleanup_after_validation_step:
# cleanup to save vram
cleanup()
def on_validation_epoch_end(self):
raise NotImplementedError
def test_step(self, batch, batch_idx):
raise NotImplementedError
def on_test_batch_end(self, outputs, batch, batch_idx):
self.dataset = self.trainer.test_dataloaders.dataset
update_end_if_possible(
self.dataset, self.true_current_epoch, self.true_global_step
)
self.do_update_step_end(self.true_current_epoch, self.true_global_step)
if self.cfg.cleanup_after_test_step:
# cleanup to save vram
cleanup()
def on_test_epoch_end(self):
pass
def predict_step(self, batch, batch_idx):
raise NotImplementedError
def on_predict_batch_end(self, outputs, batch, batch_idx):
self.dataset = self.trainer.predict_dataloaders.dataset
update_end_if_possible(
self.dataset, self.true_current_epoch, self.true_global_step
)
self.do_update_step_end(self.true_current_epoch, self.true_global_step)
if self.cfg.cleanup_after_test_step:
# cleanup to save vram
cleanup()
def on_predict_epoch_end(self):
pass
def preprocess_data(self, batch, stage):
pass
"""
Implementing on_after_batch_transfer of DataModule does the same.
But on_after_batch_transfer does not support DP.
"""
def on_train_batch_start(self, batch, batch_idx, unused=0):
self.preprocess_data(batch, "train")
self.dataset = self.trainer.train_dataloader.dataset
update_if_possible(self.dataset, self.true_current_epoch, self.true_global_step)
self.do_update_step(self.true_current_epoch, self.true_global_step)
def on_validation_batch_start(self, batch, batch_idx, dataloader_idx=0):
self.preprocess_data(batch, "validation")
self.dataset = self.trainer.val_dataloaders.dataset
update_if_possible(self.dataset, self.true_current_epoch, self.true_global_step)
self.do_update_step(self.true_current_epoch, self.true_global_step)
def on_test_batch_start(self, batch, batch_idx, dataloader_idx=0):
self.preprocess_data(batch, "test")
self.dataset = self.trainer.test_dataloaders.dataset
update_if_possible(self.dataset, self.true_current_epoch, self.true_global_step)
self.do_update_step(self.true_current_epoch, self.true_global_step)
def on_predict_batch_start(self, batch, batch_idx, dataloader_idx=0):
self.preprocess_data(batch, "predict")
self.dataset = self.trainer.predict_dataloaders.dataset
update_if_possible(self.dataset, self.true_current_epoch, self.true_global_step)
self.do_update_step(self.true_current_epoch, self.true_global_step)
def update_step(self, epoch: int, global_step: int, on_load_weights: bool = False):
pass
def on_before_optimizer_step(self, optimizer):
"""
# some gradient-related debugging goes here, example:
from lightning.pytorch.utilities import grad_norm
norms = grad_norm(self.geometry, norm_type=2)
print(norms)
"""
pass
class BaseLift3DSystem(BaseSystem):
@dataclass
class Config(BaseSystem.Config):
geometry_type: str = ""
geometry: dict = field(default_factory=dict)
geometry_convert_from: Optional[str] = None
geometry_convert_inherit_texture: bool = False
# used to override configurations of the previous geometry being converted from,
# for example isosurface_threshold
geometry_convert_override: dict = field(default_factory=dict)
material_type: str = ""
material: dict = field(default_factory=dict)
background_type: str = ""
background: dict = field(default_factory=dict)
renderer_type: str = ""
renderer: dict = field(default_factory=dict)
guidance_type: str = ""
guidance: dict = field(default_factory=dict)
prompt_processor_type: str = ""
prompt_processor: dict = field(default_factory=dict)
# geometry export configurations, no need to specify in training
exporter_type: str = "mesh-exporter"
exporter: dict = field(default_factory=dict)
cfg: Config
def configure(self, device) -> None:
if (
self.cfg.geometry_convert_from # from_coarse must be specified
and not self.cfg.weights # not initialized from coarse when weights are specified
and not self.resumed # not initialized from coarse when resumed from checkpoints
):
threestudio.info("Initializing geometry from a given checkpoint ...")
prev_cfg = load_config(
os.path.join(
os.path.dirname(self.cfg.geometry_convert_from),
"../configs/parsed.yaml",
)
) # TODO: hard-coded relative path
prev_system_cfg: BaseLift3DSystem.Config = parse_structured(
self.Config, prev_cfg.system
)
prev_geometry_cfg = prev_system_cfg.geometry
prev_geometry_cfg.update(self.cfg.geometry_convert_override)
prev_geometry = threestudio.find(prev_system_cfg.geometry_type)(
prev_geometry_cfg, device=device
)
state_dict, epoch, global_step = load_module_weights(
self.cfg.geometry_convert_from,
module_name="geometry",
map_location="cpu",
)
prev_geometry.load_state_dict(state_dict, strict=False)
# restore step-dependent states
prev_geometry.do_update_step(epoch, global_step, on_load_weights=True)
# convert from coarse stage geometry
prev_geometry = prev_geometry.to(device)
self.geometry = threestudio.find(self.cfg.geometry_type).create_from(
prev_geometry,
self.cfg.geometry,
copy_net=self.cfg.geometry_convert_inherit_texture,
)
del prev_geometry
cleanup()
else:
self.geometry = threestudio.find(self.cfg.geometry_type)(self.cfg.geometry, device=device)
self.material = threestudio.find(self.cfg.material_type)(self.cfg.material, device=device)
self.background = threestudio.find(self.cfg.background_type)(
self.cfg.background, device=device
)
self.renderer = threestudio.find(self.cfg.renderer_type)(
self.cfg.renderer,
geometry=self.geometry,
material=self.material,
background=self.background,
device=device
)
# def get_optimizer(self):
# getattr(torch.optim, self.cfg.optimizer.name)(params, ** self.cfg.optimizer.args)
def clone(self, device, other=None):
if other is None:
# make sure to clone after on_fit_start
other = type(self)(self.cfg, device=device, configure=False)
other.geometry = copy.deepcopy(self.geometry)
other.material = copy.deepcopy(self.material)
other.background = copy.deepcopy(self.background)
other.renderer = threestudio.find(self.cfg.renderer_type)(
self.cfg.renderer,
geometry=other.geometry,
material=other.material,
background=other.background,
device=device
)
# if hasattr(self, "prompt_processor"):
# other.prompt_processor = self.prompt_processor
# if hasattr(self, "prompt_utils"):
# other.prompt_utils = self.prompt_utils
# if hasattr(self, "guidance"):
# other.guidance = self.guidance
# other.geometry = type(self.geometry)(self.cfg.geometry)
# other.background = type(self.background)(
# self.cfg.background
# )
with torch.no_grad():
for parameter_to, parameter_from in zip(other.geometry.parameters(), self.geometry.parameters()):
parameter_to.data = parameter_from.data.clone()
for parameter_to, parameter_from in zip(other.material.parameters(), self.material.parameters()):
parameter_to.data = parameter_from.data.clone()
for parameter_to, parameter_from in zip(other.background.parameters(), self.background.parameters()):
parameter_to.data = parameter_from.data.clone()
for parameter_to, parameter_from in zip(other.renderer.parameters(), self.renderer.parameters()):
parameter_to.data = parameter_from.data.clone()
if self.renderer.cfg.get('grid_prune', False):
other.renderer.estimator.occs = self.renderer.estimator.occs.clone()
other.renderer.estimator.binaries = self.renderer.estimator.binaries.clone()
# if isinstance(self.geometry, ImplicitSDF):
# other.geometry.finite_difference_normal_eps = self.geometry.finite_difference_normal_eps
return other.to(device, non_blocking=True)
def get_aux_params(self):
aux = {}
if self.renderer.cfg.get('grid_prune', False):
aux['occs'] = self.renderer.estimator.occs
# aux['binaries'] = self.renderer.estimator.binaries
return aux
def get_params(self,include_occs=True, include_binaries=False):
# myparams = {**dict(self.geometry.named_parameters()), **dict(self.material.named_parameters()) , **dict(self.background.named_parameters())}
# if hasattr(self.guidance, 'unet_lora'):
# myparams.update(dict(self.guidance.unet_lora.named_parameters()))
myparams = list(self.geometry.parameters())+list(self.material.parameters())+list(self.background.parameters())+list(self.renderer.parameters())
if self.renderer.cfg.get('grid_prune', False) and include_occs:
myparams += [self.renderer.estimator.occs]#, self.renderer.estimator.binaries]
if self.renderer.cfg.get('grid_prune', False) and include_binaries:
myparams += [self.renderer.estimator.binaries]#, self.renderer.estimator.binaries]
return myparams
def set_renderer_binaries(self):
if self.renderer.cfg.get('grid_prune', False):
thre = torch.clamp(self.renderer.estimator.occs[self.renderer.estimator.occs >= 0].mean(), max=0.01)
self.renderer.estimator.binaries = (self.renderer.estimator.occs > thre).view(self.renderer.estimator.binaries.shape)
def set_aux_params(self, aux):
if self.renderer.cfg.get('grid_prune', False):
self.renderer.estimator.occs = aux['occs'].to(self.renderer.estimator.occs.device, non_blocking=True)
# self.renderer.estimator.binaries = aux['binaries'].to(self.renderer.estimator.binaries.device, non_blocking=True)
def set_params(self, params, clone=True):
myparams = self.get_params(include_occs=True, include_binaries=True)
# if isinstance(self.geometry, ImplicitSDF):
# self.geometry.finite_difference_normal_eps = aux['finite_difference_normal_eps']
for p, q in zip(myparams, params):
if clone:
p.data = q.data.clone().to(p.device, non_blocking=True)
else:
p.data = q.to(p.device, non_blocking=True)
# for p, q in zip(myparams[-2:], params[-2:]):
# p.data = q.data.clone().to(p.device, non_blocking=True)
# self.set_renderer_binaries()
def set_grads_from_grads(self, grads):
# myparams = {**dict(self.geometry.named_parameters()), **dict(self.material.named_parameters()) , **dict(self.background.named_parameters())}
# if hasattr(self.guidance, 'unet_lora'):
# myparams.update(dict(self.guidance.unet_lora.named_parameters()))
myparams = self.get_params(include_occs=False)
# assert len(myparams) == len(grads)
for p, grad in zip(myparams, grads):
if grad is not None:
p.grad = grad.to(p.device, non_blocking=True)
def compute_error_from_system(self, other):
myparams = self.get_params(include_occs=False)
otherparams = other.get_params(include_occs=False)
with torch.no_grad():
error = 0.0
total_num = 0
for p, q in zip(myparams, otherparams):
error += torch.linalg.norm(p-q).pow(2).item()
total_num += np.prod(list(q.shape))
return error / total_num * 1e6
def on_fit_start(self) -> None:
if self._save_dir is not None:
threestudio.info(f"Validation results will be saved to {self._save_dir}")
else:
threestudio.warn(
f"Saving directory not set for the system, visualization results will not be saved"
)
def on_test_end(self) -> None:
if self._save_dir is not None:
threestudio.info(f"Test results saved to {self._save_dir}")
def on_predict_start(self) -> None:
self.exporter: Exporter = threestudio.find(self.cfg.exporter_type)(
self.cfg.exporter,
geometry=self.geometry,
material=self.material,
background=self.background,
)
def predict_step(self, batch, batch_idx):
if self.exporter.cfg.save_video:
self.test_step(batch, batch_idx)
def on_predict_epoch_end(self) -> None:
if self.exporter.cfg.save_video:
self.on_test_epoch_end() | exporter_output: List[ExporterOutput] = self.exporter() | 1 | 2023-11-27 23:39:49+00:00 | 24k |
abdulhaim/LMRL-Gym | llm_rl_scripts/maze/ppo/train_ppo_online.py | [
{
"identifier": "build_ppo_score_fn",
"path": "LLM_RL/algorithms/ppo/score_fn.py",
"snippet": "def build_ppo_score_fn(\n inference: PPOInference, \n tokenizer: PreTrainedTokenizer, \n max_length: int, \n bsize: int, \n):\n \n def score_fn(text_histories: List[TextHistory]) -> List[floa... | from typing import Optional, Dict, Any, Tuple
from JaxSeq.bucket_manager import open_with_bucket as open
from transformers import AutoTokenizer
from JaxSeq.utils import convert_path, load_mesh, get_dtype, setup_experiment_save
from JaxSeq.utils import BlockingStrategy, Padding, Truncation, get_weight_decay_mask, create_path, get_enabled_save_path
from JaxSeq.models.gpt2.interface import GPT2Inference
from JaxSeq.models.gpt2.load import load_train_state, ModelLoadMode
from LLM_RL.algorithms.ppo.score_fn import build_ppo_score_fn
from LLM_RL.algorithms.ppo.train import train_loop
from LLM_RL.algorithms.ppo.base_interface import ppo_loss_fn, FixedKLController, AdaptiveKLController
from transformers.generation import GenerationConfig
from jaxtyping import PyTree
from LLM_RL.environment import Text, TokenHistory, text_env_eval, TextTrajectory, TextTrajectoryChain
from LLM_RL.algorithms.ppo.gpt2.interface import GPT2PPOPolicy, GPT2PPOInference, GPT2PPOTrain
from LLM_RL.heads.linear_head import load_train_state_from_config as load_head_train_state_from_config
from LLM_RL.heads.linear_head import LinearHeadConfig
from JaxSeq.shard_model import shard_params_from_params
from LLM_RL.algorithms.ppo.data import PPODataset
from LLM_RL.utils import get_tensor_stats_np
from functools import partial
from JaxSeq.logs import label_logs, log, pull_logs
from JaxSeq.utils import multihost_device_get
from IPython import embed
from llm_rl_scripts.maze.env.mazes import double_t_maze_optimal_directions, double_t_maze
from JaxSeq.data import MaskDataset
from JaxSeq.models.gpt2.interface import loss_fn_mask
from llm_rl_scripts.maze.env.env import MazeEnv, describe_observation_give_position, maze_proposal_function
from LLM_RL.algorithms.ppo.reranker_policy import ReRankerPolicy
from JaxSeq.utils import block_sequences
from llm_rl_scripts.maze.env.maze_utils import setup_maze_env, pick_start_position
import tyro
import jax
import jax.numpy as jnp
import os
import optax
import pickle as pkl
import re
import numpy as np
import json | 18,936 |
# in_tokens = list(map(lambda x: block_sequences([x.tokens], tokenizer.pad_token_id, dtype=np.int32, blocking_strategy=BlockingStrategy(Padding.RIGHT, Truncation.RIGHT, max_input_length))[0], text_histories))
# text_histories = list(map(lambda x: x.text_history, text_trajectories))
# no this doesn't work because we also need to pad the is_actions
token_histories = list(map(lambda x: TokenHistory.from_text_history(x, tokenizer), text_histories))
in_tokens = list(map(lambda x: block_sequences([x.tokens], tokenizer.pad_token_id, dtype=np.int32, blocking_strategy=blocking_strategy)[0], token_histories))
is_actions = list(map(lambda x: block_sequences([x.is_action], 0.0, dtype=np.float32, blocking_strategy=blocking_strategy)[0], token_histories))
# tokens = list(map(lambda x: token_process(x.tokens), token_histories))
# is_actions = list(map(lambda x: x.is_action, token_histories))
bc_data = MaskDataset(
in_tokens = jnp.array(in_tokens),
in_training_mask = jnp.array(is_actions),
)
else:
bc_data = None
mesh = load_mesh((data_mesh_shape, fsdp_mesh_shape, model_mesh_shape), ('dp', 'fsdp', 'mp'))
is_main_process = jax.process_index() == 0
print(f"Mesh: {mesh}")
print(f"Is main process: {is_main_process}")
def policy_optim_getter(params: PyTree):
mask = get_weight_decay_mask((
"".join([r"\['ln_[0-9]+'\]", re.escape("['bias']")]),
"".join([r"\['ln_[0-9]+'\]", re.escape("['scale']")]),
re.escape("['ln_f']['bias']"),
re.escape("['ln_f']['scale']"),
"bias",
))(params)
return optax.MultiSteps(
optax.adamw(
learning_rate=lr,
b1=0.9,
b2=0.95,
eps=1e-8,
weight_decay=weight_decay,
mask=mask,
),
every_k_schedule=grad_accum_steps,
)
model_dtype = get_dtype(use_fp16=use_fp16_activations)
params_dtype = get_dtype(use_fp16=use_fp16_params)
model_prng_key = jax.random.PRNGKey(2)
policy_train_state, policy_model = load_train_state(
model_load_mode=model_load_mode,
model_load_path=convert_path(model_load_path) if model_load_mode != ModelLoadMode.HF else model_load_path,
model_dtype=model_dtype,
optim_getter=policy_optim_getter,
tokenizer=tokenizer,
mesh=mesh,
prng_key=model_prng_key,
force_pad_embeddings=force_pad_embeddings,
params_dtype=params_dtype,
)
policy_model.config.gradient_checkpointing = gradient_checkpointing
policy_model.config.gradient_checkpointing_policy = gradient_checkpointing_policy
with jax.default_device(jax.devices('cpu')[0]):
initial_policy_params = jax.tree_util.tree_map(
lambda x: multihost_device_get(x, mesh=mesh).copy(),
policy_train_state.params,
)
initial_policy_params = shard_params_from_params(
model=policy_model,
params=initial_policy_params,
)
loop_state = dict()
if should_restore_loop_state and (model_load_mode in {ModelLoadMode.TRAIN_STATE,
ModelLoadMode.TRAIN_STATE_PARAMS,
ModelLoadMode.PARAMS}):
with open(os.path.join(convert_path(model_load_path), 'loop_state.pkl'), 'rb') as f:
loop_state = pkl.load(f)
policy_inference = GPT2Inference.load_inference(
params=policy_train_state.params,
model=policy_model,
tokenizer=tokenizer,
)
policy_prng = jax.random.PRNGKey(0)
policy = GPT2PPOPolicy(
inference=policy_inference,
prng_key=policy_prng,
generation_config=GenerationConfig(
do_sample=policy_do_sample,
num_beams=policy_num_beams,
temperature=policy_temperature,
top_p=policy_top_p,
top_k=policy_top_k,
eos_token_id=tokenizer.encode('\n')[0],
pad_token_id=tokenizer.pad_token_id,
max_new_tokens=max_output_length,
),
blocking_strategy=BlockingStrategy(
padding=Padding.LEFT,
truncation=Truncation.LEFT,
max_length=max_input_length,
),
out_str_process=lambda x: x.removesuffix('\n')+'\n',
)
def value_head_optim_getter(params: PyTree):
mask = get_weight_decay_mask(("bias",))(params)
return optax.MultiSteps(
optax.adamw(
learning_rate=lr,
b1=0.9,
b2=0.95,
eps=1e-8,
weight_decay=weight_decay,
mask=mask,
),
every_k_schedule=grad_accum_steps,
)
head_prng_key = jax.random.PRNGKey(3)
value_head_train_state, value_head = load_head_train_state_from_config(
|
# from LLM_RL.gpt2 import load_gpt2_from_pretrained
def main(
model_load_mode: ModelLoadMode,
model_load_path: str,
/, # Mark the end of positional arguments.
bc_data_path: Optional[str]=None,
train_bc_bsize: int=8,
bc_loss_weight:int=0,
model_str:str="gpt2",
exp_name: Optional[str]=None,
outputs_path: Optional[str]=None,
maze_name: str="double_t_maze",
data_mesh_shape: int=1,
fsdp_mesh_shape: int=1,
model_mesh_shape: int=-1,
use_wandb: bool=False,
wandb_project: Optional[str]=None,
n_rounds: int=1,
epochs: int=1,
max_steps: Optional[int]=None,
lr: float=1e-5,
weight_decay: float=0.0,
train_bsize: int=32,
grad_accum_steps: int=1,
rollout_bsize: int=32,
n_rollouts: int=128,
ppo_data_bsize: int=32,
num_pos_per_setup: int=4,
gradient_checkpointing: bool=False,
gradient_checkpointing_policy: str='nothing_saveable',
use_fp16_activations: bool=False,
use_fp16_params: bool=False,
max_input_length: int=64,
max_output_length: int=32,
log_every: int=256,
eval_every_steps: Optional[int]=None,
eval_every_epochs: Optional[int]=None,
eval_every_rounds: Optional[int]=1,
eval_at_beginning: bool=True,
eval_at_end: bool=True,
save_every_steps: Optional[int]=None,
save_every_epochs: Optional[int]=None,
save_every_rounds: Optional[int]=10,
save_at_beginning: bool=False,
save_at_end: bool=True,
save_best: bool=True,
max_checkpoints: Optional[int]=20,
save_train_state: bool=True,
save_ppo_dataset: bool=True,
save_bf16: bool=True,
policy_do_sample: bool=True,
policy_num_beams: int=1,
policy_temperature: Optional[float]=None,
policy_top_p: Optional[float]=None,
policy_top_k: Optional[int]=None,
gamma: float=0.99,
lam: float=0.95,
use_advantage_whitening: bool=True,
init_kl_coef: float=0.001,
kl_target: Optional[float]=None,
kl_horizon: Optional[int]=None,
cliprange_value: float=0.2,
cliprange: float=0.2,
value_loss_coef: float=0.5,
force_pad_embeddings: bool=False,
should_restore_loop_state: bool=False,
describe_function: str= "describe_observation",
reranker_policy: bool=False,
reward_function: str="standard_reward",
):
input_args = locals().copy()
print(input_args)
use_adaptive_kl = (kl_target is not None and kl_horizon is not None)
if not use_adaptive_kl:
assert kl_target is None and kl_horizon is None
tokenizer = AutoTokenizer.from_pretrained('gpt2')
tokenizer.add_special_tokens({'pad_token': '<|pad|>'})
if bc_data_path is not None:
with open(bc_data_path, 'rb') as f:
text_histories = pkl.load(f)
blocking_strategy = BlockingStrategy(Padding.RIGHT, Truncation.RIGHT, max_input_length+max_output_length)
# in_tokens = list(map(lambda x: block_sequences([x.tokens], tokenizer.pad_token_id, dtype=np.int32, blocking_strategy=BlockingStrategy(Padding.RIGHT, Truncation.RIGHT, max_input_length))[0], text_histories))
# text_histories = list(map(lambda x: x.text_history, text_trajectories))
# no this doesn't work because we also need to pad the is_actions
token_histories = list(map(lambda x: TokenHistory.from_text_history(x, tokenizer), text_histories))
in_tokens = list(map(lambda x: block_sequences([x.tokens], tokenizer.pad_token_id, dtype=np.int32, blocking_strategy=blocking_strategy)[0], token_histories))
is_actions = list(map(lambda x: block_sequences([x.is_action], 0.0, dtype=np.float32, blocking_strategy=blocking_strategy)[0], token_histories))
# tokens = list(map(lambda x: token_process(x.tokens), token_histories))
# is_actions = list(map(lambda x: x.is_action, token_histories))
bc_data = MaskDataset(
in_tokens = jnp.array(in_tokens),
in_training_mask = jnp.array(is_actions),
)
else:
bc_data = None
mesh = load_mesh((data_mesh_shape, fsdp_mesh_shape, model_mesh_shape), ('dp', 'fsdp', 'mp'))
is_main_process = jax.process_index() == 0
print(f"Mesh: {mesh}")
print(f"Is main process: {is_main_process}")
def policy_optim_getter(params: PyTree):
mask = get_weight_decay_mask((
"".join([r"\['ln_[0-9]+'\]", re.escape("['bias']")]),
"".join([r"\['ln_[0-9]+'\]", re.escape("['scale']")]),
re.escape("['ln_f']['bias']"),
re.escape("['ln_f']['scale']"),
"bias",
))(params)
return optax.MultiSteps(
optax.adamw(
learning_rate=lr,
b1=0.9,
b2=0.95,
eps=1e-8,
weight_decay=weight_decay,
mask=mask,
),
every_k_schedule=grad_accum_steps,
)
model_dtype = get_dtype(use_fp16=use_fp16_activations)
params_dtype = get_dtype(use_fp16=use_fp16_params)
model_prng_key = jax.random.PRNGKey(2)
policy_train_state, policy_model = load_train_state(
model_load_mode=model_load_mode,
model_load_path=convert_path(model_load_path) if model_load_mode != ModelLoadMode.HF else model_load_path,
model_dtype=model_dtype,
optim_getter=policy_optim_getter,
tokenizer=tokenizer,
mesh=mesh,
prng_key=model_prng_key,
force_pad_embeddings=force_pad_embeddings,
params_dtype=params_dtype,
)
policy_model.config.gradient_checkpointing = gradient_checkpointing
policy_model.config.gradient_checkpointing_policy = gradient_checkpointing_policy
with jax.default_device(jax.devices('cpu')[0]):
initial_policy_params = jax.tree_util.tree_map(
lambda x: multihost_device_get(x, mesh=mesh).copy(),
policy_train_state.params,
)
initial_policy_params = shard_params_from_params(
model=policy_model,
params=initial_policy_params,
)
loop_state = dict()
if should_restore_loop_state and (model_load_mode in {ModelLoadMode.TRAIN_STATE,
ModelLoadMode.TRAIN_STATE_PARAMS,
ModelLoadMode.PARAMS}):
with open(os.path.join(convert_path(model_load_path), 'loop_state.pkl'), 'rb') as f:
loop_state = pkl.load(f)
policy_inference = GPT2Inference.load_inference(
params=policy_train_state.params,
model=policy_model,
tokenizer=tokenizer,
)
policy_prng = jax.random.PRNGKey(0)
policy = GPT2PPOPolicy(
inference=policy_inference,
prng_key=policy_prng,
generation_config=GenerationConfig(
do_sample=policy_do_sample,
num_beams=policy_num_beams,
temperature=policy_temperature,
top_p=policy_top_p,
top_k=policy_top_k,
eos_token_id=tokenizer.encode('\n')[0],
pad_token_id=tokenizer.pad_token_id,
max_new_tokens=max_output_length,
),
blocking_strategy=BlockingStrategy(
padding=Padding.LEFT,
truncation=Truncation.LEFT,
max_length=max_input_length,
),
out_str_process=lambda x: x.removesuffix('\n')+'\n',
)
def value_head_optim_getter(params: PyTree):
mask = get_weight_decay_mask(("bias",))(params)
return optax.MultiSteps(
optax.adamw(
learning_rate=lr,
b1=0.9,
b2=0.95,
eps=1e-8,
weight_decay=weight_decay,
mask=mask,
),
every_k_schedule=grad_accum_steps,
)
head_prng_key = jax.random.PRNGKey(3)
value_head_train_state, value_head = load_head_train_state_from_config( | model_config=LinearHeadConfig( | 14 | 2023-11-21 00:16:42+00:00 | 24k |
jzmzhong/Automatic-Prosody-Annotator-with-SSWP-CLAP | src/clap_module/conformer/encoder.py | [
{
"identifier": "ConvolutionModule",
"path": "src/clap_module/conformer/convolution.py",
"snippet": "class ConvolutionModule(nn.Module):\r\n \"\"\"ConvolutionModule in Conformer model.\r\n\r\n Args:\r\n channels (int): The number of channels of conv layers.\r\n kernel_size (int): Ker... | import logging
import torch
import math
from .convolution import ConvolutionModule
from .encoder_layer import EncoderLayer
from .modules import get_activation
from .modules import VGG2L
from .modules import (
LegacyRelPositionMultiHeadedAttention,
MultiHeadedAttention,
RelPositionMultiHeadedAttention,
)
from .embedding import (
LegacyRelPositionalEncoding,
PositionalEncoding,
RelPositionalEncoding,
ScaledPositionalEncoding,
)
from .modules import LayerNorm
from .multi_layer_conv import (
Conv1dLinear,
MultiLayeredConv1d,
)
from .modules import (
PositionwiseFeedForward,
)
from .modules import repeat
from .sub_sampling import Conv2dSubsampling
from ..feature_fusion import AttentionPool1d, DAF, AFF, iAFF
| 14,943 | ctc_softmax=None,
conditioning_layer_dim=None,
max_seq_len=100,
enable_fusion=False,
fusion_type="",
):
"""Construct an Encoder object."""
super(Encoder, self).__init__()
self.max_seq_len = max_seq_len
activation = get_activation(activation_type)
if pos_enc_layer_type == "abs_pos":
pos_enc_class = PositionalEncoding
elif pos_enc_layer_type == "scaled_abs_pos":
pos_enc_class = ScaledPositionalEncoding
elif pos_enc_layer_type == "rel_pos":
assert selfattention_layer_type == "rel_selfattn"
pos_enc_class = RelPositionalEncoding
elif pos_enc_layer_type == "legacy_rel_pos":
assert selfattention_layer_type == "legacy_rel_selfattn"
pos_enc_class = LegacyRelPositionalEncoding
else:
raise ValueError("unknown pos_enc_layer: " + pos_enc_layer_type)
self.conv_subsampling_factor = 1
if input_layer == "linear":
self.embed = torch.nn.Sequential(
torch.nn.Linear(idim, attention_dim),
torch.nn.LayerNorm(attention_dim),
torch.nn.Dropout(dropout_rate),
pos_enc_class(attention_dim, positional_dropout_rate),
)
elif input_layer == "conv2d":
self.embed = Conv2dSubsampling(
idim,
attention_dim,
dropout_rate,
pos_enc_class(attention_dim, positional_dropout_rate),
)
self.conv_subsampling_factor = 4
elif input_layer == "vgg2l":
self.embed = VGG2L(idim, attention_dim)
self.conv_subsampling_factor = 4
elif input_layer == "embed":
self.embed = torch.nn.Sequential(
torch.nn.Embedding(idim, attention_dim, padding_idx=padding_idx),
pos_enc_class(attention_dim, positional_dropout_rate),
)
elif isinstance(input_layer, torch.nn.Module):
self.embed = torch.nn.Sequential(
input_layer,
pos_enc_class(attention_dim, positional_dropout_rate),
)
elif input_layer is None:
self.embed = torch.nn.Sequential(
pos_enc_class(attention_dim, positional_dropout_rate)
)
else:
raise ValueError("unknown input_layer: " + input_layer)
self.normalize_before = normalize_before
# self-attention module definition
if selfattention_layer_type == "selfattn":
logging.info("encoder self-attention layer type = self-attention")
encoder_selfattn_layer = MultiHeadedAttention
encoder_selfattn_layer_args = (
attention_heads,
attention_dim,
attention_dropout_rate,
)
elif selfattention_layer_type == "legacy_rel_selfattn":
assert pos_enc_layer_type == "legacy_rel_pos"
encoder_selfattn_layer = LegacyRelPositionMultiHeadedAttention
encoder_selfattn_layer_args = (
attention_heads,
attention_dim,
attention_dropout_rate,
)
elif selfattention_layer_type == "rel_selfattn":
logging.info("encoder self-attention layer type = relative self-attention")
assert pos_enc_layer_type == "rel_pos"
encoder_selfattn_layer = RelPositionMultiHeadedAttention
encoder_selfattn_layer_args = (
attention_heads,
attention_dim,
attention_dropout_rate,
zero_triu,
)
else:
raise ValueError("unknown encoder_attn_layer: " + selfattention_layer_type)
# feed-forward module definition
if ffn_layer_type == "linear":
ffn_layer = PositionwiseFeedForward
ffn_layer_args = (
attention_dim,
linear_units,
dropout_rate,
activation,
)
elif ffn_layer_type == "conv1d":
ffn_layer = MultiLayeredConv1d
ffn_layer_args = (
attention_dim,
linear_units,
ffn_conv_kernel_size,
dropout_rate,
)
elif ffn_layer_type == "conv1d-linear":
ffn_layer = Conv1dLinear
ffn_layer_args = (
attention_dim,
linear_units,
ffn_conv_kernel_size,
dropout_rate,
)
else:
raise NotImplementedError("Support only linear or conv1d.")
# convolution module definition
| # Copyright 2020 Johns Hopkins University (Shinji Watanabe)
# Northwestern Polytechnical University (Pengcheng Guo)
# Apache 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
"""Encoder definition."""
class Encoder(torch.nn.Module):
"""Conformer encoder module.
Args:
idim (int): Input dimension.
attention_dim (int): Dimension of attention.
attention_heads (int): The number of heads of multi head attention.
linear_units (int): The number of units of position-wise feed forward.
num_blocks (int): The number of decoder blocks.
dropout_rate (float): Dropout rate.
positional_dropout_rate (float): Dropout rate after adding positional encoding.
attention_dropout_rate (float): Dropout rate in attention.
input_layer (Union[str, torch.nn.Module]): Input layer type.
normalize_before (bool): Whether to use layer_norm before the first block.
concat_after (bool): Whether to concat attention layer's input and output.
if True, additional linear will be applied.
i.e. x -> x + linear(concat(x, att(x)))
if False, no additional linear will be applied. i.e. x -> x + att(x)
positionwise_layer_type (str): "linear", "conv1d", or "conv1d-linear".
positionwise_conv_kernel_size (int): Kernel size of positionwise conv1d layer.
macaron_style (bool): Whether to use macaron style for positionwise layer.
pos_enc_layer_type (str): Encoder positional encoding layer type.
selfattention_layer_type (str): Encoder attention layer type.
activation_type (str): Encoder activation function type.
use_cnn_module (bool): Whether to use convolution module.
zero_triu (bool): Whether to zero the upper triangular part of attention matrix.
cnn_module_kernel (int): Kernerl size of convolution module.
padding_idx (int): Padding idx for input_layer=embed.
stochastic_depth_rate (float): Maximum probability to skip the encoder layer.
intermediate_layers (Union[List[int], None]): indices of intermediate CTC layer.
indices start from 1.
if not None, intermediate outputs are returned (which changes return type
signature.)
"""
def __init__(
self,
idim,
attention_dim=256,
attention_heads=4,
linear_units=2048,
num_blocks=6,
dropout_rate=0.1,
positional_dropout_rate=0.1,
attention_dropout_rate=0.0,
input_layer="conv2d",
normalize_before=True,
concat_after=False,
ffn_layer_type="linear",
ffn_conv_kernel_size=1,
macaron_style=False,
pos_enc_layer_type="abs_pos",
selfattention_layer_type="selfattn",
activation_type="relu",
use_cnn_module=True,
zero_triu=False,
cnn_module_kernel=31,
padding_idx=-1,
stochastic_depth_rate=0.0,
intermediate_layers=None,
ctc_softmax=None,
conditioning_layer_dim=None,
max_seq_len=100,
enable_fusion=False,
fusion_type="",
):
"""Construct an Encoder object."""
super(Encoder, self).__init__()
self.max_seq_len = max_seq_len
activation = get_activation(activation_type)
if pos_enc_layer_type == "abs_pos":
pos_enc_class = PositionalEncoding
elif pos_enc_layer_type == "scaled_abs_pos":
pos_enc_class = ScaledPositionalEncoding
elif pos_enc_layer_type == "rel_pos":
assert selfattention_layer_type == "rel_selfattn"
pos_enc_class = RelPositionalEncoding
elif pos_enc_layer_type == "legacy_rel_pos":
assert selfattention_layer_type == "legacy_rel_selfattn"
pos_enc_class = LegacyRelPositionalEncoding
else:
raise ValueError("unknown pos_enc_layer: " + pos_enc_layer_type)
self.conv_subsampling_factor = 1
if input_layer == "linear":
self.embed = torch.nn.Sequential(
torch.nn.Linear(idim, attention_dim),
torch.nn.LayerNorm(attention_dim),
torch.nn.Dropout(dropout_rate),
pos_enc_class(attention_dim, positional_dropout_rate),
)
elif input_layer == "conv2d":
self.embed = Conv2dSubsampling(
idim,
attention_dim,
dropout_rate,
pos_enc_class(attention_dim, positional_dropout_rate),
)
self.conv_subsampling_factor = 4
elif input_layer == "vgg2l":
self.embed = VGG2L(idim, attention_dim)
self.conv_subsampling_factor = 4
elif input_layer == "embed":
self.embed = torch.nn.Sequential(
torch.nn.Embedding(idim, attention_dim, padding_idx=padding_idx),
pos_enc_class(attention_dim, positional_dropout_rate),
)
elif isinstance(input_layer, torch.nn.Module):
self.embed = torch.nn.Sequential(
input_layer,
pos_enc_class(attention_dim, positional_dropout_rate),
)
elif input_layer is None:
self.embed = torch.nn.Sequential(
pos_enc_class(attention_dim, positional_dropout_rate)
)
else:
raise ValueError("unknown input_layer: " + input_layer)
self.normalize_before = normalize_before
# self-attention module definition
if selfattention_layer_type == "selfattn":
logging.info("encoder self-attention layer type = self-attention")
encoder_selfattn_layer = MultiHeadedAttention
encoder_selfattn_layer_args = (
attention_heads,
attention_dim,
attention_dropout_rate,
)
elif selfattention_layer_type == "legacy_rel_selfattn":
assert pos_enc_layer_type == "legacy_rel_pos"
encoder_selfattn_layer = LegacyRelPositionMultiHeadedAttention
encoder_selfattn_layer_args = (
attention_heads,
attention_dim,
attention_dropout_rate,
)
elif selfattention_layer_type == "rel_selfattn":
logging.info("encoder self-attention layer type = relative self-attention")
assert pos_enc_layer_type == "rel_pos"
encoder_selfattn_layer = RelPositionMultiHeadedAttention
encoder_selfattn_layer_args = (
attention_heads,
attention_dim,
attention_dropout_rate,
zero_triu,
)
else:
raise ValueError("unknown encoder_attn_layer: " + selfattention_layer_type)
# feed-forward module definition
if ffn_layer_type == "linear":
ffn_layer = PositionwiseFeedForward
ffn_layer_args = (
attention_dim,
linear_units,
dropout_rate,
activation,
)
elif ffn_layer_type == "conv1d":
ffn_layer = MultiLayeredConv1d
ffn_layer_args = (
attention_dim,
linear_units,
ffn_conv_kernel_size,
dropout_rate,
)
elif ffn_layer_type == "conv1d-linear":
ffn_layer = Conv1dLinear
ffn_layer_args = (
attention_dim,
linear_units,
ffn_conv_kernel_size,
dropout_rate,
)
else:
raise NotImplementedError("Support only linear or conv1d.")
# convolution module definition
| convolution_layer = ConvolutionModule
| 0 | 2023-11-25 02:38:32+00:00 | 24k |
Luo-Z13/pointobb | PointOBB/mmdet/models/roi_heads/PointOBB_head.py | [
{
"identifier": "HEADS",
"path": "PointOBB/mmdet/models/builder.py",
"snippet": "HEADS = MODELS"
},
{
"identifier": "MODELS",
"path": "PointOBB/mmdet/models/builder.py",
"snippet": "MODELS = Registry('models', parent=MMCV_MODELS)"
},
{
"identifier": "build_head",
"path": "Poi... | import math
import torch
import torch.nn.functional as F
import torch.nn as nn
import copy
import numpy as np
import cv2
from mmdet.core import bbox2result, bbox2roi, rbbox2roi, build_assigner, build_sampler, multi_apply
from ..builder import HEADS, MODELS, build_head, build_roi_extractor, build_loss
from .standard_roi_head import StandardRoIHead
from .cascade_roi_head import CascadeRoIHead
from mmdet.core.bbox.iou_calculators import bbox_overlaps
from .test_mixins import BBoxTestMixin, MaskTestMixin
from mmdet.core.bbox import bbox_xyxy_to_cxcywh
from mmdet.core.bbox.transforms import rbbox2result
from mmcv.cnn import Scale, ConvModule
from mmcv.ops import box_iou_rotated
from typing import Any, List, Sequence, Tuple, Union
from torch import Tensor
from mmdet.models.utils.base_bbox_coder import BaseBBoxCoder
from ..detectors.utils import obb2xyxy, regularize_boxes, reduce_mean, obb2poly_np | 16,228 | """Simplest base roi head including one bbox head and one mask head."""
def __init__(self,
bbox_roi_extractor,
num_stages,
bbox_head,
top_k=7,
with_atten=None,
conv_cfg=None,
norm_cfg=None,
scale_angle: bool = True,
stacked_convs = 4,
loss_symmetry_ss=dict(
type='SmoothL1Loss', loss_weight=1.0, beta=0.1),
angle_coder=dict(
type='PSCCoder',
angle_version='le90',
dual_freq=False,
num_step=3,
thr_mod=0),
angle_version = 'le90',
use_angle_loss = True,
add_angle_pred_begin = False,
not_use_rot_mil = False,
detach_angle_head = False,
rotation_agnostic_classes = None,
agnostic_resize_classes = None,
cls_scores_weight = 1.0,
ins_scores_weight = 1.0,
**kwargs):
super(PointOBBHead, self).__init__(bbox_roi_extractor=bbox_roi_extractor, bbox_head=bbox_head, **kwargs)
self.threshold = 0.3
self.merge_mode = 'weighted_clsins'
self.test_mean_iou = False
# self.test_mean_iou = True
self.sum_iou = 0
self.sum_num = 0
self.num_stages = num_stages
self.topk1 = top_k # 7
self.topk2 = top_k # 7
self.featmap_strides = bbox_roi_extractor.featmap_strides
self.with_atten = with_atten
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.in_channels=256
self.feat_channels=256
self.stacked_convs=stacked_convs
self.is_scale_angle = scale_angle
self.angle_coder = HEADS.build(angle_coder)
self.loss_symmetry_ss = build_loss(loss_symmetry_ss)
self.angle_version = angle_version
self.rotation_agnostic_classes = rotation_agnostic_classes
self.agnostic_resize_classes = agnostic_resize_classes
self.add_angle_pred_begin = add_angle_pred_begin
self.use_angle_loss = use_angle_loss
self.not_use_rot_mil = not_use_rot_mil
self.detach_angle_head = detach_angle_head
self.cls_scores_weight = cls_scores_weight
self.ins_scores_weight = ins_scores_weight
self.num_classes = self.bbox_head.num_classes
self._init_layers()
def _init_layers(self):
"""Initialize layers of the head."""
self.relu = nn.ReLU(inplace=True)
self.cls_convs = nn.ModuleList()
for i in range(self.stacked_convs):
chn = self.in_channels if i == 0 else self.feat_channels
self.cls_convs.append(
ConvModule(
chn,
self.feat_channels,
3,
stride=1,
padding=1,
conv_cfg=self.conv_cfg,
norm_cfg=self.norm_cfg))
self.conv_angle = nn.Conv2d(
self.feat_channels, self.angle_coder.encode_size, 3, padding=1)
if self.is_scale_angle:
self.scale_angle = Scale(1.0)
def angle_forward(self, feats: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
angle_results = []
for feat in feats:
if self.detach_angle_head:
feat_detach = feat.clone().detach()
single_angle_pred = self.angle_forward_single(feat_detach)
else:
single_angle_pred = self.angle_forward_single(feat)
angle_results.append(single_angle_pred)
return tuple(angle_results)
def angle_forward_single(self, x: Tensor):
cls_feat = x
for cls_layer in self.cls_convs:
cls_feat = cls_layer(cls_feat)
# cls_score = self.conv_cls(cls_feat)
angle_pred = self.conv_angle(cls_feat)
if self.is_scale_angle:
angle_pred = self.scale_angle(angle_pred).float()
return angle_pred
def init_assigner_sampler(self):
"""Initialize assigner and sampler."""
self.bbox_assigner = None
self.bbox_sampler = None
if self.train_cfg:
self.bbox_assigner = build_assigner(self.train_cfg.assigner)
self.bbox_sampler = build_sampler(
self.train_cfg.sampler, context=self)
def init_bbox_head(self, bbox_roi_extractor, bbox_head):
"""Initialize ``bbox_head``"""
|
RangeType = Sequence[Tuple[int, int]]
INF = 1e8
def meshgrid(x: Tensor,
y: Tensor,
row_major: bool = True) -> Tuple[Tensor, Tensor]:
yy, xx = torch.meshgrid(y, x)
if row_major:
# warning .flatten() would cause error in ONNX exportingF
# have to use reshape here
return xx.reshape(-1), yy.reshape(-1)
else:
return yy.reshape(-1), xx.reshape(-1)
def obb2cxcywh_le90(obboxes):
"""Convert oriented bounding boxes to horizontal bounding boxes.
Args:
obbs (torch.Tensor): [x_ctr,y_ctr,w,h,angle]
Returns:
hbbs (torch.Tensor): [x_lt,y_lt,x_rb,y_rb]
"""
center, w, h, theta = torch.split(obboxes, [2, 1, 1, 1], dim=-1)
Cos, Sin = torch.cos(theta), torch.sin(theta)
x_bias = torch.abs(w / 2 * Cos) + torch.abs(h / 2 * Sin)
y_bias = torch.abs(w / 2 * Sin) + torch.abs(h / 2 * Cos)
bias = torch.cat([x_bias, y_bias], dim=-1)
wh = bias * 2
return torch.cat([center, wh, torch.zeros_like(theta)], dim=-1)
@HEADS.register_module()
class PSCCoder(BaseBBoxCoder):
"""Phase-Shifting Coder.
`Phase-Shifting Coder (PSC)
<https://arxiv.org/abs/2211.06368>`.
Args:
angle_version (str): Angle definition.
Only 'le90' is supported at present.
dual_freq (bool, optional): Use dual frequency. Default: True.
num_step (int, optional): Number of phase steps. Default: 3.
thr_mod (float): Threshold of modulation. Default: 0.47.
"""
def __init__(self,
angle_version: str,
dual_freq: bool = True,
num_step: int = 3,
thr_mod: float = 0.47):
super().__init__()
self.angle_version = angle_version
assert angle_version in ['le90']
self.dual_freq = dual_freq
self.num_step = num_step
self.thr_mod = thr_mod
if self.dual_freq:
self.encode_size = 2 * self.num_step
else:
self.encode_size = self.num_step
self.coef_sin = torch.tensor(
tuple(
torch.sin(torch.tensor(2 * k * math.pi / self.num_step))
for k in range(self.num_step)))
self.coef_cos = torch.tensor(
tuple(
torch.cos(torch.tensor(2 * k * math.pi / self.num_step))
for k in range(self.num_step)))
def encode(self, angle_targets: Tensor) -> Tensor:
"""Phase-Shifting Encoder.
Args:
angle_targets (Tensor): Angle offset for each scale level.
Has shape (num_anchors * H * W, 1)
Returns:
list[Tensor]: The psc coded data (phase-shifting patterns)
for each scale level.
Has shape (num_anchors * H * W, encode_size)
"""
phase_targets = angle_targets * 2
phase_shift_targets = tuple(
torch.cos(phase_targets + 2 * math.pi * x / self.num_step)
for x in range(self.num_step))
# Dual-freq PSC for square-like problem
if self.dual_freq:
phase_targets = angle_targets * 4
phase_shift_targets += tuple(
torch.cos(phase_targets + 2 * math.pi * x / self.num_step)
for x in range(self.num_step))
return torch.cat(phase_shift_targets, axis=-1)
def decode(self, angle_preds: Tensor, keepdim: bool = False) -> Tensor:
"""Phase-Shifting Decoder.
Args:
angle_preds (Tensor): The psc coded data (phase-shifting patterns)
for each scale level.
Has shape (num_anchors * H * W, encode_size)
keepdim (bool): Whether the output tensor has dim retained or not.
Returns:
list[Tensor]: Angle offset for each scale level.
Has shape (num_anchors * H * W, 1) when keepdim is true,
(num_anchors * H * W) otherwise
"""
self.coef_sin = self.coef_sin.to(angle_preds)
self.coef_cos = self.coef_cos.to(angle_preds)
phase_sin = torch.sum(
angle_preds[:, 0:self.num_step] * self.coef_sin,
dim=-1,
keepdim=keepdim)
phase_cos = torch.sum(
angle_preds[:, 0:self.num_step] * self.coef_cos,
dim=-1,
keepdim=keepdim)
phase_mod = phase_cos**2 + phase_sin**2
phase = -torch.atan2(phase_sin, phase_cos) # In range [-pi,pi)
if self.dual_freq:
phase_sin = torch.sum(
angle_preds[:, self.num_step:(2 * self.num_step)] *
self.coef_sin,
dim=-1,
keepdim=keepdim)
phase_cos = torch.sum(
angle_preds[:, self.num_step:(2 * self.num_step)] *
self.coef_cos,
dim=-1,
keepdim=keepdim)
phase_mod = phase_cos**2 + phase_sin**2
phase2 = -torch.atan2(phase_sin, phase_cos) / 2
# Phase unwarpping, dual freq mixing
# Angle between phase and phase2 is obtuse angle
idx = torch.cos(phase) * torch.cos(phase2) + torch.sin(
phase) * torch.sin(phase2) < 0
# Add pi to phase2 and keep it in range [-pi,pi)
phase2[idx] = phase2[idx] % (2 * math.pi) - math.pi
phase = phase2
# Set the angle of isotropic objects to zero
phase[phase_mod < self.thr_mod] *= 0
angle_pred = phase / 2
return angle_pred
@HEADS.register_module()
class PointOBBHead(StandardRoIHead):
"""Simplest base roi head including one bbox head and one mask head."""
def __init__(self,
bbox_roi_extractor,
num_stages,
bbox_head,
top_k=7,
with_atten=None,
conv_cfg=None,
norm_cfg=None,
scale_angle: bool = True,
stacked_convs = 4,
loss_symmetry_ss=dict(
type='SmoothL1Loss', loss_weight=1.0, beta=0.1),
angle_coder=dict(
type='PSCCoder',
angle_version='le90',
dual_freq=False,
num_step=3,
thr_mod=0),
angle_version = 'le90',
use_angle_loss = True,
add_angle_pred_begin = False,
not_use_rot_mil = False,
detach_angle_head = False,
rotation_agnostic_classes = None,
agnostic_resize_classes = None,
cls_scores_weight = 1.0,
ins_scores_weight = 1.0,
**kwargs):
super(PointOBBHead, self).__init__(bbox_roi_extractor=bbox_roi_extractor, bbox_head=bbox_head, **kwargs)
self.threshold = 0.3
self.merge_mode = 'weighted_clsins'
self.test_mean_iou = False
# self.test_mean_iou = True
self.sum_iou = 0
self.sum_num = 0
self.num_stages = num_stages
self.topk1 = top_k # 7
self.topk2 = top_k # 7
self.featmap_strides = bbox_roi_extractor.featmap_strides
self.with_atten = with_atten
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.in_channels=256
self.feat_channels=256
self.stacked_convs=stacked_convs
self.is_scale_angle = scale_angle
self.angle_coder = HEADS.build(angle_coder)
self.loss_symmetry_ss = build_loss(loss_symmetry_ss)
self.angle_version = angle_version
self.rotation_agnostic_classes = rotation_agnostic_classes
self.agnostic_resize_classes = agnostic_resize_classes
self.add_angle_pred_begin = add_angle_pred_begin
self.use_angle_loss = use_angle_loss
self.not_use_rot_mil = not_use_rot_mil
self.detach_angle_head = detach_angle_head
self.cls_scores_weight = cls_scores_weight
self.ins_scores_weight = ins_scores_weight
self.num_classes = self.bbox_head.num_classes
self._init_layers()
def _init_layers(self):
"""Initialize layers of the head."""
self.relu = nn.ReLU(inplace=True)
self.cls_convs = nn.ModuleList()
for i in range(self.stacked_convs):
chn = self.in_channels if i == 0 else self.feat_channels
self.cls_convs.append(
ConvModule(
chn,
self.feat_channels,
3,
stride=1,
padding=1,
conv_cfg=self.conv_cfg,
norm_cfg=self.norm_cfg))
self.conv_angle = nn.Conv2d(
self.feat_channels, self.angle_coder.encode_size, 3, padding=1)
if self.is_scale_angle:
self.scale_angle = Scale(1.0)
def angle_forward(self, feats: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
angle_results = []
for feat in feats:
if self.detach_angle_head:
feat_detach = feat.clone().detach()
single_angle_pred = self.angle_forward_single(feat_detach)
else:
single_angle_pred = self.angle_forward_single(feat)
angle_results.append(single_angle_pred)
return tuple(angle_results)
def angle_forward_single(self, x: Tensor):
cls_feat = x
for cls_layer in self.cls_convs:
cls_feat = cls_layer(cls_feat)
# cls_score = self.conv_cls(cls_feat)
angle_pred = self.conv_angle(cls_feat)
if self.is_scale_angle:
angle_pred = self.scale_angle(angle_pred).float()
return angle_pred
def init_assigner_sampler(self):
"""Initialize assigner and sampler."""
self.bbox_assigner = None
self.bbox_sampler = None
if self.train_cfg:
self.bbox_assigner = build_assigner(self.train_cfg.assigner)
self.bbox_sampler = build_sampler(
self.train_cfg.sampler, context=self)
def init_bbox_head(self, bbox_roi_extractor, bbox_head):
"""Initialize ``bbox_head``""" | self.bbox_roi_extractor = build_roi_extractor(bbox_roi_extractor) | 3 | 2023-11-20 07:50:12+00:00 | 24k |
ModelTC/EasyLLM | llm/models/hf_models/qwen_vl/modeling_qwen.py | [
{
"identifier": "QWenConfig",
"path": "llm/models/hf_models/qwen_vl/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_... | import importlib
import math
import torch # noqa
import torch.nn.functional as F # noqa
import torch.utils.checkpoint # noqa
from typing import TYPE_CHECKING, Dict, Optional, Tuple, Union, Callable, List, Any, Generator # noqa
from torch.cuda.amp import autocast # noqa
from torch.nn import CrossEntropyLoss
from transformers import PreTrainedTokenizer, GenerationConfig, StoppingCriteriaList # noqa
from transformers.generation.logits_process import LogitsProcessorList # noqa
from transformers.generation.streamers import BaseStreamer # noqa
from transformers.generation.utils import GenerateOutput # noqa
from transformers.modeling_outputs import (
BaseModelOutputWithPast,
CausalLMOutputWithPast,
)
from transformers.modeling_utils import PreTrainedModel # noqa
from transformers.utils import logging
from einops import rearrange
from torch import nn
from .configuration_qwen import QWenConfig # noqa
from .qwen_generation_utils import (
make_context,
) # noqa
from llm.models.hf_models.qwen.qwen_generation_utils import (
HistoryType,
decode_tokens,
get_stop_words_ids,
)
from .visual import VisionTransformer
from llm.models.hf_models.qwen.modeling_qwen import RMSNorm, apply_rotary_pos_emb, QWenMLP
from llm.models.hf_models.qwen.modeling_qwen import QWenAttention as QWenAttention_chat
from llm.models.hf_models.qwen.modeling_qwen import QWenModel as QWenModel_chat
from llm.models.hf_models.qwen.modeling_qwen import QWenLMHeadModel as QWenLMHeadModel_chat
from einops import rearrange | 15,715 | ):
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)
query = query.permute(0, 2, 1, 3)
key = key.permute(0, 2, 1, 3)
value = value.permute(0, 2, 1, 3)
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:
outputs += (attn_weight,)
return outputs
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
| # 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:
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)。
"""
apply_rotary_emb_func = None
rms_norm = None
# Copied from transformers.models.bart.modeling_bart._make_causal_mask
def _make_causal_mask(
input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0
):
"""
Make causal mask used for bi-directional self-attention.
"""
bsz, tgt_len = input_ids_shape
mask = torch.full((tgt_len, tgt_len), torch.finfo(dtype).min, device=device)
mask_cond = torch.arange(mask.size(-1), device=device)
mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)
mask = mask.to(dtype)
if past_key_values_length > 0:
mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1)
return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)
# Copied from transformers.models.bart.modeling_bart._expand_mask
def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
"""
Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
"""
bsz, src_len = mask.size()
tgt_len = tgt_len if tgt_len is not None else src_len
expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)
inverted_mask = 1.0 - expanded_mask
return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)
class QWenAttention(QWenAttention_chat):
def __init__(self, config):
super().__init__(config)
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,
)
attn_weights = attn_weights + attention_mask
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 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)
query = query.permute(0, 2, 1, 3)
key = key.permute(0, 2, 1, 3)
value = value.permute(0, 2, 1, 3)
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:
outputs += (attn_weight,)
return outputs
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 QWenModel(QWenModel_chat): | 6 | 2023-11-26 10:12:52+00:00 | 24k |
bearyi26/DCPT | 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 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, BDD100K_Night, SHIFT_Night, ExDark
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 | 20,995 | # 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", "BDD100K_NIGHT", "SHIFT_NIGHT", "ExDark"]
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 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", "BDD100K_NIGHT", "SHIFT_NIGHT", "ExDark"]
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)) | 0 | 2023-11-20 06:41:15+00:00 | 24k |
shercoo/RGDiffSR | ldm/models/diffusion/ddpm.py | [
{
"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 ... | import datetime
import math
import cv2
import torch
import torch.nn as nn
import numpy as np
import pytorch_lightning as pl
import pygame
from collections import OrderedDict
from matplotlib import pyplot as plt
from torch.optim.lr_scheduler import LambdaLR
from einops import rearrange, repeat
from contextlib import contextmanager
from functools import partial
from torchvision import transforms
from tqdm import tqdm
from torchvision.utils import make_grid
from pytorch_lightning.utilities.distributed import rank_zero_only
from ldm.util import log_txt_as_img, exists, default, ismap, isimage, mean_flat, count_params, instantiate_from_config
from ldm.modules.ema import LitEma
from ldm.modules.distributions.distributions import normal_kl, DiagonalGaussianDistribution
from ldm.models.autoencoder import VQModelInterface, IdentityFirstStage, AutoencoderKL
from ldm.modules.diffusionmodules.util import make_beta_schedule, extract_into_tensor, noise_like
from ldm.models.diffusion.ddim import DDIMSampler
from text_super_resolution.model.VisionLAN.utils import Attention_AR_counter
from text_super_resolution.model.tps_spatial_transformer import TPSSpatialTransformer
from text_super_resolution.model.stn_head import STNHead
from text_super_resolution.model.VisionLAN.VisionLAN import VisionLAN
from utils.render_standard_text import *
from text_super_resolution.loss.semantic_loss import SemanticLoss
from text_super_resolution.utils import ssim_psnr
from pygame import freetype
from utils.metrics import * | 14,578 | if mask is not None:
img_orig = self.q_sample(x0, ts)
img = img_orig * mask + (1. - mask) * img
if i % log_every_t == 0 or i == timesteps - 1:
intermediates.append(img)
if callback: callback(i)
if img_callback: img_callback(img, i)
if return_intermediates:
return img, intermediates
return img
@torch.no_grad()
def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None,
verbose=True, timesteps=None, quantize_denoised=False,
mask=None, x0=None, shape=None, **kwargs):
if shape is None:
shape = (batch_size, self.channels, self.image_size, self.image_size)
if cond is not None:
if isinstance(cond, dict):
cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
else:
cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
return self.p_sample_loop(cond,
shape,
return_intermediates=return_intermediates, x_T=x_T,
verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised,
mask=mask, x0=x0)
@torch.no_grad()
def sample_log(self, cond, batch_size, ddim, ddim_steps, **kwargs):
if ddim:
ddim_sampler = DDIMSampler(self)
# print(cond.shape)
if self.text_prior_enable:
if isinstance(cond, dict):
shape = (self.channels, cond['c_concat'][0].shape[2], cond['c_concat'][0].shape[3])
elif isinstance(cond, list):
shape = (self.channels, cond[0].shape[2], cond[0].shape[3])
else:
shape = (self.channels, cond.shape[2], cond.shape[3])
else:
shape = (self.channels, cond.shape[2], cond.shape[3])
# shape = (self.channels, self.image_size, self.image_size)
samples, intermediates = ddim_sampler.sample(ddim_steps, batch_size,
shape, cond, verbose=False, **kwargs)
else:
samples, intermediates = self.sample(cond=cond, batch_size=batch_size,
return_intermediates=True, **kwargs)
return samples, intermediates
@torch.no_grad()
def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None,
quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,
plot_diffusion_rows=True, **kwargs):
use_ddim = ddim_steps is not None
log = dict()
z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key,
return_first_stage_outputs=True,
force_c_encode=True,
return_original_cond=True,
bs=N)
# print('**********************c shape',c.shape)
N = min(x.shape[0], N)
n_row = min(x.shape[0], n_row)
log["inputs"] = x
log["reconstruction"] = xrec
if self.model.conditioning_key is not None:
if hasattr(self.cond_stage_model, "decode"):
xc = self.cond_stage_model.decode(c)
log["conditioning"] = xc
elif self.cond_stage_key in ["caption"]:
xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["caption"])
log["conditioning"] = xc
elif self.cond_stage_key == 'class_label':
xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"])
log['conditioning'] = xc
elif isimage(xc):
log["conditioning"] = xc
if ismap(xc):
log["original_conditioning"] = self.to_rgb(xc)
if plot_diffusion_rows:
# get diffusion row
diffusion_row = list()
z_start = z[: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(z_start)
z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)
diffusion_row.append(self.decode_first_stage(z_noisy))
diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W
diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')
diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')
diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])
log["diffusion_row"] = diffusion_grid
if sample:
# get denoise row
with self.ema_scope("Plotting"):
samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,
ddim_steps=ddim_steps, eta=ddim_eta)
# samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)
x_samples = self.decode_first_stage(samples)
log["samples"] = x_samples
if plot_denoise_rows:
denoise_grid = self._get_denoise_row_from_list(z_denoise_row)
log["denoise_row"] = denoise_grid
| """
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
-- merci
"""
__conditioning_keys__ = {'concat': 'c_concat',
'crossattn': 'c_crossattn',
'adm': 'y'}
sem_loss = SemanticLoss()
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 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.,
):
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
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)
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")
print(sd.keys())
print(sd['epoch'])
print(sd['global_step'])
print(sd['callbacks'])
# print(sd['optimizer_states'])
# print(sd['lr_schedulers'])
# print(sd['state_dict'].keys())
# exit(0)
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}")
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):
# print('************************fuck',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
def training_step(self, batch, batch_idx):
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):
# print('******************************in validation')
_, 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)
def on_train_batch_end(self, *args, **kwargs):
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,
text_prior_enable=False,
image_height=32,
image_width=128,
STN_enable=False,
standard_text=False,
VL_pretrained_path=None,
fid_eval=False,
visualize=False,
down_sample_rate=2,
recog_loss_enable=False,
font_path=None,
*args, **kwargs):
self.fid_eval = fid_eval
self.visualize = visualize
self.text_prior_enable = text_prior_enable
self.recog_loss_enable = recog_loss_enable
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.instantiate_first_stage(first_stage_config)
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
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys)
self.restarted_from_ckpt = True
self.image_height = image_height
self.image_width = image_width
self.stn = STN_enable
if self.stn:
self.tps_inputsize = [image_height // down_sample_rate, image_width // down_sample_rate]
tps_outputsize = [image_height // down_sample_rate, image_width // down_sample_rate]
num_control_points = 20
tps_margins = [0.05, 0.05]
self.tps = TPSSpatialTransformer(
output_image_size=tuple(tps_outputsize),
num_control_points=num_control_points,
margins=tuple(tps_margins))
self.stn_head = STNHead(
in_planes=3,
num_ctrlpoints=num_control_points,
activation='none',
input_size=self.tps_inputsize)
self.standard_text = standard_text
if self.standard_text:
# self.VL_model = self.VisionLAN_init(VL_pretrained_path)
# self.test_acc_counter = Attention_AR_counter('\ntest accuracy: ',
# '/home/zhouyuxuan/latent-diffusion/dic_36.txt', False)
self.font_path = font_path
pygame.init()
freetype.init()
self.cal_psnr = ssim_psnr.calculate_psnr
self.cal_ssim = ssim_psnr.SSIM()
def VisionLAN_init(self, path=None):
cfg = {'args': {
'strides': [(1, 1), (2, 2), (2, 2), (2, 2), (1, 1), (1, 1)],
'input_shape': [3, 64, 256], # C x H x W
},
'init_state_dict': '/home/zhouyuxuan/latent-diffusion/visionlan.pth', }
model_VL = VisionLAN(**cfg['args'])
model_path = cfg['init_state_dict'] if path is None else path
print('load pre_trained VisionLAN model from %s' % model_path)
model_VL = model_VL.to(self.device)
model_VL = nn.DataParallel(model_VL)
if cfg['init_state_dict'] != None:
fe_state_dict_ori = torch.load(model_path)
fe_state_dict = OrderedDict()
for k, v in fe_state_dict_ori.items():
if 'module' not in k:
k = 'module.' + k
else:
k = k.replace('features.module.', 'module.features.')
fe_state_dict[k] = v
model_dict_fe = model_VL.state_dict()
state_dict_fe = {k: v for k, v in fe_state_dict.items() if k in model_dict_fe.keys()}
model_dict_fe.update(state_dict_fe)
model_VL.load_state_dict(model_dict_fe)
return model_VL
def parse_visionlan_data(self, imgs_input):
imgs_input = transforms.ToPILImage()(imgs_input).convert('RGB')
imgs_input = cv2.resize(np.array(imgs_input), (256, 64))
imgs_input = transforms.ToTensor()(imgs_input).unsqueeze(0)
imgs_input = imgs_input.to(self.device)
return imgs_input
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
def on_save_checkpoint(self, checkpoint):
if not isinstance(self.cond_stage_model, torch.nn.Identity):
self.cond_stage_model.save_state_dict(
'/home/zhouyuxuan/latent-diffusion/crnn_ckpt/', self.current_epoch)
@rank_zero_only
@torch.no_grad()
def on_train_batch_start(self, batch, batch_idx, dataloader_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):
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
# print(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[1] * 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)
# print('weighting',weighting.shape,Ly,Lx)
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[1] // 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 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))
if self.text_prior_enable:
c = self.get_additional_cond(xc, c)
# c = {'c_concat': [xc], 'c_crossattn': [c]}
else:
c = xc
if bs is not None:
if isinstance(c, dict):
for k, v in c.items():
c[k] = [v[0][:bs]]
else:
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]
# print('fuck',c.shape)
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 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
print('decode z shape', 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")
print(ks, stride, uf)
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
print('encode x shape', x.shape)
print('ks', ks, 'stride', stride, 'df', df)
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 )
print('encode z shape', z.shape)
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 on_validation_start(self) -> None:
print(f'******************************in validation {self.current_epoch}')
def validation_step(self, batch, batch_idx):
# print('******************************in validation')
_, 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)
if self.fid_eval and self.current_epoch % 10 == 0:
results = self.recognize_sample(batch, N=114514, inpaint=False)
rec_image = results['samples']
target = batch[self.first_stage_key]
target = rearrange(target, 'b h w c -> b c h w')
cond = batch[self.cond_stage_key]
cond = rearrange(cond, 'b h w c -> b c h w')
if self.visualize:
batchlen = rec_image.shape[0]
rc = int(math.sqrt(batchlen))
f, axs = plt.subplots(rc, rc, figsize=(16, 4), sharex=True, sharey=True)
plt.subplots_adjust(wspace=0, hspace=0)
print(len(axs), batchlen, int(math.sqrt(batchlen)))
assert len(axs) ** 2 == batchlen
for i in range(batchlen):
axs[i // rc, i % rc].set_xticklabels([])
axs[i // rc, i % rc].set_yticklabels([])
axs[i // rc, i % rc].set_aspect('equal')
axs[i // rc, i % rc].imshow(rec_image[i, :3, :, :].cpu().numpy().transpose(1, 2, 0))
axs[i // rc, i % rc].axis('off')
plt.savefig(f'/home/zhouyuxuan/res/sample_{batch_idx}.jpg')
plt.cla()
f, axs = plt.subplots(rc, rc, figsize=(16, 4), sharex=True, sharey=True)
plt.subplots_adjust(wspace=0, hspace=0)
for i in range(batchlen):
axs[i // rc, i % rc].imshow(target[i, :3, :, :].cpu().numpy().transpose(1, 2, 0))
axs[i // rc, i % rc].axis('off')
plt.savefig(f'/home/zhouyuxuan/res/target_{batch_idx}.jpg')
plt.cla()
f, axs = plt.subplots(rc, rc, figsize=(16, 4), sharex=True, sharey=True)
plt.subplots_adjust(wspace=0, hspace=0)
for i in range(batchlen):
axs[i // rc, i % rc].imshow(cond[i, :3, :, :].cpu().numpy().transpose(1, 2, 0))
axs[i // rc, i % rc].axis('off')
plt.savefig(f'/home/zhouyuxuan/res/input_{batch_idx}.jpg')
PSNR = self.cal_psnr(rec_image[:, :3], target[:, :3])
SSIM = self.cal_ssim(rec_image[:, :3], target[:, :3])
self.log_dict({'PSNR': PSNR, 'SSIM': SSIM}, prog_bar=False, logger=True, on_step=False, on_epoch=True)
def shared_step(self, batch, **kwargs):
# print('*******************************************************batch',batch['image'].shape)
# print('*******************************************************batch',batch['image'].shape)
# if hasattr(self, "split_input_params"):
# print(self.split_input_params)
# else:
# print('fuck')
x, c = self.get_input(batch, self.first_stage_key)
loss, loss_dict = self(x, c)
if self.recog_loss_enable:
HR = batch['image']
HR = rearrange(HR, 'b h w c -> b c h w')
HR = HR.to(memory_format=torch.contiguous_format).float()
LR = c
label_vecs = self.get_learned_conditioning(c).permute(1, 0, 2)
label_vecs_hr = self.get_learned_conditioning(HR).permute(1, 0, 2)
loss_recog_distill = sem_loss(label_vecs, label_vecs_hr) * 100 # 100
loss = loss + loss_recog_distill
loss_dict.update({f'loss_recog': loss_recog_distill})
# return loss + loss_recog_distill, loss_dict
#
# else:
return loss, loss_dict
def get_additional_cond(self, c, tp):
if self.stn:
_, ctrl_points_c = self.stn_head(c)
c, _ = self.tps(c, ctrl_points_c)
if self.standard_text:
x_q = torch.empty(1, 2, c.shape[2], c.shape[3])
# prob_lr = torch.empty(1, 25, 37)
rec_results = get_string_crnn(tp.permute(1, 0, 2), False)
for i in range(c.shape[0]):
# visionlan_dict_lr = self.parse_visionlan_data(c[i, :3, :, :])
# target = ''
# label_lr, label_length = self.VL_model(visionlan_dict_lr, target, '', False)
# pred_str_lr, pred_prob = self.test_acc_counter.convert(label_lr, label_length)
# s = pred_str_lr[0]
# prob_lr = torch.cat([prob_lr, pred_prob], dim=0)
s = rec_results[i]
if s == "" or type(s) == torch.Tensor:
s = "\t"
lower_case = s.lower()
upper_case = s.upper()
i_t_lower = make_standard_text(self.font_path, lower_case,
(c.shape[2], c.shape[3]))
i_t_lower_tensor = torch.from_numpy(i_t_lower).unsqueeze(0).unsqueeze(0)
i_t_upper = make_standard_text(self.font_path, upper_case,
(c.shape[2], c.shape[3]))
i_t_upper_tensor = torch.from_numpy(i_t_upper).unsqueeze(0).unsqueeze(0)
i_t_tensor = torch.cat([i_t_lower_tensor, i_t_upper_tensor], dim=1)
x_q = torch.cat([x_q, i_t_tensor], dim=0)
x_q = x_q[1:]
# prob_lr = prob_lr[1:]
x_q = x_q.to(self.device)
# prob_lr = prob_lr.to(self.device)
c = torch.cat([c, x_q], dim=1)
return {'c_concat': [c], 'c_crossattn': [tp]}
def forward(self, x, c, *args, **kwargs):
t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
if self.model.conditioning_key is not None:
assert c is not None
if self.text_prior_enable and self.model.conditioning_key == 'hybrid':
tp = self.get_learned_conditioning(c)
c = self.get_additional_cond(c, tp)
else:
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:]
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")
# print('ddpm','x_noisy shape',x_noisy.shape,'ks',ks,'stride',stride)
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'] 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)
def p_losses(self, x_start, cond, 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_output = self.apply_model(x_noisy, t, cond)
loss_dict = {}
prefix = 'train' if self.training else 'val'
if self.parameterization == "x0":
target = x_start
elif self.parameterization == "eps":
target = noise
else:
raise NotImplementedError()
loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3])
loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()})
self.logvar = self.logvar.to(self.device)
logvar_t = self.logvar[t].to(self.device)
loss = loss_simple / torch.exp(logvar_t) + logvar_t
# loss = loss_simple / torch.exp(self.logvar) + self.logvar
if self.learn_logvar:
loss_dict.update({f'{prefix}/loss_gamma': loss.mean()})
loss_dict.update({'logvar': self.logvar.data.mean()})
loss = self.l_simple_weight * loss.mean()
loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3))
loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean()
loss_dict.update({f'{prefix}/loss_vlb': loss_vlb})
loss += (self.original_elbo_weight * loss_vlb)
loss_dict.update({f'{prefix}/loss': loss})
return loss, loss_dict
def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False,
return_x0=False, score_corrector=None, corrector_kwargs=None):
t_in = t
model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids)
if score_corrector is not None:
assert self.parameterization == "eps"
model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs)
if return_codebook_ids:
model_out, logits = model_out
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
else:
raise NotImplementedError()
if clip_denoised:
x_recon.clamp_(-1., 1.)
if quantize_denoised:
x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon)
model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
if return_codebook_ids:
return model_mean, posterior_variance, posterior_log_variance, logits
elif return_x0:
return model_mean, posterior_variance, posterior_log_variance, x_recon
else:
return model_mean, posterior_variance, posterior_log_variance
@torch.no_grad()
def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False,
return_codebook_ids=False, quantize_denoised=False, return_x0=False,
temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None):
b, *_, device = *x.shape, x.device
outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised,
return_codebook_ids=return_codebook_ids,
quantize_denoised=quantize_denoised,
return_x0=return_x0,
score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
if return_codebook_ids:
raise DeprecationWarning("Support dropped.")
model_mean, _, model_log_variance, logits = outputs
elif return_x0:
model_mean, _, model_log_variance, x0 = outputs
else:
model_mean, _, model_log_variance = outputs
noise = noise_like(x.shape, device, repeat_noise) * temperature
if noise_dropout > 0.:
noise = torch.nn.functional.dropout(noise, p=noise_dropout)
# no noise when t == 0
nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
if return_codebook_ids:
return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1)
if return_x0:
return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0
else:
return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
@torch.no_grad()
def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False,
img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0.,
score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None,
log_every_t=None):
if not log_every_t:
log_every_t = self.log_every_t
timesteps = self.num_timesteps
if batch_size is not None:
b = batch_size if batch_size is not None else shape[0]
shape = [batch_size] + list(shape)
else:
b = batch_size = shape[0]
if x_T is None:
img = torch.randn(shape, device=self.device)
else:
img = x_T
intermediates = []
if cond is not None:
if isinstance(cond, dict):
cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
else:
cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
if start_T is not None:
timesteps = min(timesteps, start_T)
iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation',
total=timesteps) if verbose else reversed(
range(0, timesteps))
if type(temperature) == float:
temperature = [temperature] * timesteps
for i in iterator:
ts = torch.full((b,), i, device=self.device, dtype=torch.long)
if self.shorten_cond_schedule:
assert self.model.conditioning_key != 'hybrid'
tc = self.cond_ids[ts].to(cond.device)
cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
img, x0_partial = self.p_sample(img, cond, ts,
clip_denoised=self.clip_denoised,
quantize_denoised=quantize_denoised, return_x0=True,
temperature=temperature[i], noise_dropout=noise_dropout,
score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
if mask is not None:
assert x0 is not None
img_orig = self.q_sample(x0, ts)
img = img_orig * mask + (1. - mask) * img
if i % log_every_t == 0 or i == timesteps - 1:
intermediates.append(x0_partial)
if callback: callback(i)
if img_callback: img_callback(img, i)
return img, intermediates
@torch.no_grad()
def p_sample_loop(self, cond, shape, return_intermediates=False,
x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False,
mask=None, x0=None, img_callback=None, start_T=None,
log_every_t=None):
if not log_every_t:
log_every_t = self.log_every_t
device = self.betas.device
b = shape[0]
if x_T is None:
img = torch.randn(shape, device=device)
else:
img = x_T
intermediates = [img]
if timesteps is None:
timesteps = self.num_timesteps
if start_T is not None:
timesteps = min(timesteps, start_T)
iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed(
range(0, timesteps))
if mask is not None:
assert x0 is not None
assert x0.shape[2:3] == mask.shape[2:3] # spatial size has to match
for i in iterator:
ts = torch.full((b,), i, device=device, dtype=torch.long)
if self.shorten_cond_schedule:
assert self.model.conditioning_key != 'hybrid'
tc = self.cond_ids[ts].to(cond.device)
cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
img = self.p_sample(img, cond, ts,
clip_denoised=self.clip_denoised,
quantize_denoised=quantize_denoised)
if mask is not None:
img_orig = self.q_sample(x0, ts)
img = img_orig * mask + (1. - mask) * img
if i % log_every_t == 0 or i == timesteps - 1:
intermediates.append(img)
if callback: callback(i)
if img_callback: img_callback(img, i)
if return_intermediates:
return img, intermediates
return img
@torch.no_grad()
def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None,
verbose=True, timesteps=None, quantize_denoised=False,
mask=None, x0=None, shape=None, **kwargs):
if shape is None:
shape = (batch_size, self.channels, self.image_size, self.image_size)
if cond is not None:
if isinstance(cond, dict):
cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
else:
cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
return self.p_sample_loop(cond,
shape,
return_intermediates=return_intermediates, x_T=x_T,
verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised,
mask=mask, x0=x0)
@torch.no_grad()
def sample_log(self, cond, batch_size, ddim, ddim_steps, **kwargs):
if ddim:
ddim_sampler = DDIMSampler(self)
# print(cond.shape)
if self.text_prior_enable:
if isinstance(cond, dict):
shape = (self.channels, cond['c_concat'][0].shape[2], cond['c_concat'][0].shape[3])
elif isinstance(cond, list):
shape = (self.channels, cond[0].shape[2], cond[0].shape[3])
else:
shape = (self.channels, cond.shape[2], cond.shape[3])
else:
shape = (self.channels, cond.shape[2], cond.shape[3])
# shape = (self.channels, self.image_size, self.image_size)
samples, intermediates = ddim_sampler.sample(ddim_steps, batch_size,
shape, cond, verbose=False, **kwargs)
else:
samples, intermediates = self.sample(cond=cond, batch_size=batch_size,
return_intermediates=True, **kwargs)
return samples, intermediates
@torch.no_grad()
def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None,
quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,
plot_diffusion_rows=True, **kwargs):
use_ddim = ddim_steps is not None
log = dict()
z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key,
return_first_stage_outputs=True,
force_c_encode=True,
return_original_cond=True,
bs=N)
# print('**********************c shape',c.shape)
N = min(x.shape[0], N)
n_row = min(x.shape[0], n_row)
log["inputs"] = x
log["reconstruction"] = xrec
if self.model.conditioning_key is not None:
if hasattr(self.cond_stage_model, "decode"):
xc = self.cond_stage_model.decode(c)
log["conditioning"] = xc
elif self.cond_stage_key in ["caption"]:
xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["caption"])
log["conditioning"] = xc
elif self.cond_stage_key == 'class_label':
xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"])
log['conditioning'] = xc
elif isimage(xc):
log["conditioning"] = xc
if ismap(xc):
log["original_conditioning"] = self.to_rgb(xc)
if plot_diffusion_rows:
# get diffusion row
diffusion_row = list()
z_start = z[: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(z_start)
z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)
diffusion_row.append(self.decode_first_stage(z_noisy))
diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W
diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')
diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')
diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])
log["diffusion_row"] = diffusion_grid
if sample:
# get denoise row
with self.ema_scope("Plotting"):
samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,
ddim_steps=ddim_steps, eta=ddim_eta)
# samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)
x_samples = self.decode_first_stage(samples)
log["samples"] = x_samples
if plot_denoise_rows:
denoise_grid = self._get_denoise_row_from_list(z_denoise_row)
log["denoise_row"] = denoise_grid
| if quantize_denoised and not isinstance(self.first_stage_model, AutoencoderKL) and not isinstance( | 13 | 2023-11-20 06:34:21+00:00 | 24k |
microsoft/Project-BayesDAG | src/causica/models/pvae_base_model.py | [
{
"identifier": "Dataset",
"path": "src/causica/datasets/dataset.py",
"snippet": "class Dataset(BaseDataset):\n \"\"\"\n Class to store dense train/val/test data and masks and variables metadata.\n Note that the data and masks provided by this class are read only.\n \"\"\"\n\n def __init_... | from abc import abstractmethod
from typing import Any, Callable, Dict, Optional, Tuple, Union, cast
from scipy.sparse import csr_matrix, issparse
from tqdm import tqdm
from ..datasets.dataset import Dataset, SparseDataset
from ..datasets.variables import Variables
from ..objectives.eddi import EDDIObjective
from ..utils.data_mask_utils import restore_preserved_values, sample_inducing_points
from ..utils.helper_functions import to_tensors
from ..utils.torch_utils import create_dataloader
from ..utils.training_objectives import gaussian_negative_log_likelihood, negative_log_likelihood
from .imodel import IModelForObjective
from .torch_imputation import impute
from .torch_model import TorchModel
from .torch_training_types import LossConfig
import numpy as np
import torch | 20,613 | self: PVAEBaseModel,
data: np.ndarray,
feature_mask: np.ndarray,
target_idx,
sample_count: int = 50,
):
"""
Computes the predictive log-likelihood of the target-data given the feature_mask-masked data as input.
Args:
data (Numpy array of shape (batch_size, feature_count)): Data in unprocessed form to be used to
compute the pll.
feature_mask (Numpy array of shape (batch_size, feature_count)): Mask indicating conditioning
variables for computing the predictive log-likelihood.
target_idx (int): Column index of target variable for compute the likelihood of.
sample_count (int): Number of Monte Carlo samples to use from the latent space. Defaults to 50.
Returns:
predictive_ll (float): Mean predictive log-likelihood (mean taken over batch dim in data).
"""
# Process input data
(
proc_feature_data_array,
proc_feature_mask_array,
) = self.data_processor.process_data_and_masks(data, feature_mask)
proc_feature_data, proc_feature_mask = to_tensors(
proc_feature_data_array, proc_feature_mask_array, device=self.device
)
# Create target_mask from target_index
target_mask = np.zeros_like(data, dtype=bool)
target_mask[:, target_idx] = 1
# Process target data
(
proc_target_data_array,
proc_target_mask_array,
) = self.data_processor.process_data_and_masks(data, target_mask)
proc_target_data, proc_target_mask = to_tensors(
proc_target_data_array, proc_target_mask_array, device=self.device
)
# Expand target data and mask to be shape (sample_count, batch_size, feature_count)
proc_target_data = proc_target_data.expand(sample_count, *proc_target_data.shape)
proc_target_mask = proc_target_mask.expand(sample_count, *proc_target_mask.shape)
# Compute PVAE outputs given input features (parameters of the Gaussian mixture)
(dec_mean, dec_logvar), _, _ = self.reconstruct(proc_feature_data, proc_feature_mask, count=sample_count)
# Compute Gaussian negative log-likelihood per sample in sample_count
gnll = gaussian_negative_log_likelihood(
proc_target_data, dec_mean, dec_logvar, mask=proc_target_mask, sum_type=None
)
gnll = gnll[:, :, target_idx]
predictive_ll = -gnll
predictive_ll = torch.logsumexp(predictive_ll, dim=0) - np.log(sample_count)
predictive_ll = predictive_ll.mean()
return predictive_ll
def get_marginal_log_likelihood(
self,
impute_config: Dict[str, int],
data: Union[np.ndarray, csr_matrix],
observed_mask: Optional[Union[np.ndarray, csr_matrix]] = None,
target_mask: Optional[Union[np.ndarray, csr_matrix]] = None,
evaluate_imputation: Optional[bool] = False,
num_importance_samples: int = 5000,
**kwargs,
) -> float:
"""
Estimate marginal log-likelihood of the data using importance sampling:
- Imputation MLL -> imputed data given the observed data log p(x_u|x_o) if evaluate_imputation is True
- Reconstruction MLL -> all data log p(x) otherwise
Args:
impute_config: Dictionary containing options for inference.
data: Data in unprocessed form to be used with shape (num_rows, input_dim).
mask: If not None, mask indicating observed variables with shape (num_rows, input_dim). 1 is observed,
0 is un-observed. If None everything is marked as observed.
target_mask: Values masked during imputation to use as prediction targets, where 1 is a target, 0 is not.
If None, nothing is marked as an imputation target.
evaluate_imputation: Whether to estimate Imputation MLL log p(x_u|x_o) or Reconstruction MLL log p(x).
num_importance_samples: The number of importance samples to be taken.
**kwargs: Extra keyword arguments required by reconstruct.
Returns:
marginal_log_likelihood: The estimated marginal log likelihood averaged across data points.
"""
# TODO(17895): Add Generation MLL option to the marginal log-likelihood metric.
batch_size = impute_config["batch_size"]
# Assumed to only work on dense arrays for now
if issparse(data):
data = cast(csr_matrix, data)
data = data.toarray()
if issparse(observed_mask):
observed_mask = cast(csr_matrix, observed_mask)
observed_mask = observed_mask.toarray()
if issparse(target_mask):
target_mask = cast(csr_matrix, target_mask)
target_mask = target_mask.toarray()
if observed_mask is None:
observed_mask = np.ones_like(data, dtype=bool)
if target_mask is None:
assert not evaluate_imputation
target_mask = np.zeros_like(data, dtype=bool)
assert data.shape == observed_mask.shape
assert data.shape == target_mask.shape
num_rows, _ = data.shape
# TODO(17896): Add processing and batching of extra data objects
processed_data, processed_obs_mask, processed_target_mask = self.data_processor.process_data_and_masks(
data, observed_mask, target_mask
)
marginal_log_likelihood = np.empty((num_rows,), dtype=processed_data.dtype)
with torch.no_grad():
| # This is required in python 3 to allow return types of the same class.
from __future__ import annotations
EPSILON = 1e-5
class PVAEBaseModel(TorchModel, IModelForObjective):
"""
Abstract model class.
To instantiate this class, these functions need to be implemented:
_train: Run the training loop for the model.
_impute: Fill in any missing values for test data.
_reconstruct: Reconstruct data by passing them through the VAE
name: Name of model implementation.
"""
def __init__(self, model_id: str, variables: Variables, save_dir: str, device: torch.device) -> None:
"""
Args:
model_id: Unique model ID for referencing this model instance.
variables: Information about variables/features used by this model.
save_dir: Location to save any information about this model, including training data.
It will be created if it doesn't exist.
device: Name of Torch device to create the model on. Valid options are 'cpu', 'gpu', or a device ID
(e.g. 0 or 1 on a two-GPU machine).
"""
super().__init__(model_id, variables, save_dir, device)
self._alpha = 1.0 # The default value for the categorical likelihood coefficient.
@staticmethod
def _split_vamp_prior_config(training_config: Dict[str, Any]) -> Tuple[dict, dict]:
# Split training config into (training_config, vamp_prior_config)
training_config = training_config.copy()
vamp_prior_config = {"save_vamp_prior": training_config.pop("save_vamp_prior")}
for k in ["vamp_prior_reward_samples", "vamp_prior_inducing_points"]:
vamp_prior_config.update({k: training_config.pop(k, None)})
return training_config, vamp_prior_config
def _save_vamp_prior(
self,
processed_dataset: Union[Dataset, SparseDataset],
save_vamp_prior: bool,
vamp_prior_inducing_points: Optional[int] = None,
vamp_prior_reward_samples: Optional[int] = None,
) -> None:
if not save_vamp_prior:
return
assert vamp_prior_inducing_points is not None
assert vamp_prior_reward_samples is not None
train_data, train_mask = processed_dataset.train_data_and_mask
vamp_prior_data = sample_inducing_points(train_data, train_mask, row_count=vamp_prior_inducing_points)
vamp_prior_data = cast(Union[Tuple[np.ndarray, np.ndarray], Tuple[csr_matrix, csr_matrix]], vamp_prior_data)
EDDIObjective.calc_and_save_vamp_prior_info_gain(self, vamp_prior_data, sample_count=vamp_prior_reward_samples)
def run_train(
self,
dataset: Union[Dataset, SparseDataset],
train_config_dict: Optional[Dict[str, Any]] = None,
report_progress_callback: Optional[Callable[[str, int, int], None]] = None,
) -> None:
"""
Train the model.
Training results will be saved.
Args:
dataset: Dataset object with data and masks in unprocessed form.
train_config_dict (dictionary): Any other parameters needed by a specific concrete class. Of
the form {arg_name: arg_value}. e.g. {"learning_rate": 1e-3, "epochs": 100}
report_progress_callback: Function to report model progress for API.
"""
if train_config_dict is None:
train_config_dict = {}
train_config_dict, vamp_prior_config = self._split_vamp_prior_config(train_config_dict)
processed_dataset = self.data_processor.process_dataset(dataset)
self._train(
dataset=processed_dataset,
report_progress_callback=report_progress_callback,
**train_config_dict,
)
self._save_vamp_prior(processed_dataset, **vamp_prior_config)
@abstractmethod
def _train(self, *args, **kwargs):
pass
def impute(self, data, mask, impute_config_dict=None, *, vamp_prior_data=None, average=True):
if vamp_prior_data is None:
return impute(self, data, mask, impute_config_dict=impute_config_dict, average=average)
else:
processed_vamp_data_array = self.data_processor.process_data_and_masks(*vamp_prior_data)
# Keep processed VampPrior data on CPU until we sample inducing points, as this data can be large and is
# not required for any CUDA computations.
return impute(
self,
data,
mask,
impute_config_dict=impute_config_dict,
average=average,
vamp_prior_data=to_tensors(*processed_vamp_data_array, device=torch.device("cpu")),
)
def impute_processed_batch(
self: PVAEBaseModel,
data: torch.Tensor,
mask: torch.Tensor,
*,
sample_count: int,
preserve_data: bool = True,
vamp_prior_data: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
**kwargs,
) -> torch.Tensor:
"""
Fill in unobserved variables in a minibatch of data using a trained model. Optionally, use a vamp prior to
impute empty rows, and optionally replace imputed values with input values for observed features.
Assumes data is a torch.Tensor and in processed form (i.e. variables will be in their squashed ranges,
and categorical variables will be in one-hot form).
Args:
data (shape (batch_size, input_dim)): Data to be used to train the model, in processed form.
mask (shape (batch_size, input_dim)): Data observation mask, where observed values are 1 and unobserved
values are 0.
sample_count: Number of imputation samples to generate.
vamp_prior_data (Tuple of (torch tensor, torch tensor)): Data to be used to fill variables if using the VAMP
prior method. Format: (data, mask). This defaults to None, in which case the VAMP Prior method will not
be used.
preserve_data (bool): Whether or not to impute data already present. Defaults to True, which keeps data
present in input.
Returns:
imputations (torch.Tensor of shape (sample_count, batch_size, output_dim)): Input data with missing values
filled in.
"""
if not isinstance(data, torch.Tensor) or not isinstance(mask, torch.Tensor):
raise ValueError("data and mask should be tensors. To work on ndarrays, use impute")
assert data.shape == mask.shape
assert data.shape[1] == self.input_dim
batch_size, num_features = data.shape
if self.variables.has_auxiliary:
num_features = self.variables.num_processed_non_aux_cols
imputations = torch.full((sample_count, batch_size, num_features), np.nan, device=self.device)
# vamp_rows are rows where input is completely unobserved
vamp_rows = torch.where(mask.sum(dim=1) == 0)[0]
if vamp_prior_data is not None and vamp_rows.numel() > 0:
imputed_from_vamp = self._impute_from_vamp_prior(sample_count * vamp_rows.numel(), vamp_prior_data)
imputed_from_vamp = imputed_from_vamp.reshape(sample_count, vamp_rows.numel(), -1)
imputations[:, vamp_rows, :] = imputed_from_vamp
not_vamp_rows = torch.where(mask.sum(dim=1) != 0)[0]
else:
not_vamp_rows = torch.arange(batch_size)
if len(not_vamp_rows) > 0:
not_vamp_data = data[not_vamp_rows]
not_vamp_mask = mask[not_vamp_rows]
imputed_not_vamp_data = self._reconstruct_and_reshape(
not_vamp_data, not_vamp_mask, sample_count=sample_count, **kwargs
)
imputations[:, not_vamp_rows, :] = imputed_not_vamp_data
if preserve_data:
imputations = restore_preserved_values(self.variables, data, imputations, mask)
return imputations
def get_model_pll(
self: PVAEBaseModel,
data: np.ndarray,
feature_mask: np.ndarray,
target_idx,
sample_count: int = 50,
):
"""
Computes the predictive log-likelihood of the target-data given the feature_mask-masked data as input.
Args:
data (Numpy array of shape (batch_size, feature_count)): Data in unprocessed form to be used to
compute the pll.
feature_mask (Numpy array of shape (batch_size, feature_count)): Mask indicating conditioning
variables for computing the predictive log-likelihood.
target_idx (int): Column index of target variable for compute the likelihood of.
sample_count (int): Number of Monte Carlo samples to use from the latent space. Defaults to 50.
Returns:
predictive_ll (float): Mean predictive log-likelihood (mean taken over batch dim in data).
"""
# Process input data
(
proc_feature_data_array,
proc_feature_mask_array,
) = self.data_processor.process_data_and_masks(data, feature_mask)
proc_feature_data, proc_feature_mask = to_tensors(
proc_feature_data_array, proc_feature_mask_array, device=self.device
)
# Create target_mask from target_index
target_mask = np.zeros_like(data, dtype=bool)
target_mask[:, target_idx] = 1
# Process target data
(
proc_target_data_array,
proc_target_mask_array,
) = self.data_processor.process_data_and_masks(data, target_mask)
proc_target_data, proc_target_mask = to_tensors(
proc_target_data_array, proc_target_mask_array, device=self.device
)
# Expand target data and mask to be shape (sample_count, batch_size, feature_count)
proc_target_data = proc_target_data.expand(sample_count, *proc_target_data.shape)
proc_target_mask = proc_target_mask.expand(sample_count, *proc_target_mask.shape)
# Compute PVAE outputs given input features (parameters of the Gaussian mixture)
(dec_mean, dec_logvar), _, _ = self.reconstruct(proc_feature_data, proc_feature_mask, count=sample_count)
# Compute Gaussian negative log-likelihood per sample in sample_count
gnll = gaussian_negative_log_likelihood(
proc_target_data, dec_mean, dec_logvar, mask=proc_target_mask, sum_type=None
)
gnll = gnll[:, :, target_idx]
predictive_ll = -gnll
predictive_ll = torch.logsumexp(predictive_ll, dim=0) - np.log(sample_count)
predictive_ll = predictive_ll.mean()
return predictive_ll
def get_marginal_log_likelihood(
self,
impute_config: Dict[str, int],
data: Union[np.ndarray, csr_matrix],
observed_mask: Optional[Union[np.ndarray, csr_matrix]] = None,
target_mask: Optional[Union[np.ndarray, csr_matrix]] = None,
evaluate_imputation: Optional[bool] = False,
num_importance_samples: int = 5000,
**kwargs,
) -> float:
"""
Estimate marginal log-likelihood of the data using importance sampling:
- Imputation MLL -> imputed data given the observed data log p(x_u|x_o) if evaluate_imputation is True
- Reconstruction MLL -> all data log p(x) otherwise
Args:
impute_config: Dictionary containing options for inference.
data: Data in unprocessed form to be used with shape (num_rows, input_dim).
mask: If not None, mask indicating observed variables with shape (num_rows, input_dim). 1 is observed,
0 is un-observed. If None everything is marked as observed.
target_mask: Values masked during imputation to use as prediction targets, where 1 is a target, 0 is not.
If None, nothing is marked as an imputation target.
evaluate_imputation: Whether to estimate Imputation MLL log p(x_u|x_o) or Reconstruction MLL log p(x).
num_importance_samples: The number of importance samples to be taken.
**kwargs: Extra keyword arguments required by reconstruct.
Returns:
marginal_log_likelihood: The estimated marginal log likelihood averaged across data points.
"""
# TODO(17895): Add Generation MLL option to the marginal log-likelihood metric.
batch_size = impute_config["batch_size"]
# Assumed to only work on dense arrays for now
if issparse(data):
data = cast(csr_matrix, data)
data = data.toarray()
if issparse(observed_mask):
observed_mask = cast(csr_matrix, observed_mask)
observed_mask = observed_mask.toarray()
if issparse(target_mask):
target_mask = cast(csr_matrix, target_mask)
target_mask = target_mask.toarray()
if observed_mask is None:
observed_mask = np.ones_like(data, dtype=bool)
if target_mask is None:
assert not evaluate_imputation
target_mask = np.zeros_like(data, dtype=bool)
assert data.shape == observed_mask.shape
assert data.shape == target_mask.shape
num_rows, _ = data.shape
# TODO(17896): Add processing and batching of extra data objects
processed_data, processed_obs_mask, processed_target_mask = self.data_processor.process_data_and_masks(
data, observed_mask, target_mask
)
marginal_log_likelihood = np.empty((num_rows,), dtype=processed_data.dtype)
with torch.no_grad(): | dataloader = create_dataloader( | 7 | 2023-11-21 12:55:08+00:00 | 24k |
jiawei-ren/dreamgaussian4d | diffusers/src/diffusers/pipelines/deepfloyd_if/watermark.py | [
{
"identifier": "ConfigMixin",
"path": "diffusers/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 [`~Conf... | from typing import List
from PIL import Image
from ...configuration_utils import ConfigMixin
from ...models.modeling_utils import ModelMixin
from ...utils import PIL_INTERPOLATION
import PIL.Image
import torch | 17,026 |
class IFWatermarker(ModelMixin, ConfigMixin):
def __init__(self):
super().__init__()
self.register_buffer("watermark_image", torch.zeros((62, 62, 4)))
self.watermark_image_as_pil = None
def apply_watermark(self, images: List[PIL.Image.Image], sample_size=None):
# copied from https://github.com/deep-floyd/IF/blob/b77482e36ca2031cb94dbca1001fc1e6400bf4ab/deepfloyd_if/modules/base.py#L287
h = images[0].height
w = images[0].width
sample_size = sample_size or h
coef = min(h / sample_size, w / sample_size)
img_h, img_w = (int(h / coef), int(w / coef)) if coef < 1 else (h, w)
S1, S2 = 1024**2, img_w * img_h
K = (S2 / S1) ** 0.5
wm_size, wm_x, wm_y = int(K * 62), img_w - int(14 * K), img_h - int(14 * K)
if self.watermark_image_as_pil is None:
watermark_image = self.watermark_image.to(torch.uint8).cpu().numpy()
watermark_image = Image.fromarray(watermark_image, mode="RGBA")
self.watermark_image_as_pil = watermark_image
wm_img = self.watermark_image_as_pil.resize(
|
class IFWatermarker(ModelMixin, ConfigMixin):
def __init__(self):
super().__init__()
self.register_buffer("watermark_image", torch.zeros((62, 62, 4)))
self.watermark_image_as_pil = None
def apply_watermark(self, images: List[PIL.Image.Image], sample_size=None):
# copied from https://github.com/deep-floyd/IF/blob/b77482e36ca2031cb94dbca1001fc1e6400bf4ab/deepfloyd_if/modules/base.py#L287
h = images[0].height
w = images[0].width
sample_size = sample_size or h
coef = min(h / sample_size, w / sample_size)
img_h, img_w = (int(h / coef), int(w / coef)) if coef < 1 else (h, w)
S1, S2 = 1024**2, img_w * img_h
K = (S2 / S1) ** 0.5
wm_size, wm_x, wm_y = int(K * 62), img_w - int(14 * K), img_h - int(14 * K)
if self.watermark_image_as_pil is None:
watermark_image = self.watermark_image.to(torch.uint8).cpu().numpy()
watermark_image = Image.fromarray(watermark_image, mode="RGBA")
self.watermark_image_as_pil = watermark_image
wm_img = self.watermark_image_as_pil.resize( | (wm_size, wm_size), PIL_INTERPOLATION["bicubic"], reducing_gap=None | 2 | 2023-12-28 08:17:40+00:00 | 24k |
FoundationVision/UniRef | detectron2/utils/visualizer.py | [
{
"identifier": "MetadataCatalog",
"path": "detectron2/data/catalog.py",
"snippet": "class _DatasetCatalog(UserDict):\nclass Metadata(types.SimpleNamespace):\nclass _MetadataCatalog(UserDict):\n def register(self, name, func):\n def get(self, name):\n def list(self) -> List[str]:\n def remov... | import colorsys
import logging
import math
import cv2
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import pycocotools.mask as mask_util
import torch
from enum import Enum, unique
from detectron2.data import MetadataCatalog
from detectron2.structures import (
BitMasks,
Boxes,
BoxMode,
Keypoints,
PolygonMasks,
RotatedBoxes,
)
from detectron2.utils.file_io import PathManager
from matplotlib.backends.backend_agg import FigureCanvasAgg
from PIL import Image
from .colormap import random_color
from panopticapi.utils import rgb2id | 17,020 | 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.
logger = logging.getLogger(__name__)
__all__ = ["ColorMode", "VisImage", "Visualizer"]
_SMALL_OBJECT_AREA_THRESH = 1000
_LARGE_MASK_AREA_THRESH = 120000
_OFF_WHITE = (1.0, 1.0, 240.0 / 255)
_BLACK = (0, 0, 0)
_RED = (1.0, 0, 0)
_KEYPOINT_THRESHOLD = 0.05
@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, 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.
"""
self.img = np.asarray(img_rgb).clip(0, 255).astype(np.uint8)
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 draw_instance_predictions(self, predictions):
"""
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("thing_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("thing_colors"):
colors = [
self._jitter([x / 255 for x in self.metadata.thing_colors[c]]) for c in classes
]
alpha = 0.8
else:
colors = None
alpha = 0.5
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
)
)
alpha = 0.3
self.overlay_instances(
masks=masks,
boxes=boxes,
labels=labels,
keypoints=keypoints,
assigned_colors=colors,
alpha=alpha,
)
return self.output
def draw_sem_seg(self, sem_seg, area_threshold=None, alpha=0.8):
"""
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=_OFF_WHITE,
text=text,
alpha=alpha,
area_threshold=area_threshold,
)
return self.output
def draw_panoptic_seg(self, panoptic_seg, segments_info, area_threshold=None, alpha=0.7):
"""
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,
)
# 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.thing_classes, [x.get("iscrowd", 0) for x in sinfo]
)
try:
colors = [
self._jitter([x / 255 for x in self.metadata.thing_colors[c]]) for c in category_ids
]
except AttributeError:
colors = None
self.overlay_instances(masks=masks, labels=labels, assigned_colors=colors, alpha=alpha)
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("thing_colors"):
colors = [
self._jitter([x / 255 for x in self.metadata.thing_colors[c]])
for c in category_ids
]
names = self.metadata.get("thing_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)
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,
):
"""
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)]
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
)
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)]
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=0.5, 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 = max(self._default_font_size / 4, 1)
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
):
"""
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 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-22 13:31:33+00:00 | 24k |
iKala/ievals | ievals/cli/ieval.py | [
{
"identifier": "TGI_Evaluator",
"path": "ievals/modules/qa_evaluators/tgi.py",
"snippet": "class TGI_Evaluator(Evaluator):\n def __init__(\n self,\n choices,\n k,\n ip_addr,\n model_name,\n systemMessageToken=\"<|im_start|>system\\n\",\n messageEndTok... | import os
import logging
import argparse
import pandas as pd
from datasets import load_dataset
from ievals.modules.qa_evaluators.tgi import TGI_Evaluator
from ievals.modules.qa_evaluators.gemini import Gemini_Evaluator
from ievals.modules.qa_evaluators.claude import Claude_Evaluator
from ievals.modules.qa_evaluators.azure import Azure_Evaluator
from ievals.modules.qa_evaluators.oai_complete import GPT_Evaluator
from ievals.modules.qa_evaluators.chatgpt import ChatGPT_Evaluator
from ievals.modules.qa_evaluators.hf_chat import HF_Chat_Evaluator
from ievals.modules.qa_evaluators.hf_base import (
Qwen_Evaluator,
) # we only use this for qwen base model
from ievals.modules.qa_evaluators.ali_dashscope import DashScope_Evaluator
from ievals.exp_executer import run_exp | 19,458 | """
CLI for all models
Support mode:
if tgi service was used you must pass in IP and hostname
if the service was found in model_config.csv you could skip providing the 4 tokens (user, assistant, system, eos)
else you need to pass in the four token in args
"""
try:
except ImportError as e:
logging.error("huggingface and qwen models are not supported due to " + str(e))
def get_model_config():
current_dir = os.path.dirname(os.path.abspath(__file__))
up_dir = os.path.abspath(os.path.join(current_dir, os.pardir))
df = pd.read_csv(os.path.join(up_dir, "model_config.csv"))
df.fillna("", inplace=True)
valid_model_names = df["model_name"].tolist()
return valid_model_names, df
def get_tgi_prompt_config(model_name):
valid_model_names, df = get_model_config()
if model_name not in valid_model_names:
return None, None
prompt_config = df[df["model_name"] == model_name].iloc[0]
prompt_config.pop("model_name")
return prompt_config
def get_evaluator(model_name, series=""):
if len(series):
if series == "azure":
return Azure_Evaluator
elif series == "openai_chat":
return ChatGPT_Evaluator
elif series == "openai_complete":
return GPT_Evaluator
elif series == "gemini":
| """
CLI for all models
Support mode:
if tgi service was used you must pass in IP and hostname
if the service was found in model_config.csv you could skip providing the 4 tokens (user, assistant, system, eos)
else you need to pass in the four token in args
"""
try:
except ImportError as e:
logging.error("huggingface and qwen models are not supported due to " + str(e))
def get_model_config():
current_dir = os.path.dirname(os.path.abspath(__file__))
up_dir = os.path.abspath(os.path.join(current_dir, os.pardir))
df = pd.read_csv(os.path.join(up_dir, "model_config.csv"))
df.fillna("", inplace=True)
valid_model_names = df["model_name"].tolist()
return valid_model_names, df
def get_tgi_prompt_config(model_name):
valid_model_names, df = get_model_config()
if model_name not in valid_model_names:
return None, None
prompt_config = df[df["model_name"] == model_name].iloc[0]
prompt_config.pop("model_name")
return prompt_config
def get_evaluator(model_name, series=""):
if len(series):
if series == "azure":
return Azure_Evaluator
elif series == "openai_chat":
return ChatGPT_Evaluator
elif series == "openai_complete":
return GPT_Evaluator
elif series == "gemini": | return Gemini_Evaluator | 1 | 2023-12-24 08:00:38+00:00 | 24k |
kraina-ai/quackosm | quackosm/functions.py | [
{
"identifier": "GroupedOsmTagsFilter",
"path": "quackosm/_osm_tags_filters.py",
"snippet": "def merge_osm_tags_filter(osm_tags_filter: OsmTagsFilter) -> OsmTagsFilter: ...\ndef merge_osm_tags_filter(osm_tags_filter: GroupedOsmTagsFilter) -> OsmTagsFilter: ...\ndef merge_osm_tags_filter(osm_tags_filter:... | from collections.abc import Iterable
from pathlib import Path
from typing import Any, Optional, Union
from shapely.geometry.base import BaseGeometry
from quackosm._osm_tags_filters import GroupedOsmTagsFilter, OsmTagsFilter
from quackosm._osm_way_polygon_features import OsmWayPolygonConfig
from quackosm.pbf_file_reader import PbfFileReader
import geopandas as gpd | 17,284 | """
Functions.
This module contains helper functions to simplify the usage.
"""
def convert_pbf_to_gpq(
pbf_path: Union[str, Path],
| """
Functions.
This module contains helper functions to simplify the usage.
"""
def convert_pbf_to_gpq(
pbf_path: Union[str, Path], | tags_filter: Optional[Union[OsmTagsFilter, GroupedOsmTagsFilter]] = None, | 0 | 2023-12-28 11:26:41+00:00 | 24k |
KyanChen/TTP | tests/test_datasets/test_dataset.py | [
{
"identifier": "ADE20KDataset",
"path": "mmseg/datasets/ade.py",
"snippet": "class ADE20KDataset(BaseSegDataset):\n \"\"\"ADE20K dataset.\n\n In segmentation map annotation for ADE20K, 0 stands for background, which\n is not included in 150 categories. ``reduce_zero_label`` is fixed to True.\n... | import os
import os.path as osp
import tempfile
import pytest
from mmseg.datasets import (ADE20KDataset, BaseSegDataset, BDD100KDataset,
CityscapesDataset, COCOStuffDataset,
DecathlonDataset, DSDLSegDataset, ISPRSDataset,
LIPDataset, LoveDADataset, MapillaryDataset_v1,
MapillaryDataset_v2, NYUDataset, PascalVOCDataset,
PotsdamDataset, REFUGEDataset, SynapseDataset,
iSAIDDataset)
from mmseg.registry import DATASETS
from mmseg.utils import get_classes, get_palette
from dsdl.dataset import DSDLDataset | 20,211 | def test_cityscapes():
test_dataset = CityscapesDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_cityscapes_dataset/leftImg8bit/val'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_cityscapes_dataset/gtFine/val')))
assert len(test_dataset) == 1
def test_loveda():
test_dataset = LoveDADataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_loveda_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_loveda_dataset/ann_dir')))
assert len(test_dataset) == 3
def test_potsdam():
test_dataset = PotsdamDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_potsdam_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_potsdam_dataset/ann_dir')))
assert len(test_dataset) == 1
def test_vaihingen():
test_dataset = ISPRSDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_vaihingen_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_vaihingen_dataset/ann_dir')))
assert len(test_dataset) == 1
def test_synapse():
test_dataset = SynapseDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_synapse_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_synapse_dataset/ann_dir')))
assert len(test_dataset) == 2
def test_refuge():
test_dataset = REFUGEDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_refuge_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_refuge_dataset/ann_dir')))
assert len(test_dataset) == 1
def test_isaid():
test_dataset = iSAIDDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__), '../data/pseudo_isaid_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_isaid_dataset/ann_dir')))
assert len(test_dataset) == 2
test_dataset = iSAIDDataset(
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__), '../data/pseudo_isaid_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_isaid_dataset/ann_dir')),
ann_file=osp.join(
osp.dirname(__file__),
'../data/pseudo_isaid_dataset/splits/train.txt'))
assert len(test_dataset) == 1
def test_decathlon():
data_root = osp.join(osp.dirname(__file__), '../data')
# test load training dataset
test_dataset = DecathlonDataset(
pipeline=[], data_root=data_root, ann_file='dataset.json')
assert len(test_dataset) == 1
# test load test dataset
test_dataset = DecathlonDataset(
pipeline=[],
data_root=data_root,
ann_file='dataset.json',
test_mode=True)
assert len(test_dataset) == 3
def test_lip():
data_root = osp.join(osp.dirname(__file__), '../data/pseudo_lip_dataset')
# train load training dataset
| # Copyright (c) OpenMMLab. All rights reserved.
try:
except ImportError:
DSDLDataset = None
def test_classes():
assert list(
CityscapesDataset.METAINFO['classes']) == get_classes('cityscapes')
assert list(PascalVOCDataset.METAINFO['classes']) == get_classes(
'voc') == get_classes('pascal_voc')
assert list(ADE20KDataset.METAINFO['classes']) == get_classes(
'ade') == get_classes('ade20k')
assert list(
COCOStuffDataset.METAINFO['classes']) == get_classes('cocostuff')
assert list(LoveDADataset.METAINFO['classes']) == get_classes('loveda')
assert list(PotsdamDataset.METAINFO['classes']) == get_classes('potsdam')
assert list(ISPRSDataset.METAINFO['classes']) == get_classes('vaihingen')
assert list(iSAIDDataset.METAINFO['classes']) == get_classes('isaid')
assert list(
MapillaryDataset_v1.METAINFO['classes']) == get_classes('mapillary_v1')
assert list(
MapillaryDataset_v2.METAINFO['classes']) == get_classes('mapillary_v2')
assert list(BDD100KDataset.METAINFO['classes']) == get_classes('bdd100k')
with pytest.raises(ValueError):
get_classes('unsupported')
def test_classes_file_path():
tmp_file = tempfile.NamedTemporaryFile()
classes_path = f'{tmp_file.name}.txt'
train_pipeline = []
kwargs = dict(
pipeline=train_pipeline,
data_prefix=dict(img_path='./', seg_map_path='./'),
metainfo=dict(classes=classes_path))
# classes.txt with full categories
categories = get_classes('cityscapes')
with open(classes_path, 'w') as f:
f.write('\n'.join(categories))
dataset = CityscapesDataset(**kwargs)
assert list(dataset.metainfo['classes']) == categories
assert dataset.label_map is None
# classes.txt with sub categories
categories = ['road', 'sidewalk', 'building']
with open(classes_path, 'w') as f:
f.write('\n'.join(categories))
dataset = CityscapesDataset(**kwargs)
assert list(dataset.metainfo['classes']) == categories
assert dataset.label_map is not None
# classes.txt with unknown categories
categories = ['road', 'sidewalk', 'unknown']
with open(classes_path, 'w') as f:
f.write('\n'.join(categories))
with pytest.raises(ValueError):
CityscapesDataset(**kwargs)
tmp_file.close()
os.remove(classes_path)
assert not osp.exists(classes_path)
def test_palette():
assert CityscapesDataset.METAINFO['palette'] == get_palette('cityscapes')
assert PascalVOCDataset.METAINFO['palette'] == get_palette(
'voc') == get_palette('pascal_voc')
assert ADE20KDataset.METAINFO['palette'] == get_palette(
'ade') == get_palette('ade20k')
assert LoveDADataset.METAINFO['palette'] == get_palette('loveda')
assert PotsdamDataset.METAINFO['palette'] == get_palette('potsdam')
assert COCOStuffDataset.METAINFO['palette'] == get_palette('cocostuff')
assert iSAIDDataset.METAINFO['palette'] == get_palette('isaid')
assert list(
MapillaryDataset_v1.METAINFO['palette']) == get_palette('mapillary_v1')
assert list(
MapillaryDataset_v2.METAINFO['palette']) == get_palette('mapillary_v2')
assert list(BDD100KDataset.METAINFO['palette']) == get_palette('bdd100k')
with pytest.raises(ValueError):
get_palette('unsupported')
def test_custom_dataset():
# with 'img_path' and 'seg_map_path' in data_prefix
train_dataset = BaseSegDataset(
data_root=osp.join(osp.dirname(__file__), '../data/pseudo_dataset'),
data_prefix=dict(
img_path='imgs/',
seg_map_path='gts/',
),
img_suffix='img.jpg',
seg_map_suffix='gt.png')
assert len(train_dataset) == 5
# with 'img_path' and 'seg_map_path' in data_prefix and ann_file
train_dataset = BaseSegDataset(
data_root=osp.join(osp.dirname(__file__), '../data/pseudo_dataset'),
data_prefix=dict(
img_path='imgs/',
seg_map_path='gts/',
),
img_suffix='img.jpg',
seg_map_suffix='gt.png',
ann_file='splits/train.txt')
assert len(train_dataset) == 4
# no data_root
train_dataset = BaseSegDataset(
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__), '../data/pseudo_dataset/imgs'),
seg_map_path=osp.join(
osp.dirname(__file__), '../data/pseudo_dataset/gts')),
img_suffix='img.jpg',
seg_map_suffix='gt.png')
assert len(train_dataset) == 5
# with data_root but 'img_path' and 'seg_map_path' in data_prefix are
# abs path
train_dataset = BaseSegDataset(
data_root=osp.join(osp.dirname(__file__), '../data/pseudo_dataset'),
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__), '../data/pseudo_dataset/imgs'),
seg_map_path=osp.join(
osp.dirname(__file__), '../data/pseudo_dataset/gts')),
img_suffix='img.jpg',
seg_map_suffix='gt.png')
assert len(train_dataset) == 5
# test_mode=True
test_dataset = BaseSegDataset(
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__), '../data/pseudo_dataset/imgs')),
img_suffix='img.jpg',
test_mode=True,
metainfo=dict(classes=('pseudo_class', )))
assert len(test_dataset) == 5
# training data get
train_data = train_dataset[0]
assert isinstance(train_data, dict)
assert 'img_path' in train_data and osp.isfile(train_data['img_path'])
assert 'seg_map_path' in train_data and osp.isfile(
train_data['seg_map_path'])
# test data get
test_data = test_dataset[0]
assert isinstance(test_data, dict)
assert 'img_path' in train_data and osp.isfile(train_data['img_path'])
assert 'seg_map_path' in train_data and osp.isfile(
train_data['seg_map_path'])
def test_ade():
test_dataset = ADE20KDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__), '../data/pseudo_dataset/imgs')))
assert len(test_dataset) == 5
def test_cityscapes():
test_dataset = CityscapesDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_cityscapes_dataset/leftImg8bit/val'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_cityscapes_dataset/gtFine/val')))
assert len(test_dataset) == 1
def test_loveda():
test_dataset = LoveDADataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_loveda_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_loveda_dataset/ann_dir')))
assert len(test_dataset) == 3
def test_potsdam():
test_dataset = PotsdamDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_potsdam_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_potsdam_dataset/ann_dir')))
assert len(test_dataset) == 1
def test_vaihingen():
test_dataset = ISPRSDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_vaihingen_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_vaihingen_dataset/ann_dir')))
assert len(test_dataset) == 1
def test_synapse():
test_dataset = SynapseDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_synapse_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_synapse_dataset/ann_dir')))
assert len(test_dataset) == 2
def test_refuge():
test_dataset = REFUGEDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_refuge_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_refuge_dataset/ann_dir')))
assert len(test_dataset) == 1
def test_isaid():
test_dataset = iSAIDDataset(
pipeline=[],
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__), '../data/pseudo_isaid_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_isaid_dataset/ann_dir')))
assert len(test_dataset) == 2
test_dataset = iSAIDDataset(
data_prefix=dict(
img_path=osp.join(
osp.dirname(__file__), '../data/pseudo_isaid_dataset/img_dir'),
seg_map_path=osp.join(
osp.dirname(__file__),
'../data/pseudo_isaid_dataset/ann_dir')),
ann_file=osp.join(
osp.dirname(__file__),
'../data/pseudo_isaid_dataset/splits/train.txt'))
assert len(test_dataset) == 1
def test_decathlon():
data_root = osp.join(osp.dirname(__file__), '../data')
# test load training dataset
test_dataset = DecathlonDataset(
pipeline=[], data_root=data_root, ann_file='dataset.json')
assert len(test_dataset) == 1
# test load test dataset
test_dataset = DecathlonDataset(
pipeline=[],
data_root=data_root,
ann_file='dataset.json',
test_mode=True)
assert len(test_dataset) == 3
def test_lip():
data_root = osp.join(osp.dirname(__file__), '../data/pseudo_lip_dataset')
# train load training dataset | train_dataset = LIPDataset( | 9 | 2023-12-23 08:36:47+00:00 | 24k |
see2023/Bert-VITS2-ext | train_ms.py | [
{
"identifier": "config",
"path": "config.py",
"snippet": "class Resample_config:\nclass Preprocess_text_config:\nclass Bert_gen_config:\nclass Emo_gen_config:\nclass Train_ms_config:\nclass Webui_config:\nclass Server_config:\nclass Translate_config:\nclass Config:\n def __init__(self, in_dir: str, ... | import platform
import os
import torch
import torch.distributed as dist
import logging
import argparse
import datetime
import gc
import commons
import utils
from torch.nn import functional as F
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.cuda.amp import autocast, GradScaler
from tqdm import tqdm
from config import config
from data_utils import (
TextAudioSpeakerLoader,
TextAudioSpeakerCollate,
DistributedBucketSampler,
AudioVisemesLoader,
)
from models import (
SynthesizerTrn,
MultiPeriodDiscriminator,
DurationDiscriminator,
WavLMDiscriminator,
VisemesNet,
)
from losses import (
generator_loss,
discriminator_loss,
feature_loss,
kl_loss,
WavLMLoss,
)
from mel_processing import mel_spectrogram_torch, spec_to_mel_torch
from text.symbols import symbols | 15,277 | if net_dur_disc is not None:
scheduler_dur_disc.step()
def train_and_evaluate(
rank,
local_rank,
epoch,
hps,
nets,
optims,
schedulers,
scaler,
loaders,
logger,
writers,
):
net_g, net_d, net_dur_disc, net_wd, wl = nets
optim_g, optim_d, optim_dur_disc, optim_wd = optims
scheduler_g, scheduler_d, scheduler_dur_disc, scheduler_wd = schedulers
train_loader, eval_loader = loaders
if writers is not None:
writer, writer_eval = writers
train_loader.batch_sampler.set_epoch(epoch)
global global_step
net_g.train()
net_d.train()
net_wd.train()
if net_dur_disc is not None:
net_dur_disc.train()
for batch_idx, (
x,
x_lengths,
spec,
spec_lengths,
y,
y_lengths,
speakers,
tone,
language,
bert,
ja_bert,
en_bert,
) in enumerate(tqdm(train_loader)):
if net_g.module.use_noise_scaled_mas:
current_mas_noise_scale = (
net_g.module.mas_noise_scale_initial
- net_g.module.noise_scale_delta * global_step
)
net_g.module.current_mas_noise_scale = max(current_mas_noise_scale, 0.0)
x, x_lengths = x.cuda(local_rank, non_blocking=True), x_lengths.cuda(
local_rank, non_blocking=True
)
spec, spec_lengths = spec.cuda(
local_rank, non_blocking=True
), spec_lengths.cuda(local_rank, non_blocking=True)
y, y_lengths = y.cuda(local_rank, non_blocking=True), y_lengths.cuda(
local_rank, non_blocking=True
)
speakers = speakers.cuda(local_rank, non_blocking=True)
tone = tone.cuda(local_rank, non_blocking=True)
language = language.cuda(local_rank, non_blocking=True)
bert = bert.cuda(local_rank, non_blocking=True)
ja_bert = ja_bert.cuda(local_rank, non_blocking=True)
en_bert = en_bert.cuda(local_rank, non_blocking=True)
with autocast(enabled=hps.train.bf16_run, dtype=torch.bfloat16):
(
y_hat,
l_length,
attn,
ids_slice,
x_mask,
z_mask,
(z, z_p, m_p, logs_p, m_q, logs_q),
(hidden_x, logw, logw_, logw_sdp),
g,
) = net_g(
x,
x_lengths,
spec,
spec_lengths,
speakers,
tone,
language,
bert,
ja_bert,
en_bert,
)
mel = spec_to_mel_torch(
spec,
hps.data.filter_length,
hps.data.n_mel_channels,
hps.data.sampling_rate,
hps.data.mel_fmin,
hps.data.mel_fmax,
)
y_mel = commons.slice_segments(
mel, ids_slice, hps.train.segment_size // hps.data.hop_length
)
y_hat_mel = mel_spectrogram_torch(
y_hat.squeeze(1).float(),
hps.data.filter_length,
hps.data.n_mel_channels,
hps.data.sampling_rate,
hps.data.hop_length,
hps.data.win_length,
hps.data.mel_fmin,
hps.data.mel_fmax,
)
y = commons.slice_segments(
y, ids_slice * hps.data.hop_length, hps.train.segment_size
) # slice
# Discriminator
y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach())
with autocast(enabled=hps.train.bf16_run, dtype=torch.bfloat16):
| # flake8: noqa: E402
logging.getLogger("numba").setLevel(logging.WARNING)
logger = logging.getLogger(__name__)
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = (
True # If encontered training problem,please try to disable TF32.
)
torch.set_float32_matmul_precision("medium")
torch.backends.cuda.sdp_kernel("flash")
torch.backends.cuda.enable_flash_sdp(True)
torch.backends.cuda.enable_mem_efficient_sdp(
True
) # Not available if torch version is lower than 2.0
global_step = 0
global_visemes_step = 0
def run_only_visemes(hps):
# 使用最简单的单机模式，仅训练隐变量z到表情(visemes)的全连接 VisemesFCNet 的参数
global global_visemes_step
torch.manual_seed(hps.train.seed)
torch.cuda.set_device(0)
train_dataset = AudioVisemesLoader(hps.data.training_visemes_files, hps.data)
train_loader = DataLoader(train_dataset, num_workers=0, shuffle=False, pin_memory=True,
batch_size=1, drop_last=True)
eval_dataset = AudioVisemesLoader(hps.data.validation_visemes_files, hps.data)
eval_loader = DataLoader(eval_dataset, num_workers=0, shuffle=False,
batch_size=1, pin_memory=True,
drop_last=False)
net_v = VisemesNet(hps.model.hidden_channels).cuda()
latest_model_path = utils.latest_checkpoint_path(hps.model_dir, "V_*.pth")
if latest_model_path is not None:
_, optim_d, _, epoch_str = utils.load_checkpoint(latest_model_path, net_v, None, skip_optimizer=False)
else :
epoch_str = 1
global_visemes_step = 0
net_v.init_weights()
optim_v = torch.optim.AdamW(
net_v.parameters(),
hps.train.learning_rate,
betas=hps.train.betas,
eps=hps.train.eps)
optim_v.param_groups[0]['initial_lr'] = hps.train.learning_rate
scheduler_v = torch.optim.lr_scheduler.ExponentialLR(optim_v, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2, )
scaler = GradScaler(enabled=hps.train.bf16_run)
for epoch in range(epoch_str, hps.train.epochs + 1):
train_visemes_only(epoch, hps, net_v, train_loader, optim_v, scaler)
scheduler_v.step()
if epoch % hps.train.eval_interval == 0:
eval_visemes_only(epoch, hps, net_v, eval_loader)
utils.save_checkpoint(net_v, optim_v,hps.train.learning_rate , epoch, os.path.join(hps.model_dir, "V_{}.pth".format(epoch)))
def train_visemes_only(epoch, hps, net_v, train_loader, optim_v, scaler):
for batch_idx, (spec, visemes) in tqdm(enumerate(train_loader)):
spec, visemes = spec.cuda(), visemes.cuda()
with autocast(enabled=hps.train.bf16_run):
# 通过VisemesNet从z生成visemes_hat，和均方差
visemes_hat = net_v(spec)
visemes_hat_mse = get_visemes_mse(visemes, visemes_hat)
optim_v.zero_grad()
scaler.scale(visemes_hat_mse).backward()
scaler.unscale_(optim_v)
grad_norm_v = commons.clip_grad_value_(net_v.parameters(), None)
scaler.step(optim_v)
global global_visemes_step
global_visemes_step += 1
if batch_idx % hps.train.log_interval == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tvisemes_hat_mse: {:.6f}\tgrad_norm_v: {:.6f}'.format(
epoch, batch_idx * len(spec), len(train_loader.dataset),
100. * batch_idx / len(train_loader), visemes_hat_mse.item(), grad_norm_v))
def get_visemes_mse(visemes, visemes_hat):
if visemes.shape[-1] != visemes_hat.shape[-1]: # 如果y和x的最低维度不一样
visemes_hat = F.interpolate(visemes_hat, size=visemes.shape[-1], mode='linear', align_corners=True) # 对x进行线性插值，使其形状与y一致
visemes_hat_mse = torch.mean(torch.pow(visemes_hat - visemes, 2))
return visemes_hat_mse
def eval_visemes_only(epoch, hps, net_v, eval_loader):
net_v.eval()
with torch.no_grad():
visemes_hat_mse_sum = 0.0
for batch_idx, (spec, visemes) in tqdm(enumerate(eval_loader)):
spec, visemes = spec.cuda(), visemes.cuda()
# 通过VisemesFCNet从z生成visemes_hat，和均方差
visemes_hat = net_v(spec)
visemes_hat_mse = get_visemes_mse(visemes, visemes_hat)
visemes_hat_mse_sum += visemes_hat_mse
# print('visemes_hat_mse', visemes_hat_mse)
break
visemes_hat_mse_avg = visemes_hat_mse_sum / (batch_idx + 1)
log_str = '------------------ eval epoch: {} visemes_hat_mse_avg: {:.6f}'.format(epoch, visemes_hat_mse_avg)
print(log_str)
logger.warning(log_str)
net_v.train()
def run():
# 环境变量解析
envs = config.train_ms_config.env
for env_name, env_value in envs.items():
if env_name not in os.environ.keys():
print("加载config中的配置{}".format(str(env_value)))
os.environ[env_name] = str(env_value)
print(
"加载环境变量 \nMASTER_ADDR: {},\nMASTER_PORT: {},\nWORLD_SIZE: {},\nRANK: {},\nLOCAL_RANK: {}".format(
os.environ["MASTER_ADDR"],
os.environ["MASTER_PORT"],
os.environ["WORLD_SIZE"],
os.environ["RANK"],
os.environ["LOCAL_RANK"],
)
)
backend = "nccl"
if platform.system() == "Windows":
backend = "gloo" # If Windows,switch to gloo backend.
dist.init_process_group(
backend=backend,
init_method="env://",
timeout=datetime.timedelta(seconds=300),
) # Use torchrun instead of mp.spawn
rank = dist.get_rank()
local_rank = int(os.environ["LOCAL_RANK"])
n_gpus = dist.get_world_size()
# 命令行/config.yml配置解析
# hps = utils.get_hparams()
parser = argparse.ArgumentParser()
# 非必要不建议使用命令行配置，请使用config.yml文件
parser.add_argument(
"-c",
"--config",
type=str,
default=config.train_ms_config.config_path,
help="JSON file for configuration",
)
parser.add_argument(
"-m",
"--model",
type=str,
help="数据集文件夹路径，请注意，数据不再默认放在/logs文件夹下。如果需要用命令行配置，请声明相对于根目录的路径",
default=config.dataset_path,
)
parser.add_argument('--visemes', dest='visemes', action="store_true", default=False, help="train visemes only, lock the encoder and decoder")
args = parser.parse_args()
model_dir = os.path.join(args.model, config.train_ms_config.model)
if not os.path.exists(model_dir):
os.makedirs(model_dir)
hps = utils.get_hparams_from_file(args.config)
hps.model_dir = model_dir
set_logger(hps)
if args.visemes:
run_only_visemes(hps)
# 比较路径是否相同
if os.path.realpath(args.config) != os.path.realpath(
config.train_ms_config.config_path
):
with open(args.config, "r", encoding="utf-8") as f:
data = f.read()
with open(config.train_ms_config.config_path, "w", encoding="utf-8") as f:
f.write(data)
torch.manual_seed(hps.train.seed)
torch.cuda.set_device(local_rank)
global global_step
if rank == 0:
logger = utils.get_logger(hps.model_dir)
logger.info(hps)
utils.check_git_hash(hps.model_dir)
writer = SummaryWriter(log_dir=hps.model_dir)
writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval"))
train_dataset = TextAudioSpeakerLoader(hps.data.training_files, hps.data)
train_sampler = DistributedBucketSampler(
train_dataset,
hps.train.batch_size,
[32, 300, 400, 500, 600, 700, 800, 900, 1000],
num_replicas=n_gpus,
rank=rank,
shuffle=True,
)
collate_fn = TextAudioSpeakerCollate()
train_loader = DataLoader(
train_dataset,
num_workers=min(config.train_ms_config.num_workers, os.cpu_count() - 1),
shuffle=False,
pin_memory=True,
collate_fn=collate_fn,
batch_sampler=train_sampler,
persistent_workers=True,
prefetch_factor=4,
) # DataLoader config could be adjusted.
if rank == 0:
eval_dataset = TextAudioSpeakerLoader(hps.data.validation_files, hps.data)
eval_loader = DataLoader(
eval_dataset,
num_workers=0,
shuffle=False,
batch_size=1,
pin_memory=True,
drop_last=False,
collate_fn=collate_fn,
)
if (
"use_noise_scaled_mas" in hps.model.keys()
and hps.model.use_noise_scaled_mas is True
):
print("Using noise scaled MAS for VITS2")
mas_noise_scale_initial = 0.01
noise_scale_delta = 2e-6
else:
print("Using normal MAS for VITS1")
mas_noise_scale_initial = 0.0
noise_scale_delta = 0.0
if (
"use_duration_discriminator" in hps.model.keys()
and hps.model.use_duration_discriminator is True
):
print("Using duration discriminator for VITS2")
net_dur_disc = DurationDiscriminator(
hps.model.hidden_channels,
hps.model.hidden_channels,
3,
0.1,
gin_channels=hps.model.gin_channels if hps.data.n_speakers != 0 else 0,
).cuda(local_rank)
else:
net_dur_disc = None
if (
"use_spk_conditioned_encoder" in hps.model.keys()
and hps.model.use_spk_conditioned_encoder is True
):
if hps.data.n_speakers == 0:
raise ValueError(
"n_speakers must be > 0 when using spk conditioned encoder to train multi-speaker model"
)
else:
print("Using normal encoder for VITS1")
net_g = SynthesizerTrn(
len(symbols),
hps.data.filter_length // 2 + 1,
hps.train.segment_size // hps.data.hop_length,
n_speakers=hps.data.n_speakers,
mas_noise_scale_initial=mas_noise_scale_initial,
noise_scale_delta=noise_scale_delta,
**hps.model,
).cuda(local_rank)
if getattr(hps.train, "freeze_ZH_bert", False):
print("Freezing ZH bert encoder !!!")
for param in net_g.enc_p.bert_proj.parameters():
param.requires_grad = False
if getattr(hps.train, "freeze_EN_bert", False):
print("Freezing EN bert encoder !!!")
for param in net_g.enc_p.en_bert_proj.parameters():
param.requires_grad = False
if getattr(hps.train, "freeze_JP_bert", False):
print("Freezing JP bert encoder !!!")
for param in net_g.enc_p.ja_bert_proj.parameters():
param.requires_grad = False
net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm).cuda(local_rank)
net_wd = WavLMDiscriminator(
hps.model.slm.hidden, hps.model.slm.nlayers, hps.model.slm.initial_channel
).cuda(local_rank)
optim_g = torch.optim.AdamW(
filter(lambda p: p.requires_grad, net_g.parameters()),
hps.train.learning_rate,
betas=hps.train.betas,
eps=hps.train.eps,
)
optim_d = torch.optim.AdamW(
net_d.parameters(),
hps.train.learning_rate,
betas=hps.train.betas,
eps=hps.train.eps,
)
optim_wd = torch.optim.AdamW(
net_wd.parameters(),
hps.train.learning_rate,
betas=hps.train.betas,
eps=hps.train.eps,
)
if net_dur_disc is not None:
optim_dur_disc = torch.optim.AdamW(
net_dur_disc.parameters(),
hps.train.learning_rate,
betas=hps.train.betas,
eps=hps.train.eps,
)
else:
optim_dur_disc = None
net_g = DDP(net_g, device_ids=[local_rank], bucket_cap_mb=512)
net_d = DDP(net_d, device_ids=[local_rank], bucket_cap_mb=512)
net_wd = DDP(net_wd, device_ids=[local_rank], bucket_cap_mb=512)
if net_dur_disc is not None:
net_dur_disc = DDP(
net_dur_disc,
device_ids=[local_rank],
bucket_cap_mb=512,
)
# 下载底模
if config.train_ms_config.base["use_base_model"]:
utils.download_checkpoint(
hps.model_dir,
config.train_ms_config.base,
token=config.openi_token,
mirror=config.mirror,
)
dur_resume_lr = hps.train.learning_rate
wd_resume_lr = hps.train.learning_rate
if net_dur_disc is not None:
try:
_, _, dur_resume_lr, epoch_str = utils.load_checkpoint(
utils.latest_checkpoint_path(hps.model_dir, "DUR_*.pth"),
net_dur_disc,
optim_dur_disc,
skip_optimizer=hps.train.skip_optimizer
if "skip_optimizer" in hps.train
else True,
)
if not optim_dur_disc.param_groups[0].get("initial_lr"):
optim_dur_disc.param_groups[0]["initial_lr"] = dur_resume_lr
except:
print("Initialize dur_disc")
try:
_, optim_g, g_resume_lr, epoch_str = utils.load_checkpoint(
utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"),
net_g,
optim_g,
skip_optimizer=hps.train.skip_optimizer
if "skip_optimizer" in hps.train
else True,
)
_, optim_d, d_resume_lr, epoch_str = utils.load_checkpoint(
utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"),
net_d,
optim_d,
skip_optimizer=hps.train.skip_optimizer
if "skip_optimizer" in hps.train
else True,
)
if not optim_g.param_groups[0].get("initial_lr"):
optim_g.param_groups[0]["initial_lr"] = g_resume_lr
if not optim_d.param_groups[0].get("initial_lr"):
optim_d.param_groups[0]["initial_lr"] = d_resume_lr
epoch_str = max(epoch_str, 1)
# global_step = (epoch_str - 1) * len(train_loader)
global_step = int(
utils.get_steps(utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"))
)
print(
f"******************检测到模型存在，epoch为 {epoch_str}，gloabl step为 {global_step}*********************"
)
except Exception as e:
print(e)
epoch_str = 1
global_step = 0
try:
_, optim_wd, wd_resume_lr, epoch_str = utils.load_checkpoint(
utils.latest_checkpoint_path(hps.model_dir, "WD_*.pth"),
net_wd,
optim_wd,
skip_optimizer=hps.train.skip_optimizer
if "skip_optimizer" in hps.train
else True,
)
if not optim_wd.param_groups[0].get("initial_lr"):
optim_wd.param_groups[0]["initial_lr"] = wd_resume_lr
except Exception as e:
print(e)
scheduler_g = torch.optim.lr_scheduler.ExponentialLR(
optim_g, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2
)
scheduler_d = torch.optim.lr_scheduler.ExponentialLR(
optim_d, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2
)
scheduler_wd = torch.optim.lr_scheduler.ExponentialLR(
optim_wd, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2
)
if net_dur_disc is not None:
scheduler_dur_disc = torch.optim.lr_scheduler.ExponentialLR(
optim_dur_disc, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2
)
else:
scheduler_dur_disc = None
scaler = GradScaler(enabled=hps.train.bf16_run)
wl = WavLMLoss(
hps.model.slm.model,
net_wd,
hps.data.sampling_rate,
hps.model.slm.sr,
).to(local_rank)
for epoch in range(epoch_str, hps.train.epochs + 1):
if rank == 0:
train_and_evaluate(
rank,
local_rank,
epoch,
hps,
[net_g, net_d, net_dur_disc, net_wd, wl],
[optim_g, optim_d, optim_dur_disc, optim_wd],
[scheduler_g, scheduler_d, scheduler_dur_disc, scheduler_wd],
scaler,
[train_loader, eval_loader],
logger,
[writer, writer_eval],
)
else:
train_and_evaluate(
rank,
local_rank,
epoch,
hps,
[net_g, net_d, net_dur_disc, net_wd, wl],
[optim_g, optim_d, optim_dur_disc, optim_wd],
[scheduler_g, scheduler_d, scheduler_dur_disc, scheduler_wd],
scaler,
[train_loader, None],
None,
None,
)
scheduler_g.step()
scheduler_d.step()
scheduler_wd.step()
if net_dur_disc is not None:
scheduler_dur_disc.step()
def train_and_evaluate(
rank,
local_rank,
epoch,
hps,
nets,
optims,
schedulers,
scaler,
loaders,
logger,
writers,
):
net_g, net_d, net_dur_disc, net_wd, wl = nets
optim_g, optim_d, optim_dur_disc, optim_wd = optims
scheduler_g, scheduler_d, scheduler_dur_disc, scheduler_wd = schedulers
train_loader, eval_loader = loaders
if writers is not None:
writer, writer_eval = writers
train_loader.batch_sampler.set_epoch(epoch)
global global_step
net_g.train()
net_d.train()
net_wd.train()
if net_dur_disc is not None:
net_dur_disc.train()
for batch_idx, (
x,
x_lengths,
spec,
spec_lengths,
y,
y_lengths,
speakers,
tone,
language,
bert,
ja_bert,
en_bert,
) in enumerate(tqdm(train_loader)):
if net_g.module.use_noise_scaled_mas:
current_mas_noise_scale = (
net_g.module.mas_noise_scale_initial
- net_g.module.noise_scale_delta * global_step
)
net_g.module.current_mas_noise_scale = max(current_mas_noise_scale, 0.0)
x, x_lengths = x.cuda(local_rank, non_blocking=True), x_lengths.cuda(
local_rank, non_blocking=True
)
spec, spec_lengths = spec.cuda(
local_rank, non_blocking=True
), spec_lengths.cuda(local_rank, non_blocking=True)
y, y_lengths = y.cuda(local_rank, non_blocking=True), y_lengths.cuda(
local_rank, non_blocking=True
)
speakers = speakers.cuda(local_rank, non_blocking=True)
tone = tone.cuda(local_rank, non_blocking=True)
language = language.cuda(local_rank, non_blocking=True)
bert = bert.cuda(local_rank, non_blocking=True)
ja_bert = ja_bert.cuda(local_rank, non_blocking=True)
en_bert = en_bert.cuda(local_rank, non_blocking=True)
with autocast(enabled=hps.train.bf16_run, dtype=torch.bfloat16):
(
y_hat,
l_length,
attn,
ids_slice,
x_mask,
z_mask,
(z, z_p, m_p, logs_p, m_q, logs_q),
(hidden_x, logw, logw_, logw_sdp),
g,
) = net_g(
x,
x_lengths,
spec,
spec_lengths,
speakers,
tone,
language,
bert,
ja_bert,
en_bert,
)
mel = spec_to_mel_torch(
spec,
hps.data.filter_length,
hps.data.n_mel_channels,
hps.data.sampling_rate,
hps.data.mel_fmin,
hps.data.mel_fmax,
)
y_mel = commons.slice_segments(
mel, ids_slice, hps.train.segment_size // hps.data.hop_length
)
y_hat_mel = mel_spectrogram_torch(
y_hat.squeeze(1).float(),
hps.data.filter_length,
hps.data.n_mel_channels,
hps.data.sampling_rate,
hps.data.hop_length,
hps.data.win_length,
hps.data.mel_fmin,
hps.data.mel_fmax,
)
y = commons.slice_segments(
y, ids_slice * hps.data.hop_length, hps.train.segment_size
) # slice
# Discriminator
y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach())
with autocast(enabled=hps.train.bf16_run, dtype=torch.bfloat16): | loss_disc, losses_disc_r, losses_disc_g = discriminator_loss( | 11 | 2023-12-27 03:09:11+00:00 | 24k |
open-mmlab/Amphion | models/tts/naturalspeech2/ns2_trainer.py | [
{
"identifier": "Logger",
"path": "utils/util.py",
"snippet": "class Logger(object):\n def __init__(\n self,\n filename,\n level=\"info\",\n when=\"D\",\n backCount=10,\n fmt=\"%(asctime)s : %(message)s\",\n ):\n self.level_relations = {\n ... | import os
import shutil
import json
import time
import torch
import numpy as np
import torch.nn.functional as F
import accelerate
from utils.util import Logger, ValueWindow
from torch.utils.data import ConcatDataset, DataLoader
from models.tts.base.tts_trainer import TTSTrainer
from models.base.base_trainer import BaseTrainer
from models.base.base_sampler import VariableSampler
from models.tts.naturalspeech2.ns2_dataset import NS2Dataset, NS2Collator, batch_by_size
from models.tts.naturalspeech2.ns2_loss import (
log_pitch_loss,
log_dur_loss,
diff_loss,
diff_ce_loss,
)
from torch.utils.data.sampler import BatchSampler, SequentialSampler
from models.tts.naturalspeech2.ns2 import NaturalSpeech2
from torch.optim import Adam, AdamW
from torch.nn import MSELoss, L1Loss
from diffusers import get_scheduler
from accelerate.logging import get_logger
from accelerate.utils import ProjectConfiguration | 19,716 | batch_sampler=VariableSampler(batches, drop_last=False),
pin_memory=self.cfg.train.dataloader.pin_memory,
)
self.accelerator.wait_for_everyone()
else:
print("Use Normal Batchsize......")
Dataset, Collator = self._build_dataset()
train_dataset = Dataset(self.cfg, self.cfg.dataset[0], is_valid=False)
train_collate = Collator(self.cfg)
train_loader = DataLoader(
train_dataset,
shuffle=True,
collate_fn=train_collate,
batch_size=self.cfg.train.batch_size,
num_workers=self.cfg.train.dataloader.num_worker,
pin_memory=self.cfg.train.dataloader.pin_memory,
)
valid_dataset = Dataset(self.cfg, self.cfg.dataset[0], is_valid=True)
valid_collate = Collator(self.cfg)
valid_loader = DataLoader(
valid_dataset,
shuffle=True,
collate_fn=valid_collate,
batch_size=self.cfg.train.batch_size,
num_workers=self.cfg.train.dataloader.num_worker,
pin_memory=self.cfg.train.dataloader.pin_memory,
)
self.accelerator.wait_for_everyone()
return train_loader, valid_loader
def _build_optimizer(self):
optimizer = torch.optim.AdamW(
filter(lambda p: p.requires_grad, self.model.parameters()),
**self.cfg.train.adam,
)
return optimizer
def _build_scheduler(self):
lr_scheduler = get_scheduler(
self.cfg.train.lr_scheduler,
optimizer=self.optimizer,
num_warmup_steps=self.cfg.train.lr_warmup_steps,
num_training_steps=self.cfg.train.num_train_steps,
)
return lr_scheduler
def _build_criterion(self):
criterion = torch.nn.L1Loss(reduction="mean")
return criterion
def write_summary(self, losses, stats):
for key, value in losses.items():
self.sw.add_scalar(key, value, self.step)
def write_valid_summary(self, losses, stats):
for key, value in losses.items():
self.sw.add_scalar(key, value, self.step)
def get_state_dict(self):
state_dict = {
"model": self.model.state_dict(),
"optimizer": self.optimizer.state_dict(),
"scheduler": self.scheduler.state_dict(),
"step": self.step,
"epoch": self.epoch,
"batch_size": self.cfg.train.batch_size,
}
return state_dict
def load_model(self, checkpoint):
self.step = checkpoint["step"]
self.epoch = checkpoint["epoch"]
self.model.load_state_dict(checkpoint["model"])
self.optimizer.load_state_dict(checkpoint["optimizer"])
self.scheduler.load_state_dict(checkpoint["scheduler"])
def _train_step(self, batch):
train_losses = {}
total_loss = 0
train_stats = {}
code = batch["code"] # (B, 16, T)
pitch = batch["pitch"] # (B, T)
duration = batch["duration"] # (B, N)
phone_id = batch["phone_id"] # (B, N)
ref_code = batch["ref_code"] # (B, 16, T')
phone_mask = batch["phone_mask"] # (B, N)
mask = batch["mask"] # (B, T)
ref_mask = batch["ref_mask"] # (B, T')
diff_out, prior_out = self.model(
code=code,
pitch=pitch,
duration=duration,
phone_id=phone_id,
ref_code=ref_code,
phone_mask=phone_mask,
mask=mask,
ref_mask=ref_mask,
)
# pitch loss
pitch_loss = log_pitch_loss(prior_out["pitch_pred_log"], pitch, mask=mask)
total_loss += pitch_loss
train_losses["pitch_loss"] = pitch_loss
# duration loss
dur_loss = log_dur_loss(prior_out["dur_pred_log"], duration, mask=phone_mask)
total_loss += dur_loss
train_losses["dur_loss"] = dur_loss
x0 = self.model.module.code_to_latent(code)
if self.cfg.model.diffusion.diffusion_type == "diffusion":
# diff loss x0
| # Copyright (c) 2023 Amphion.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
class NS2Trainer(TTSTrainer):
def __init__(self, args, cfg):
self.args = args
self.cfg = cfg
cfg.exp_name = args.exp_name
self._init_accelerator()
self.accelerator.wait_for_everyone()
# Init logger
with self.accelerator.main_process_first():
if self.accelerator.is_main_process:
os.makedirs(os.path.join(self.exp_dir, "checkpoint"), exist_ok=True)
self.log_file = os.path.join(
os.path.join(self.exp_dir, "checkpoint"), "train.log"
)
self.logger = Logger(self.log_file, level=self.args.log_level).logger
self.time_window = ValueWindow(50)
if self.accelerator.is_main_process:
# Log some info
self.logger.info("=" * 56)
self.logger.info("||\t\t" + "New training process started." + "\t\t||")
self.logger.info("=" * 56)
self.logger.info("\n")
self.logger.debug(f"Using {args.log_level.upper()} logging level.")
self.logger.info(f"Experiment name: {args.exp_name}")
self.logger.info(f"Experiment directory: {self.exp_dir}")
self.checkpoint_dir = os.path.join(self.exp_dir, "checkpoint")
if self.accelerator.is_main_process:
os.makedirs(self.checkpoint_dir, exist_ok=True)
if self.accelerator.is_main_process:
self.logger.debug(f"Checkpoint directory: {self.checkpoint_dir}")
# init counts
self.batch_count: int = 0
self.step: int = 0
self.epoch: int = 0
self.max_epoch = (
self.cfg.train.max_epoch if self.cfg.train.max_epoch > 0 else float("inf")
)
if self.accelerator.is_main_process:
self.logger.info(
"Max epoch: {}".format(
self.max_epoch if self.max_epoch < float("inf") else "Unlimited"
)
)
# Check values
if self.accelerator.is_main_process:
self._check_basic_configs()
# Set runtime configs
self.save_checkpoint_stride = self.cfg.train.save_checkpoint_stride
self.checkpoints_path = [
[] for _ in range(len(self.save_checkpoint_stride))
]
self.keep_last = [
i if i > 0 else float("inf") for i in self.cfg.train.keep_last
]
self.run_eval = self.cfg.train.run_eval
# set random seed
with self.accelerator.main_process_first():
start = time.monotonic_ns()
self._set_random_seed(self.cfg.train.random_seed)
end = time.monotonic_ns()
if self.accelerator.is_main_process:
self.logger.debug(
f"Setting random seed done in {(end - start) / 1e6:.2f}ms"
)
self.logger.debug(f"Random seed: {self.cfg.train.random_seed}")
# setup data_loader
with self.accelerator.main_process_first():
if self.accelerator.is_main_process:
self.logger.info("Building dataset...")
start = time.monotonic_ns()
self.train_dataloader, self.valid_dataloader = self._build_dataloader()
end = time.monotonic_ns()
if self.accelerator.is_main_process:
self.logger.info(
f"Building dataset done in {(end - start) / 1e6:.2f}ms"
)
# setup model
with self.accelerator.main_process_first():
if self.accelerator.is_main_process:
self.logger.info("Building model...")
start = time.monotonic_ns()
self.model = self._build_model()
end = time.monotonic_ns()
if self.accelerator.is_main_process:
self.logger.debug(self.model)
self.logger.info(f"Building model done in {(end - start) / 1e6:.2f}ms")
self.logger.info(
f"Model parameters: {self._count_parameters(self.model)/1e6:.2f}M"
)
# optimizer & scheduler
with self.accelerator.main_process_first():
if self.accelerator.is_main_process:
self.logger.info("Building optimizer and scheduler...")
start = time.monotonic_ns()
self.optimizer = self._build_optimizer()
self.scheduler = self._build_scheduler()
end = time.monotonic_ns()
if self.accelerator.is_main_process:
self.logger.info(
f"Building optimizer and scheduler done in {(end - start) / 1e6:.2f}ms"
)
# accelerate prepare
if not self.cfg.train.use_dynamic_batchsize:
if self.accelerator.is_main_process:
self.logger.info("Initializing accelerate...")
start = time.monotonic_ns()
(
self.train_dataloader,
self.valid_dataloader,
) = self.accelerator.prepare(
self.train_dataloader,
self.valid_dataloader,
)
if isinstance(self.model, dict):
for key in self.model.keys():
self.model[key] = self.accelerator.prepare(self.model[key])
else:
self.model = self.accelerator.prepare(self.model)
if isinstance(self.optimizer, dict):
for key in self.optimizer.keys():
self.optimizer[key] = self.accelerator.prepare(self.optimizer[key])
else:
self.optimizer = self.accelerator.prepare(self.optimizer)
if isinstance(self.scheduler, dict):
for key in self.scheduler.keys():
self.scheduler[key] = self.accelerator.prepare(self.scheduler[key])
else:
self.scheduler = self.accelerator.prepare(self.scheduler)
end = time.monotonic_ns()
if self.accelerator.is_main_process:
self.logger.info(
f"Initializing accelerate done in {(end - start) / 1e6:.2f}ms"
)
# create criterion
with self.accelerator.main_process_first():
if self.accelerator.is_main_process:
self.logger.info("Building criterion...")
start = time.monotonic_ns()
self.criterion = self._build_criterion()
end = time.monotonic_ns()
if self.accelerator.is_main_process:
self.logger.info(
f"Building criterion done in {(end - start) / 1e6:.2f}ms"
)
# TODO: Resume from ckpt need test/debug
with self.accelerator.main_process_first():
if args.resume:
if self.accelerator.is_main_process:
self.logger.info("Resuming from checkpoint...")
start = time.monotonic_ns()
ckpt_path = self._load_model(
self.checkpoint_dir,
args.checkpoint_path,
resume_type=args.resume_type,
)
end = time.monotonic_ns()
if self.accelerator.is_main_process:
self.logger.info(
f"Resuming from checkpoint done in {(end - start) / 1e6:.2f}ms"
)
self.checkpoints_path = json.load(
open(os.path.join(ckpt_path, "ckpts.json"), "r")
)
self.checkpoint_dir = os.path.join(self.exp_dir, "checkpoint")
if self.accelerator.is_main_process:
os.makedirs(self.checkpoint_dir, exist_ok=True)
if self.accelerator.is_main_process:
self.logger.debug(f"Checkpoint directory: {self.checkpoint_dir}")
# save config file path
self.config_save_path = os.path.join(self.exp_dir, "args.json")
# Only for TTS tasks
self.task_type = "TTS"
if self.accelerator.is_main_process:
self.logger.info("Task type: {}".format(self.task_type))
def _init_accelerator(self):
self.exp_dir = os.path.join(
os.path.abspath(self.cfg.log_dir), self.args.exp_name
)
project_config = ProjectConfiguration(
project_dir=self.exp_dir,
logging_dir=os.path.join(self.exp_dir, "log"),
)
# ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
self.accelerator = accelerate.Accelerator(
gradient_accumulation_steps=self.cfg.train.gradient_accumulation_step,
log_with=self.cfg.train.tracker,
project_config=project_config,
# kwargs_handlers=[ddp_kwargs]
)
if self.accelerator.is_main_process:
os.makedirs(project_config.project_dir, exist_ok=True)
os.makedirs(project_config.logging_dir, exist_ok=True)
with self.accelerator.main_process_first():
self.accelerator.init_trackers(self.args.exp_name)
def _build_model(self):
model = NaturalSpeech2(cfg=self.cfg.model)
return model
def _build_dataset(self):
return NS2Dataset, NS2Collator
def _build_dataloader(self):
if self.cfg.train.use_dynamic_batchsize:
print("Use Dynamic Batchsize......")
Dataset, Collator = self._build_dataset()
train_dataset = Dataset(self.cfg, self.cfg.dataset[0], is_valid=False)
train_collate = Collator(self.cfg)
batch_sampler = batch_by_size(
train_dataset.num_frame_indices,
train_dataset.get_num_frames,
max_tokens=self.cfg.train.max_tokens * self.accelerator.num_processes,
max_sentences=self.cfg.train.max_sentences
* self.accelerator.num_processes,
required_batch_size_multiple=self.accelerator.num_processes,
)
np.random.seed(980205)
np.random.shuffle(batch_sampler)
print(batch_sampler[:1])
batches = [
x[
self.accelerator.local_process_index :: self.accelerator.num_processes
]
for x in batch_sampler
if len(x) % self.accelerator.num_processes == 0
]
train_loader = DataLoader(
train_dataset,
collate_fn=train_collate,
num_workers=self.cfg.train.dataloader.num_worker,
batch_sampler=VariableSampler(
batches, drop_last=False, use_random_sampler=True
),
pin_memory=self.cfg.train.dataloader.pin_memory,
)
self.accelerator.wait_for_everyone()
valid_dataset = Dataset(self.cfg, self.cfg.dataset[0], is_valid=True)
valid_collate = Collator(self.cfg)
batch_sampler = batch_by_size(
valid_dataset.num_frame_indices,
valid_dataset.get_num_frames,
max_tokens=self.cfg.train.max_tokens * self.accelerator.num_processes,
max_sentences=self.cfg.train.max_sentences
* self.accelerator.num_processes,
required_batch_size_multiple=self.accelerator.num_processes,
)
batches = [
x[
self.accelerator.local_process_index :: self.accelerator.num_processes
]
for x in batch_sampler
if len(x) % self.accelerator.num_processes == 0
]
valid_loader = DataLoader(
valid_dataset,
collate_fn=valid_collate,
num_workers=self.cfg.train.dataloader.num_worker,
batch_sampler=VariableSampler(batches, drop_last=False),
pin_memory=self.cfg.train.dataloader.pin_memory,
)
self.accelerator.wait_for_everyone()
else:
print("Use Normal Batchsize......")
Dataset, Collator = self._build_dataset()
train_dataset = Dataset(self.cfg, self.cfg.dataset[0], is_valid=False)
train_collate = Collator(self.cfg)
train_loader = DataLoader(
train_dataset,
shuffle=True,
collate_fn=train_collate,
batch_size=self.cfg.train.batch_size,
num_workers=self.cfg.train.dataloader.num_worker,
pin_memory=self.cfg.train.dataloader.pin_memory,
)
valid_dataset = Dataset(self.cfg, self.cfg.dataset[0], is_valid=True)
valid_collate = Collator(self.cfg)
valid_loader = DataLoader(
valid_dataset,
shuffle=True,
collate_fn=valid_collate,
batch_size=self.cfg.train.batch_size,
num_workers=self.cfg.train.dataloader.num_worker,
pin_memory=self.cfg.train.dataloader.pin_memory,
)
self.accelerator.wait_for_everyone()
return train_loader, valid_loader
def _build_optimizer(self):
optimizer = torch.optim.AdamW(
filter(lambda p: p.requires_grad, self.model.parameters()),
**self.cfg.train.adam,
)
return optimizer
def _build_scheduler(self):
lr_scheduler = get_scheduler(
self.cfg.train.lr_scheduler,
optimizer=self.optimizer,
num_warmup_steps=self.cfg.train.lr_warmup_steps,
num_training_steps=self.cfg.train.num_train_steps,
)
return lr_scheduler
def _build_criterion(self):
criterion = torch.nn.L1Loss(reduction="mean")
return criterion
def write_summary(self, losses, stats):
for key, value in losses.items():
self.sw.add_scalar(key, value, self.step)
def write_valid_summary(self, losses, stats):
for key, value in losses.items():
self.sw.add_scalar(key, value, self.step)
def get_state_dict(self):
state_dict = {
"model": self.model.state_dict(),
"optimizer": self.optimizer.state_dict(),
"scheduler": self.scheduler.state_dict(),
"step": self.step,
"epoch": self.epoch,
"batch_size": self.cfg.train.batch_size,
}
return state_dict
def load_model(self, checkpoint):
self.step = checkpoint["step"]
self.epoch = checkpoint["epoch"]
self.model.load_state_dict(checkpoint["model"])
self.optimizer.load_state_dict(checkpoint["optimizer"])
self.scheduler.load_state_dict(checkpoint["scheduler"])
def _train_step(self, batch):
train_losses = {}
total_loss = 0
train_stats = {}
code = batch["code"] # (B, 16, T)
pitch = batch["pitch"] # (B, T)
duration = batch["duration"] # (B, N)
phone_id = batch["phone_id"] # (B, N)
ref_code = batch["ref_code"] # (B, 16, T')
phone_mask = batch["phone_mask"] # (B, N)
mask = batch["mask"] # (B, T)
ref_mask = batch["ref_mask"] # (B, T')
diff_out, prior_out = self.model(
code=code,
pitch=pitch,
duration=duration,
phone_id=phone_id,
ref_code=ref_code,
phone_mask=phone_mask,
mask=mask,
ref_mask=ref_mask,
)
# pitch loss
pitch_loss = log_pitch_loss(prior_out["pitch_pred_log"], pitch, mask=mask)
total_loss += pitch_loss
train_losses["pitch_loss"] = pitch_loss
# duration loss
dur_loss = log_dur_loss(prior_out["dur_pred_log"], duration, mask=phone_mask)
total_loss += dur_loss
train_losses["dur_loss"] = dur_loss
x0 = self.model.module.code_to_latent(code)
if self.cfg.model.diffusion.diffusion_type == "diffusion":
# diff loss x0 | diff_loss_x0 = diff_loss(diff_out["x0_pred"], x0, mask=mask) | 10 | 2023-11-15 09:19:27+00:00 | 24k |
BobaZooba/xllm | tests/unit/core/test_dependencies.py | [
{
"identifier": "LMCollator",
"path": "src/xllm/collators/lm.py",
"snippet": "class LMCollator(BaseCollator):\n \"\"\"\n `LMCollator` is a data collator class specifically designed to prepare batches of data for language modeling tasks.\n Extending the `BaseCollator`, it adapts the general data... | import pytest
from peft import PeftModel
from pytest import MonkeyPatch
from torch import Tensor
from transformers import (
BitsAndBytesConfig,
GPTQConfig,
PreTrainedTokenizer,
TrainingArguments,
)
from src.xllm.collators.lm import LMCollator
from src.xllm.collators.registry import collators_registry
from src.xllm.core.config import Config
from src.xllm.core.dependencies import (
build_collator,
build_dataset,
build_model,
build_quantization_config,
build_tokenizer,
build_trainer,
build_training_arguments,
)
from src.xllm.datasets.registry import datasets_registry
from src.xllm.datasets.soda import SodaDataset
from src.xllm.trainers.registry import trainers_registry
from tests.helpers.constants import LLAMA_TOKENIZER_DIR
from tests.helpers.dummy_data import DATA, DummyDataset
from tests.helpers.patches import patch_from_pretrained_auto_causal_lm | 18,389 | # Copyright 2023 Boris Zubarev. 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.
def test_build_training_arguments(config: Config):
arguments = build_training_arguments(config=config)
assert arguments.per_device_train_batch_size == config.per_device_train_batch_size
assert arguments.deepspeed is None
def test_build_dataset_train(path_to_train_dummy_data: str):
| # Copyright 2023 Boris Zubarev. 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.
def test_build_training_arguments(config: Config):
arguments = build_training_arguments(config=config)
assert arguments.per_device_train_batch_size == config.per_device_train_batch_size
assert arguments.deepspeed is None
def test_build_dataset_train(path_to_train_dummy_data: str): | datasets_registry.add(key="dummy", value=DummyDataset) | 15 | 2023-11-10 17:55:03+00:00 | 24k |
AMAAI-Lab/mustango | diffusers/src/diffusers/models/unet_2d_blocks.py | [
{
"identifier": "AdaGroupNorm",
"path": "diffusers/src/diffusers/models/attention.py",
"snippet": "class AdaGroupNorm(nn.Module):\n \"\"\"\n GroupNorm layer modified to incorporate timestep embeddings.\n \"\"\"\n\n def __init__(\n self, embedding_dim: int, out_dim: int, num_groups: in... | from typing import Any, Dict, Optional, Tuple
from torch import nn
from .attention import AdaGroupNorm, AttentionBlock
from .attention_processor import Attention, AttnAddedKVProcessor
from .dual_transformer_2d import DualTransformer2DModel
from .resnet import Downsample2D, FirDownsample2D, FirUpsample2D, KDownsample2D, KUpsample2D, ResnetBlock2D, Upsample2D
from .transformer_2d import Transformer2DModel, Transformer2DModelOutput
import numpy as np
import torch | 18,209 |
class AttnUpDecoderBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=1.0,
add_upsample=True,
):
super().__init__()
resnets = []
attentions = []
for i in range(num_layers):
input_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=input_channels,
out_channels=out_channels,
temb_channels=None,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
attentions.append(
AttentionBlock(
out_channels,
num_head_channels=attn_num_head_channels,
rescale_output_factor=output_scale_factor,
eps=resnet_eps,
norm_num_groups=resnet_groups,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
if add_upsample:
self.upsamplers = nn.ModuleList([Upsample2D(out_channels, use_conv=True, out_channels=out_channels)])
else:
self.upsamplers = None
def forward(self, hidden_states):
for resnet, attn in zip(self.resnets, self.attentions):
hidden_states = resnet(hidden_states, temb=None)
hidden_states = attn(hidden_states)
if self.upsamplers is not None:
for upsampler in self.upsamplers:
hidden_states = upsampler(hidden_states)
return hidden_states
class AttnSkipUpBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
prev_output_channel: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=np.sqrt(2.0),
upsample_padding=1,
add_upsample=True,
):
super().__init__()
self.attentions = nn.ModuleList([])
self.resnets = nn.ModuleList([])
for i in range(num_layers):
res_skip_channels = in_channels if (i == num_layers - 1) else out_channels
resnet_in_channels = prev_output_channel if i == 0 else out_channels
self.resnets.append(
ResnetBlock2D(
in_channels=resnet_in_channels + res_skip_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=min(resnet_in_channels + res_skip_channels // 4, 32),
groups_out=min(out_channels // 4, 32),
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.attentions.append(
AttentionBlock(
out_channels,
num_head_channels=attn_num_head_channels,
rescale_output_factor=output_scale_factor,
eps=resnet_eps,
)
)
| # 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.
def get_down_block(
down_block_type,
num_layers,
in_channels,
out_channels,
temb_channels,
add_downsample,
resnet_eps,
resnet_act_fn,
attn_num_head_channels,
resnet_groups=None,
cross_attention_dim=None,
downsample_padding=None,
dual_cross_attention=False,
use_linear_projection=False,
only_cross_attention=False,
upcast_attention=False,
resnet_time_scale_shift="default",
):
down_block_type = down_block_type[7:] if down_block_type.startswith("UNetRes") else down_block_type
if down_block_type == "DownBlock2D":
return DownBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
downsample_padding=downsample_padding,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "ResnetDownsampleBlock2D":
return ResnetDownsampleBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "AttnDownBlock2D":
return AttnDownBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
downsample_padding=downsample_padding,
attn_num_head_channels=attn_num_head_channels,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "CrossAttnDownBlock2D":
if cross_attention_dim is None:
raise ValueError("cross_attention_dim must be specified for CrossAttnDownBlock2D")
return CrossAttnDownBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
downsample_padding=downsample_padding,
cross_attention_dim=cross_attention_dim,
attn_num_head_channels=attn_num_head_channels,
dual_cross_attention=dual_cross_attention,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "CrossAttnDownBlock2DMusic":
if cross_attention_dim is None:
raise ValueError("cross_attention_dim must be specified for CrossAttnDownBlock2D")
return CrossAttnDownBlock2DMusic(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
downsample_padding=downsample_padding,
cross_attention_dim=cross_attention_dim,
attn_num_head_channels=attn_num_head_channels,
dual_cross_attention=dual_cross_attention,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "SimpleCrossAttnDownBlock2D":
if cross_attention_dim is None:
raise ValueError("cross_attention_dim must be specified for SimpleCrossAttnDownBlock2D")
return SimpleCrossAttnDownBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
cross_attention_dim=cross_attention_dim,
attn_num_head_channels=attn_num_head_channels,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "SkipDownBlock2D":
return SkipDownBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
downsample_padding=downsample_padding,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "AttnSkipDownBlock2D":
return AttnSkipDownBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
downsample_padding=downsample_padding,
attn_num_head_channels=attn_num_head_channels,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "DownEncoderBlock2D":
return DownEncoderBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
downsample_padding=downsample_padding,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "AttnDownEncoderBlock2D":
return AttnDownEncoderBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
downsample_padding=downsample_padding,
attn_num_head_channels=attn_num_head_channels,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif down_block_type == "KDownBlock2D":
return KDownBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
)
elif down_block_type == "KCrossAttnDownBlock2D":
return KCrossAttnDownBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_downsample=add_downsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
cross_attention_dim=cross_attention_dim,
attn_num_head_channels=attn_num_head_channels,
add_self_attention=True if not add_downsample else False,
)
raise ValueError(f"{down_block_type} does not exist.")
def get_up_block(
up_block_type,
num_layers,
in_channels,
out_channels,
prev_output_channel,
temb_channels,
add_upsample,
resnet_eps,
resnet_act_fn,
attn_num_head_channels,
resnet_groups=None,
cross_attention_dim=None,
dual_cross_attention=False,
use_linear_projection=False,
only_cross_attention=False,
upcast_attention=False,
resnet_time_scale_shift="default",
):
up_block_type = up_block_type[7:] if up_block_type.startswith("UNetRes") else up_block_type
if up_block_type == "UpBlock2D":
return UpBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
prev_output_channel=prev_output_channel,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "ResnetUpsampleBlock2D":
return ResnetUpsampleBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
prev_output_channel=prev_output_channel,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "CrossAttnUpBlock2D":
if cross_attention_dim is None:
raise ValueError("cross_attention_dim must be specified for CrossAttnUpBlock2D")
return CrossAttnUpBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
prev_output_channel=prev_output_channel,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
cross_attention_dim=cross_attention_dim,
attn_num_head_channels=attn_num_head_channels,
dual_cross_attention=dual_cross_attention,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "CrossAttnUpBlock2DMusic":
if cross_attention_dim is None:
raise ValueError("cross_attention_dim must be specified for CrossAttnUpBlock2D")
return CrossAttnUpBlock2DMusic(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
prev_output_channel=prev_output_channel,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
cross_attention_dim=cross_attention_dim,
attn_num_head_channels=attn_num_head_channels,
dual_cross_attention=dual_cross_attention,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "SimpleCrossAttnUpBlock2D":
if cross_attention_dim is None:
raise ValueError("cross_attention_dim must be specified for SimpleCrossAttnUpBlock2D")
return SimpleCrossAttnUpBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
prev_output_channel=prev_output_channel,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
cross_attention_dim=cross_attention_dim,
attn_num_head_channels=attn_num_head_channels,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "AttnUpBlock2D":
return AttnUpBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
prev_output_channel=prev_output_channel,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
attn_num_head_channels=attn_num_head_channels,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "SkipUpBlock2D":
return SkipUpBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
prev_output_channel=prev_output_channel,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "AttnSkipUpBlock2D":
return AttnSkipUpBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
prev_output_channel=prev_output_channel,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
attn_num_head_channels=attn_num_head_channels,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "UpDecoderBlock2D":
return UpDecoderBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "AttnUpDecoderBlock2D":
return AttnUpDecoderBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
resnet_groups=resnet_groups,
attn_num_head_channels=attn_num_head_channels,
resnet_time_scale_shift=resnet_time_scale_shift,
)
elif up_block_type == "KUpBlock2D":
return KUpBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
)
elif up_block_type == "KCrossAttnUpBlock2D":
return KCrossAttnUpBlock2D(
num_layers=num_layers,
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
add_upsample=add_upsample,
resnet_eps=resnet_eps,
resnet_act_fn=resnet_act_fn,
cross_attention_dim=cross_attention_dim,
attn_num_head_channels=attn_num_head_channels,
)
raise ValueError(f"{up_block_type} does not exist.")
class UNetMidBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
add_attention: bool = True,
attn_num_head_channels=1,
output_scale_factor=1.0,
):
super().__init__()
resnet_groups = resnet_groups if resnet_groups is not None else min(in_channels // 4, 32)
self.add_attention = add_attention
# there is always at least one resnet
resnets = [
ResnetBlock2D(
in_channels=in_channels,
out_channels=in_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
]
attentions = []
for _ in range(num_layers):
if self.add_attention:
attentions.append(
AttentionBlock(
in_channels,
num_head_channels=attn_num_head_channels,
rescale_output_factor=output_scale_factor,
eps=resnet_eps,
norm_num_groups=resnet_groups,
)
)
else:
attentions.append(None)
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=in_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
def forward(self, hidden_states, temb=None):
hidden_states = self.resnets[0](hidden_states, temb)
for attn, resnet in zip(self.attentions, self.resnets[1:]):
if attn is not None:
hidden_states = attn(hidden_states)
hidden_states = resnet(hidden_states, temb)
return hidden_states
class UNetMidBlock2DCrossAttn(nn.Module):
def __init__(
self,
in_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=1.0,
cross_attention_dim=1280,
dual_cross_attention=False,
use_linear_projection=False,
upcast_attention=False,
):
super().__init__()
self.has_cross_attention = True
self.attn_num_head_channels = attn_num_head_channels
resnet_groups = resnet_groups if resnet_groups is not None else min(in_channels // 4, 32)
# there is always at least one resnet
resnets = [
ResnetBlock2D(
in_channels=in_channels,
out_channels=in_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
]
attentions = []
for _ in range(num_layers):
if not dual_cross_attention:
attentions.append(
Transformer2DModel(
attn_num_head_channels,
in_channels // attn_num_head_channels,
in_channels=in_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
upcast_attention=upcast_attention,
)
)
else:
attentions.append(
DualTransformer2DModel(
attn_num_head_channels,
in_channels // attn_num_head_channels,
in_channels=in_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
)
)
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=in_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
def forward(
self,
hidden_states: torch.FloatTensor,
temb: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.FloatTensor] = None,
attention_mask: Optional[torch.FloatTensor] = None,
cross_attention_kwargs: Optional[Dict[str, Any]] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
) -> torch.FloatTensor:
hidden_states = self.resnets[0](hidden_states, temb)
for attn, resnet in zip(self.attentions, self.resnets[1:]):
output: Transformer2DModelOutput = attn(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=encoder_attention_mask,
)
hidden_states = output.sample
hidden_states = resnet(hidden_states, temb)
return hidden_states
class UNetMidBlock2DCrossAttnMusic(nn.Module):
def __init__(
self,
in_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=1.0,
cross_attention_dim=1280,
dual_cross_attention=False,
use_linear_projection=False,
upcast_attention=False,
):
super().__init__()
self.has_cross_attention = True
self.attn_num_head_channels = attn_num_head_channels
resnet_groups = resnet_groups if resnet_groups is not None else min(in_channels // 4, 32)
# there is always at least one resnet
resnets = [
ResnetBlock2D(
in_channels=in_channels,
out_channels=in_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
]
attentions = []
attentions2 = []
attentions3 = []
for _ in range(num_layers):
if not dual_cross_attention:
attentions.append(
Transformer2DModel(
attn_num_head_channels,
in_channels // attn_num_head_channels,
in_channels=in_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
upcast_attention=upcast_attention,
)
)
attentions2.append(
Transformer2DModel(
attn_num_head_channels,
in_channels // attn_num_head_channels,
in_channels=in_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
upcast_attention=upcast_attention,
)
)
attentions3.append(
Transformer2DModel(
attn_num_head_channels,
in_channels // attn_num_head_channels,
in_channels=in_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
upcast_attention=upcast_attention,
)
)
else:
attentions.append(
DualTransformer2DModel(
attn_num_head_channels,
in_channels // attn_num_head_channels,
in_channels=in_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
)
)
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=in_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.attentions = nn.ModuleList(attentions)
self.attentions2 = nn.ModuleList(attentions2)
self.attentions3 = nn.ModuleList(attentions3)
self.resnets = nn.ModuleList(resnets)
def forward(
self,
hidden_states: torch.FloatTensor,
temb: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.FloatTensor] = None,
beat_features = None,
chord_features = None,
attention_mask: Optional[torch.FloatTensor] = None,
cross_attention_kwargs: Optional[Dict[str, Any]] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
beat_attention_mask = None,
chord_attention_mask = None
) -> torch.FloatTensor:
hidden_states = self.resnets[0](hidden_states, temb)
for attn, attn2, attn3, resnet in zip(self.attentions, self.attentions2,self.attentions3, self.resnets[1:]):
output: Transformer2DModelOutput = attn(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=encoder_attention_mask,
)
hidden_states = output.sample
hidden_states = attn2(
hidden_states,
encoder_hidden_states=beat_features,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=beat_attention_mask,
).sample
hidden_states = attn3(
hidden_states,
encoder_hidden_states=chord_features,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=chord_attention_mask,
).sample
hidden_states = resnet(hidden_states, temb)
return hidden_states
class UNetMidBlock2DSimpleCrossAttn(nn.Module):
def __init__(
self,
in_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=1.0,
cross_attention_dim=1280,
):
super().__init__()
self.has_cross_attention = True
self.attn_num_head_channels = attn_num_head_channels
resnet_groups = resnet_groups if resnet_groups is not None else min(in_channels // 4, 32)
self.num_heads = in_channels // self.attn_num_head_channels
# there is always at least one resnet
resnets = [
ResnetBlock2D(
in_channels=in_channels,
out_channels=in_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
]
attentions = []
for _ in range(num_layers):
attentions.append(
Attention(
query_dim=in_channels,
cross_attention_dim=in_channels,
heads=self.num_heads,
dim_head=attn_num_head_channels,
added_kv_proj_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
bias=True,
upcast_softmax=True,
processor=AttnAddedKVProcessor(),
)
)
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=in_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
def forward(
self, hidden_states, temb=None, encoder_hidden_states=None, attention_mask=None, cross_attention_kwargs=None
):
cross_attention_kwargs = cross_attention_kwargs if cross_attention_kwargs is not None else {}
hidden_states = self.resnets[0](hidden_states, temb)
for attn, resnet in zip(self.attentions, self.resnets[1:]):
# attn
hidden_states = attn(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
attention_mask=attention_mask,
**cross_attention_kwargs,
)
# resnet
hidden_states = resnet(hidden_states, temb)
return hidden_states
class AttnDownBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=1.0,
downsample_padding=1,
add_downsample=True,
):
super().__init__()
resnets = []
attentions = []
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
attentions.append(
AttentionBlock(
out_channels,
num_head_channels=attn_num_head_channels,
rescale_output_factor=output_scale_factor,
eps=resnet_eps,
norm_num_groups=resnet_groups,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
if add_downsample:
self.downsamplers = nn.ModuleList(
[
Downsample2D(
out_channels, use_conv=True, out_channels=out_channels, padding=downsample_padding, name="op"
)
]
)
else:
self.downsamplers = None
def forward(self, hidden_states, temb=None):
output_states = ()
for resnet, attn in zip(self.resnets, self.attentions):
hidden_states = resnet(hidden_states, temb)
hidden_states = attn(hidden_states)
output_states += (hidden_states,)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states)
output_states += (hidden_states,)
return hidden_states, output_states
class CrossAttnDownBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
cross_attention_dim=1280,
output_scale_factor=1.0,
downsample_padding=1,
add_downsample=True,
dual_cross_attention=False,
use_linear_projection=False,
only_cross_attention=False,
upcast_attention=False,
):
super().__init__()
resnets = []
attentions = []
self.has_cross_attention = True
self.attn_num_head_channels = attn_num_head_channels
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
if not dual_cross_attention:
attentions.append(
Transformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
)
)
else:
attentions.append(
DualTransformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
if add_downsample:
self.downsamplers = nn.ModuleList(
[
Downsample2D(
out_channels, use_conv=True, out_channels=out_channels, padding=downsample_padding, name="op"
)
]
)
else:
self.downsamplers = None
self.gradient_checkpointing = False
def forward(
self,
hidden_states: torch.FloatTensor,
temb: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.FloatTensor] = None,
attention_mask: Optional[torch.FloatTensor] = None,
cross_attention_kwargs: Optional[Dict[str, Any]] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
):
output_states = ()
for resnet, attn in zip(self.resnets, self.attentions):
if self.training and self.gradient_checkpointing:
def create_custom_forward(module, return_dict=None):
def custom_forward(*inputs):
if return_dict is not None:
return module(*inputs, return_dict=return_dict)
else:
return module(*inputs)
return custom_forward
hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
hidden_states = torch.utils.checkpoint.checkpoint(
create_custom_forward(attn, return_dict=False),
hidden_states,
encoder_hidden_states,
None, # timestep
None, # class_labels
cross_attention_kwargs,
attention_mask,
encoder_attention_mask,
)[0]
else:
hidden_states = resnet(hidden_states, temb)
hidden_states = attn(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=encoder_attention_mask,
).sample
output_states += (hidden_states,)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states)
output_states += (hidden_states,)
return hidden_states, output_states
class CrossAttnDownBlock2DMusic(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
cross_attention_dim=1280,
output_scale_factor=1.0,
downsample_padding=1,
add_downsample=True,
dual_cross_attention=False,
use_linear_projection=False,
only_cross_attention=False,
upcast_attention=False,
):
super().__init__()
resnets = []
attentions = []
attentions2 = []
attentions3 = []
self.has_cross_attention = True
self.attn_num_head_channels = attn_num_head_channels
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
if not dual_cross_attention:
attentions.append(
Transformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
))
attentions2.append(
Transformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
))
attentions3.append(
Transformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
)
)
else:
attentions.append(
DualTransformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
)
)
self.attentions = nn.ModuleList(attentions)
self.attentions2 = nn.ModuleList(attentions2)
self.attentions3 = nn.ModuleList(attentions3)
self.resnets = nn.ModuleList(resnets)
if add_downsample:
self.downsamplers = nn.ModuleList(
[
Downsample2D(
out_channels, use_conv=True, out_channels=out_channels, padding=downsample_padding, name="op"
)
]
)
else:
self.downsamplers = None
self.gradient_checkpointing = False
def forward(
self,
hidden_states: torch.FloatTensor,
temb: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.FloatTensor] = None,
beat_features = None,
chord_features = None,
attention_mask: Optional[torch.FloatTensor] = None,
cross_attention_kwargs: Optional[Dict[str, Any]] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
beat_attention_mask = None,
chord_attention_mask = None
):
output_states = ()
for resnet, attn, attn2, attn3 in zip(self.resnets, self.attentions, self.attentions2, self.attentions3):
if self.training and self.gradient_checkpointing:
def create_custom_forward(module, return_dict=None):
def custom_forward(*inputs):
if return_dict is not None:
return module(*inputs, return_dict=return_dict)
else:
return module(*inputs)
return custom_forward
hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
hidden_states = torch.utils.checkpoint.checkpoint(
create_custom_forward(attn, return_dict=False),
hidden_states,
encoder_hidden_states,
None, # timestep
None, # class_labels
cross_attention_kwargs,
attention_mask,
encoder_attention_mask,
)[0]
else:
# print("checking downsampling shape", encoder_hidden_states.shape, beat_features.shape, chord_features.shape, encoder_attention_mask.shape, beat_attention_mask.shape, chord_attention_mask.shape)
hidden_states = resnet(hidden_states, temb)
hidden_states = attn(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=encoder_attention_mask,
).sample
hidden_states = attn2(
hidden_states,
encoder_hidden_states=beat_features,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=beat_attention_mask,
).sample
hidden_states = attn3(
hidden_states,
encoder_hidden_states=chord_features,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=chord_attention_mask,
).sample
output_states += (hidden_states,)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states)
output_states += (hidden_states,)
return hidden_states, output_states
class DownBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
output_scale_factor=1.0,
add_downsample=True,
downsample_padding=1,
):
super().__init__()
resnets = []
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.resnets = nn.ModuleList(resnets)
if add_downsample:
self.downsamplers = nn.ModuleList(
[
Downsample2D(
out_channels, use_conv=True, out_channels=out_channels, padding=downsample_padding, name="op"
)
]
)
else:
self.downsamplers = None
self.gradient_checkpointing = False
def forward(self, hidden_states, temb=None):
output_states = ()
for resnet in self.resnets:
if self.training and self.gradient_checkpointing:
def create_custom_forward(module):
def custom_forward(*inputs):
return module(*inputs)
return custom_forward
hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
else:
hidden_states = resnet(hidden_states, temb)
output_states += (hidden_states,)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states)
output_states += (hidden_states,)
return hidden_states, output_states
class DownEncoderBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
output_scale_factor=1.0,
add_downsample=True,
downsample_padding=1,
):
super().__init__()
resnets = []
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=None,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.resnets = nn.ModuleList(resnets)
if add_downsample:
self.downsamplers = nn.ModuleList(
[
Downsample2D(
out_channels, use_conv=True, out_channels=out_channels, padding=downsample_padding, name="op"
)
]
)
else:
self.downsamplers = None
def forward(self, hidden_states):
for resnet in self.resnets:
hidden_states = resnet(hidden_states, temb=None)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states)
return hidden_states
class AttnDownEncoderBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=1.0,
add_downsample=True,
downsample_padding=1,
):
super().__init__()
resnets = []
attentions = []
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=None,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
attentions.append(
AttentionBlock(
out_channels,
num_head_channels=attn_num_head_channels,
rescale_output_factor=output_scale_factor,
eps=resnet_eps,
norm_num_groups=resnet_groups,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
if add_downsample:
self.downsamplers = nn.ModuleList(
[
Downsample2D(
out_channels, use_conv=True, out_channels=out_channels, padding=downsample_padding, name="op"
)
]
)
else:
self.downsamplers = None
def forward(self, hidden_states):
for resnet, attn in zip(self.resnets, self.attentions):
hidden_states = resnet(hidden_states, temb=None)
hidden_states = attn(hidden_states)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states)
return hidden_states
class AttnSkipDownBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=np.sqrt(2.0),
downsample_padding=1,
add_downsample=True,
):
super().__init__()
self.attentions = nn.ModuleList([])
self.resnets = nn.ModuleList([])
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
self.resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=min(in_channels // 4, 32),
groups_out=min(out_channels // 4, 32),
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.attentions.append(
AttentionBlock(
out_channels,
num_head_channels=attn_num_head_channels,
rescale_output_factor=output_scale_factor,
eps=resnet_eps,
)
)
if add_downsample:
self.resnet_down = ResnetBlock2D(
in_channels=out_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=min(out_channels // 4, 32),
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
use_in_shortcut=True,
down=True,
kernel="fir",
)
self.downsamplers = nn.ModuleList([FirDownsample2D(out_channels, out_channels=out_channels)])
self.skip_conv = nn.Conv2d(3, out_channels, kernel_size=(1, 1), stride=(1, 1))
else:
self.resnet_down = None
self.downsamplers = None
self.skip_conv = None
def forward(self, hidden_states, temb=None, skip_sample=None):
output_states = ()
for resnet, attn in zip(self.resnets, self.attentions):
hidden_states = resnet(hidden_states, temb)
hidden_states = attn(hidden_states)
output_states += (hidden_states,)
if self.downsamplers is not None:
hidden_states = self.resnet_down(hidden_states, temb)
for downsampler in self.downsamplers:
skip_sample = downsampler(skip_sample)
hidden_states = self.skip_conv(skip_sample) + hidden_states
output_states += (hidden_states,)
return hidden_states, output_states, skip_sample
class SkipDownBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_pre_norm: bool = True,
output_scale_factor=np.sqrt(2.0),
add_downsample=True,
downsample_padding=1,
):
super().__init__()
self.resnets = nn.ModuleList([])
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
self.resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=min(in_channels // 4, 32),
groups_out=min(out_channels // 4, 32),
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
if add_downsample:
self.resnet_down = ResnetBlock2D(
in_channels=out_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=min(out_channels // 4, 32),
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
use_in_shortcut=True,
down=True,
kernel="fir",
)
self.downsamplers = nn.ModuleList([FirDownsample2D(out_channels, out_channels=out_channels)])
self.skip_conv = nn.Conv2d(3, out_channels, kernel_size=(1, 1), stride=(1, 1))
else:
self.resnet_down = None
self.downsamplers = None
self.skip_conv = None
def forward(self, hidden_states, temb=None, skip_sample=None):
output_states = ()
for resnet in self.resnets:
hidden_states = resnet(hidden_states, temb)
output_states += (hidden_states,)
if self.downsamplers is not None:
hidden_states = self.resnet_down(hidden_states, temb)
for downsampler in self.downsamplers:
skip_sample = downsampler(skip_sample)
hidden_states = self.skip_conv(skip_sample) + hidden_states
output_states += (hidden_states,)
return hidden_states, output_states, skip_sample
class ResnetDownsampleBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
output_scale_factor=1.0,
add_downsample=True,
):
super().__init__()
resnets = []
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.resnets = nn.ModuleList(resnets)
if add_downsample:
self.downsamplers = nn.ModuleList(
[
ResnetBlock2D(
in_channels=out_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
down=True,
)
]
)
else:
self.downsamplers = None
self.gradient_checkpointing = False
def forward(self, hidden_states, temb=None):
output_states = ()
for resnet in self.resnets:
if self.training and self.gradient_checkpointing:
def create_custom_forward(module):
def custom_forward(*inputs):
return module(*inputs)
return custom_forward
hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
else:
hidden_states = resnet(hidden_states, temb)
output_states += (hidden_states,)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states, temb)
output_states += (hidden_states,)
return hidden_states, output_states
class SimpleCrossAttnDownBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
cross_attention_dim=1280,
output_scale_factor=1.0,
add_downsample=True,
):
super().__init__()
self.has_cross_attention = True
resnets = []
attentions = []
self.attn_num_head_channels = attn_num_head_channels
self.num_heads = out_channels // self.attn_num_head_channels
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
attentions.append(
Attention(
query_dim=out_channels,
cross_attention_dim=out_channels,
heads=self.num_heads,
dim_head=attn_num_head_channels,
added_kv_proj_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
bias=True,
upcast_softmax=True,
processor=AttnAddedKVProcessor(),
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
if add_downsample:
self.downsamplers = nn.ModuleList(
[
ResnetBlock2D(
in_channels=out_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
down=True,
)
]
)
else:
self.downsamplers = None
self.gradient_checkpointing = False
def forward(
self, hidden_states, temb=None, encoder_hidden_states=None, attention_mask=None, cross_attention_kwargs=None
):
output_states = ()
cross_attention_kwargs = cross_attention_kwargs if cross_attention_kwargs is not None else {}
for resnet, attn in zip(self.resnets, self.attentions):
# resnet
hidden_states = resnet(hidden_states, temb)
# attn
hidden_states = attn(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
attention_mask=attention_mask,
**cross_attention_kwargs,
)
output_states += (hidden_states,)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states, temb)
output_states += (hidden_states,)
return hidden_states, output_states
class KDownBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 4,
resnet_eps: float = 1e-5,
resnet_act_fn: str = "gelu",
resnet_group_size: int = 32,
add_downsample=False,
):
super().__init__()
resnets = []
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
groups = in_channels // resnet_group_size
groups_out = out_channels // resnet_group_size
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
dropout=dropout,
temb_channels=temb_channels,
groups=groups,
groups_out=groups_out,
eps=resnet_eps,
non_linearity=resnet_act_fn,
time_embedding_norm="ada_group",
conv_shortcut_bias=False,
)
)
self.resnets = nn.ModuleList(resnets)
if add_downsample:
# YiYi's comments- might be able to use FirDownsample2D, look into details later
self.downsamplers = nn.ModuleList([KDownsample2D()])
else:
self.downsamplers = None
self.gradient_checkpointing = False
def forward(self, hidden_states, temb=None):
output_states = ()
for resnet in self.resnets:
if self.training and self.gradient_checkpointing:
def create_custom_forward(module):
def custom_forward(*inputs):
return module(*inputs)
return custom_forward
hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
else:
hidden_states = resnet(hidden_states, temb)
output_states += (hidden_states,)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states)
return hidden_states, output_states
class KCrossAttnDownBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
temb_channels: int,
cross_attention_dim: int,
dropout: float = 0.0,
num_layers: int = 4,
resnet_group_size: int = 32,
add_downsample=True,
attn_num_head_channels: int = 64,
add_self_attention: bool = False,
resnet_eps: float = 1e-5,
resnet_act_fn: str = "gelu",
):
super().__init__()
resnets = []
attentions = []
self.has_cross_attention = True
for i in range(num_layers):
in_channels = in_channels if i == 0 else out_channels
groups = in_channels // resnet_group_size
groups_out = out_channels // resnet_group_size
resnets.append(
ResnetBlock2D(
in_channels=in_channels,
out_channels=out_channels,
dropout=dropout,
temb_channels=temb_channels,
groups=groups,
groups_out=groups_out,
eps=resnet_eps,
non_linearity=resnet_act_fn,
time_embedding_norm="ada_group",
conv_shortcut_bias=False,
)
)
attentions.append(
KAttentionBlock(
out_channels,
out_channels // attn_num_head_channels,
attn_num_head_channels,
cross_attention_dim=cross_attention_dim,
temb_channels=temb_channels,
attention_bias=True,
add_self_attention=add_self_attention,
cross_attention_norm=True,
group_size=resnet_group_size,
)
)
self.resnets = nn.ModuleList(resnets)
self.attentions = nn.ModuleList(attentions)
if add_downsample:
self.downsamplers = nn.ModuleList([KDownsample2D()])
else:
self.downsamplers = None
self.gradient_checkpointing = False
def forward(
self, hidden_states, temb=None, encoder_hidden_states=None, attention_mask=None, cross_attention_kwargs=None
):
output_states = ()
for resnet, attn in zip(self.resnets, self.attentions):
if self.training and self.gradient_checkpointing:
def create_custom_forward(module, return_dict=None):
def custom_forward(*inputs):
if return_dict is not None:
return module(*inputs, return_dict=return_dict)
else:
return module(*inputs)
return custom_forward
hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
hidden_states = torch.utils.checkpoint.checkpoint(
create_custom_forward(attn, return_dict=False),
hidden_states,
encoder_hidden_states,
attention_mask,
cross_attention_kwargs,
)
else:
hidden_states = resnet(hidden_states, temb)
hidden_states = attn(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
emb=temb,
attention_mask=attention_mask,
cross_attention_kwargs=cross_attention_kwargs,
)
if self.downsamplers is None:
output_states += (None,)
else:
output_states += (hidden_states,)
if self.downsamplers is not None:
for downsampler in self.downsamplers:
hidden_states = downsampler(hidden_states)
return hidden_states, output_states
class AttnUpBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
prev_output_channel: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=1.0,
add_upsample=True,
):
super().__init__()
resnets = []
attentions = []
for i in range(num_layers):
res_skip_channels = in_channels if (i == num_layers - 1) else out_channels
resnet_in_channels = prev_output_channel if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=resnet_in_channels + res_skip_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
attentions.append(
AttentionBlock(
out_channels,
num_head_channels=attn_num_head_channels,
rescale_output_factor=output_scale_factor,
eps=resnet_eps,
norm_num_groups=resnet_groups,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
if add_upsample:
self.upsamplers = nn.ModuleList([Upsample2D(out_channels, use_conv=True, out_channels=out_channels)])
else:
self.upsamplers = None
def forward(self, hidden_states, res_hidden_states_tuple, temb=None):
for resnet, attn in zip(self.resnets, self.attentions):
# pop res hidden states
res_hidden_states = res_hidden_states_tuple[-1]
res_hidden_states_tuple = res_hidden_states_tuple[:-1]
hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
hidden_states = resnet(hidden_states, temb)
hidden_states = attn(hidden_states)
if self.upsamplers is not None:
for upsampler in self.upsamplers:
hidden_states = upsampler(hidden_states)
return hidden_states
class CrossAttnUpBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
prev_output_channel: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
cross_attention_dim=1280,
output_scale_factor=1.0,
add_upsample=True,
dual_cross_attention=False,
use_linear_projection=False,
only_cross_attention=False,
upcast_attention=False,
):
super().__init__()
resnets = []
attentions = []
self.has_cross_attention = True
self.attn_num_head_channels = attn_num_head_channels
for i in range(num_layers):
res_skip_channels = in_channels if (i == num_layers - 1) else out_channels
resnet_in_channels = prev_output_channel if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=resnet_in_channels + res_skip_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
if not dual_cross_attention:
attentions.append(
Transformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
)
)
else:
attentions.append(
DualTransformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
if add_upsample:
self.upsamplers = nn.ModuleList([Upsample2D(out_channels, use_conv=True, out_channels=out_channels)])
else:
self.upsamplers = None
self.gradient_checkpointing = False
def forward(
self,
hidden_states: torch.FloatTensor,
res_hidden_states_tuple: Tuple[torch.FloatTensor, ...],
temb: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.FloatTensor] = None,
cross_attention_kwargs: Optional[Dict[str, Any]] = None,
upsample_size: Optional[int] = None,
attention_mask: Optional[torch.FloatTensor] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
):
for resnet, attn in zip(self.resnets, self.attentions):
# pop res hidden states
res_hidden_states = res_hidden_states_tuple[-1]
res_hidden_states_tuple = res_hidden_states_tuple[:-1]
hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
if self.training and self.gradient_checkpointing:
def create_custom_forward(module, return_dict=None):
def custom_forward(*inputs):
if return_dict is not None:
return module(*inputs, return_dict=return_dict)
else:
return module(*inputs)
return custom_forward
hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
hidden_states = torch.utils.checkpoint.checkpoint(
create_custom_forward(attn, return_dict=False),
hidden_states,
encoder_hidden_states,
None, # timestep
None, # class_labels
cross_attention_kwargs,
attention_mask,
encoder_attention_mask,
)[0]
else:
hidden_states = resnet(hidden_states, temb)
hidden_states = attn(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=encoder_attention_mask,
).sample
if self.upsamplers is not None:
for upsampler in self.upsamplers:
hidden_states = upsampler(hidden_states, upsample_size)
return hidden_states
class CrossAttnUpBlock2DMusic(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
prev_output_channel: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
cross_attention_dim=1280,
output_scale_factor=1.0,
add_upsample=True,
dual_cross_attention=False,
use_linear_projection=False,
only_cross_attention=False,
upcast_attention=False,
):
super().__init__()
resnets = []
attentions = []
attentions2 = []
attentions3 = []
self.has_cross_attention = True
self.attn_num_head_channels = attn_num_head_channels
for i in range(num_layers):
res_skip_channels = in_channels if (i == num_layers - 1) else out_channels
resnet_in_channels = prev_output_channel if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=resnet_in_channels + res_skip_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
if not dual_cross_attention:
attentions.append(
Transformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
)
)
attentions2.append(
Transformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
)
)
attentions3.append(
Transformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
use_linear_projection=use_linear_projection,
only_cross_attention=only_cross_attention,
upcast_attention=upcast_attention,
)
)
else:
attentions.append(
DualTransformer2DModel(
attn_num_head_channels,
out_channels // attn_num_head_channels,
in_channels=out_channels,
num_layers=1,
cross_attention_dim=cross_attention_dim,
norm_num_groups=resnet_groups,
)
)
self.attentions = nn.ModuleList(attentions)
self.attentions2 = nn.ModuleList(attentions2)
self.attentions3 = nn.ModuleList(attentions3)
self.resnets = nn.ModuleList(resnets)
if add_upsample:
self.upsamplers = nn.ModuleList([Upsample2D(out_channels, use_conv=True, out_channels=out_channels)])
else:
self.upsamplers = None
self.gradient_checkpointing = False
def forward(
self,
hidden_states: torch.FloatTensor,
res_hidden_states_tuple: Tuple[torch.FloatTensor, ...],
temb: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.FloatTensor] = None,
beat_features = None,
chord_features = None,
cross_attention_kwargs: Optional[Dict[str, Any]] = None,
upsample_size: Optional[int] = None,
attention_mask: Optional[torch.FloatTensor] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
beat_attention_mask = None,
chord_attention_mask = None
):
for resnet, attn, attn2, attn3 in zip(self.resnets, self.attentions, self.attentions2,self.attentions3):
# pop res hidden states
res_hidden_states = res_hidden_states_tuple[-1]
res_hidden_states_tuple = res_hidden_states_tuple[:-1]
hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
if self.training and self.gradient_checkpointing:
def create_custom_forward(module, return_dict=None):
def custom_forward(*inputs):
if return_dict is not None:
return module(*inputs, return_dict=return_dict)
else:
return module(*inputs)
return custom_forward
hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
hidden_states = torch.utils.checkpoint.checkpoint(
create_custom_forward(attn, return_dict=False),
hidden_states,
encoder_hidden_states,
None, # timestep
None, # class_labels
cross_attention_kwargs,
attention_mask,
encoder_attention_mask,
)[0]
else:
hidden_states = resnet(hidden_states, temb)
hidden_states = attn(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=encoder_attention_mask,
).sample
hidden_states = attn2(
hidden_states,
encoder_hidden_states=beat_features,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=beat_attention_mask,
).sample
hidden_states = attn3(
hidden_states,
encoder_hidden_states=chord_features,
cross_attention_kwargs=cross_attention_kwargs,
attention_mask=attention_mask,
encoder_attention_mask=chord_attention_mask,
).sample
if self.upsamplers is not None:
for upsampler in self.upsamplers:
hidden_states = upsampler(hidden_states, upsample_size)
return hidden_states
class UpBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
prev_output_channel: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
output_scale_factor=1.0,
add_upsample=True,
):
super().__init__()
resnets = []
for i in range(num_layers):
res_skip_channels = in_channels if (i == num_layers - 1) else out_channels
resnet_in_channels = prev_output_channel if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=resnet_in_channels + res_skip_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.resnets = nn.ModuleList(resnets)
if add_upsample:
self.upsamplers = nn.ModuleList([Upsample2D(out_channels, use_conv=True, out_channels=out_channels)])
else:
self.upsamplers = None
self.gradient_checkpointing = False
def forward(self, hidden_states, res_hidden_states_tuple, temb=None, upsample_size=None):
for resnet in self.resnets:
# pop res hidden states
res_hidden_states = res_hidden_states_tuple[-1]
res_hidden_states_tuple = res_hidden_states_tuple[:-1]
hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)
if self.training and self.gradient_checkpointing:
def create_custom_forward(module):
def custom_forward(*inputs):
return module(*inputs)
return custom_forward
hidden_states = torch.utils.checkpoint.checkpoint(create_custom_forward(resnet), hidden_states, temb)
else:
hidden_states = resnet(hidden_states, temb)
if self.upsamplers is not None:
for upsampler in self.upsamplers:
hidden_states = upsampler(hidden_states, upsample_size)
return hidden_states
class UpDecoderBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
output_scale_factor=1.0,
add_upsample=True,
):
super().__init__()
resnets = []
for i in range(num_layers):
input_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=input_channels,
out_channels=out_channels,
temb_channels=None,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.resnets = nn.ModuleList(resnets)
if add_upsample:
self.upsamplers = nn.ModuleList([Upsample2D(out_channels, use_conv=True, out_channels=out_channels)])
else:
self.upsamplers = None
def forward(self, hidden_states):
for resnet in self.resnets:
hidden_states = resnet(hidden_states, temb=None)
if self.upsamplers is not None:
for upsampler in self.upsamplers:
hidden_states = upsampler(hidden_states)
return hidden_states
class AttnUpDecoderBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
out_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_groups: int = 32,
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=1.0,
add_upsample=True,
):
super().__init__()
resnets = []
attentions = []
for i in range(num_layers):
input_channels = in_channels if i == 0 else out_channels
resnets.append(
ResnetBlock2D(
in_channels=input_channels,
out_channels=out_channels,
temb_channels=None,
eps=resnet_eps,
groups=resnet_groups,
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
attentions.append(
AttentionBlock(
out_channels,
num_head_channels=attn_num_head_channels,
rescale_output_factor=output_scale_factor,
eps=resnet_eps,
norm_num_groups=resnet_groups,
)
)
self.attentions = nn.ModuleList(attentions)
self.resnets = nn.ModuleList(resnets)
if add_upsample:
self.upsamplers = nn.ModuleList([Upsample2D(out_channels, use_conv=True, out_channels=out_channels)])
else:
self.upsamplers = None
def forward(self, hidden_states):
for resnet, attn in zip(self.resnets, self.attentions):
hidden_states = resnet(hidden_states, temb=None)
hidden_states = attn(hidden_states)
if self.upsamplers is not None:
for upsampler in self.upsamplers:
hidden_states = upsampler(hidden_states)
return hidden_states
class AttnSkipUpBlock2D(nn.Module):
def __init__(
self,
in_channels: int,
prev_output_channel: int,
out_channels: int,
temb_channels: int,
dropout: float = 0.0,
num_layers: int = 1,
resnet_eps: float = 1e-6,
resnet_time_scale_shift: str = "default",
resnet_act_fn: str = "swish",
resnet_pre_norm: bool = True,
attn_num_head_channels=1,
output_scale_factor=np.sqrt(2.0),
upsample_padding=1,
add_upsample=True,
):
super().__init__()
self.attentions = nn.ModuleList([])
self.resnets = nn.ModuleList([])
for i in range(num_layers):
res_skip_channels = in_channels if (i == num_layers - 1) else out_channels
resnet_in_channels = prev_output_channel if i == 0 else out_channels
self.resnets.append(
ResnetBlock2D(
in_channels=resnet_in_channels + res_skip_channels,
out_channels=out_channels,
temb_channels=temb_channels,
eps=resnet_eps,
groups=min(resnet_in_channels + res_skip_channels // 4, 32),
groups_out=min(out_channels // 4, 32),
dropout=dropout,
time_embedding_norm=resnet_time_scale_shift,
non_linearity=resnet_act_fn,
output_scale_factor=output_scale_factor,
pre_norm=resnet_pre_norm,
)
)
self.attentions.append(
AttentionBlock(
out_channels,
num_head_channels=attn_num_head_channels,
rescale_output_factor=output_scale_factor,
eps=resnet_eps,
)
)
| self.upsampler = FirUpsample2D(in_channels, out_channels=out_channels) | 7 | 2023-11-14 23:29:31+00:00 | 24k |
BraveGroup/Drive-WM | src/diffusers/pipelines/wuerstchen/modeling_paella_vq_model.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... | from typing import Union
from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin
from ...models.vae import DecoderOutput, VectorQuantizer
from ...models.vq_model import VQEncoderOutput
from ...utils.accelerate_utils import apply_forward_hook
import torch
import torch.nn as nn | 20,149 |
class MixingResidualBlock(nn.Module):
"""
Residual block with mixing used by Paella's VQ-VAE.
"""
def __init__(self, inp_channels, embed_dim):
super().__init__()
# depthwise
self.norm1 = nn.LayerNorm(inp_channels, elementwise_affine=False, eps=1e-6)
self.depthwise = nn.Sequential(
nn.ReplicationPad2d(1), nn.Conv2d(inp_channels, inp_channels, kernel_size=3, groups=inp_channels)
)
# channelwise
self.norm2 = nn.LayerNorm(inp_channels, elementwise_affine=False, eps=1e-6)
self.channelwise = nn.Sequential(
nn.Linear(inp_channels, embed_dim), nn.GELU(), nn.Linear(embed_dim, inp_channels)
)
self.gammas = nn.Parameter(torch.zeros(6), requires_grad=True)
def forward(self, x):
mods = self.gammas
x_temp = self.norm1(x.permute(0, 2, 3, 1)).permute(0, 3, 1, 2) * (1 + mods[0]) + mods[1]
x = x + self.depthwise(x_temp) * mods[2]
x_temp = self.norm2(x.permute(0, 2, 3, 1)).permute(0, 3, 1, 2) * (1 + mods[3]) + mods[4]
x = x + self.channelwise(x_temp.permute(0, 2, 3, 1)).permute(0, 3, 1, 2) * mods[5]
return x
class PaellaVQModel(ModelMixin, ConfigMixin):
r"""VQ-VAE model from Paella model.
This model inherits from [`ModelMixin`]. Check the superclass documentation for the generic methods the library
implements for all the model (such as downloading or saving, etc.)
Parameters:
in_channels (int, *optional*, defaults to 3): Number of channels in the input image.
out_channels (int, *optional*, defaults to 3): Number of channels in the output.
up_down_scale_factor (int, *optional*, defaults to 2): Up and Downscale factor of the input image.
levels (int, *optional*, defaults to 2): Number of levels in the model.
bottleneck_blocks (int, *optional*, defaults to 12): Number of bottleneck blocks in the model.
embed_dim (int, *optional*, defaults to 384): Number of hidden channels in the model.
latent_channels (int, *optional*, defaults to 4): Number of latent channels in the VQ-VAE model.
num_vq_embeddings (int, *optional*, defaults to 8192): Number of codebook vectors in the VQ-VAE.
scale_factor (float, *optional*, defaults to 0.3764): Scaling factor of the latent space.
"""
@register_to_config
def __init__(
self,
in_channels: int = 3,
out_channels: int = 3,
up_down_scale_factor: int = 2,
levels: int = 2,
bottleneck_blocks: int = 12,
embed_dim: int = 384,
latent_channels: int = 4,
num_vq_embeddings: int = 8192,
scale_factor: float = 0.3764,
):
super().__init__()
c_levels = [embed_dim // (2**i) for i in reversed(range(levels))]
# Encoder blocks
self.in_block = nn.Sequential(
nn.PixelUnshuffle(up_down_scale_factor),
nn.Conv2d(in_channels * up_down_scale_factor**2, c_levels[0], kernel_size=1),
)
down_blocks = []
for i in range(levels):
if i > 0:
down_blocks.append(nn.Conv2d(c_levels[i - 1], c_levels[i], kernel_size=4, stride=2, padding=1))
block = MixingResidualBlock(c_levels[i], c_levels[i] * 4)
down_blocks.append(block)
down_blocks.append(
nn.Sequential(
nn.Conv2d(c_levels[-1], latent_channels, kernel_size=1, bias=False),
nn.BatchNorm2d(latent_channels), # then normalize them to have mean 0 and std 1
)
)
self.down_blocks = nn.Sequential(*down_blocks)
# Vector Quantizer
self.vquantizer = VectorQuantizer(num_vq_embeddings, vq_embed_dim=latent_channels, legacy=False, beta=0.25)
# Decoder blocks
up_blocks = [nn.Sequential(nn.Conv2d(latent_channels, c_levels[-1], kernel_size=1))]
for i in range(levels):
for j in range(bottleneck_blocks if i == 0 else 1):
block = MixingResidualBlock(c_levels[levels - 1 - i], c_levels[levels - 1 - i] * 4)
up_blocks.append(block)
if i < levels - 1:
up_blocks.append(
nn.ConvTranspose2d(
c_levels[levels - 1 - i], c_levels[levels - 2 - i], kernel_size=4, stride=2, padding=1
)
)
self.up_blocks = nn.Sequential(*up_blocks)
self.out_block = nn.Sequential(
nn.Conv2d(c_levels[0], out_channels * up_down_scale_factor**2, kernel_size=1),
nn.PixelShuffle(up_down_scale_factor),
)
@apply_forward_hook
def encode(self, x: torch.FloatTensor, return_dict: bool = True) -> VQEncoderOutput:
h = self.in_block(x)
h = self.down_blocks(h)
if not return_dict:
return (h,)
return VQEncoderOutput(latents=h)
@apply_forward_hook
def decode(
self, h: torch.FloatTensor, force_not_quantize: bool = True, return_dict: bool = True
| # Copyright (c) 2022 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 MixingResidualBlock(nn.Module):
"""
Residual block with mixing used by Paella's VQ-VAE.
"""
def __init__(self, inp_channels, embed_dim):
super().__init__()
# depthwise
self.norm1 = nn.LayerNorm(inp_channels, elementwise_affine=False, eps=1e-6)
self.depthwise = nn.Sequential(
nn.ReplicationPad2d(1), nn.Conv2d(inp_channels, inp_channels, kernel_size=3, groups=inp_channels)
)
# channelwise
self.norm2 = nn.LayerNorm(inp_channels, elementwise_affine=False, eps=1e-6)
self.channelwise = nn.Sequential(
nn.Linear(inp_channels, embed_dim), nn.GELU(), nn.Linear(embed_dim, inp_channels)
)
self.gammas = nn.Parameter(torch.zeros(6), requires_grad=True)
def forward(self, x):
mods = self.gammas
x_temp = self.norm1(x.permute(0, 2, 3, 1)).permute(0, 3, 1, 2) * (1 + mods[0]) + mods[1]
x = x + self.depthwise(x_temp) * mods[2]
x_temp = self.norm2(x.permute(0, 2, 3, 1)).permute(0, 3, 1, 2) * (1 + mods[3]) + mods[4]
x = x + self.channelwise(x_temp.permute(0, 2, 3, 1)).permute(0, 3, 1, 2) * mods[5]
return x
class PaellaVQModel(ModelMixin, ConfigMixin):
r"""VQ-VAE model from Paella model.
This model inherits from [`ModelMixin`]. Check the superclass documentation for the generic methods the library
implements for all the model (such as downloading or saving, etc.)
Parameters:
in_channels (int, *optional*, defaults to 3): Number of channels in the input image.
out_channels (int, *optional*, defaults to 3): Number of channels in the output.
up_down_scale_factor (int, *optional*, defaults to 2): Up and Downscale factor of the input image.
levels (int, *optional*, defaults to 2): Number of levels in the model.
bottleneck_blocks (int, *optional*, defaults to 12): Number of bottleneck blocks in the model.
embed_dim (int, *optional*, defaults to 384): Number of hidden channels in the model.
latent_channels (int, *optional*, defaults to 4): Number of latent channels in the VQ-VAE model.
num_vq_embeddings (int, *optional*, defaults to 8192): Number of codebook vectors in the VQ-VAE.
scale_factor (float, *optional*, defaults to 0.3764): Scaling factor of the latent space.
"""
@register_to_config
def __init__(
self,
in_channels: int = 3,
out_channels: int = 3,
up_down_scale_factor: int = 2,
levels: int = 2,
bottleneck_blocks: int = 12,
embed_dim: int = 384,
latent_channels: int = 4,
num_vq_embeddings: int = 8192,
scale_factor: float = 0.3764,
):
super().__init__()
c_levels = [embed_dim // (2**i) for i in reversed(range(levels))]
# Encoder blocks
self.in_block = nn.Sequential(
nn.PixelUnshuffle(up_down_scale_factor),
nn.Conv2d(in_channels * up_down_scale_factor**2, c_levels[0], kernel_size=1),
)
down_blocks = []
for i in range(levels):
if i > 0:
down_blocks.append(nn.Conv2d(c_levels[i - 1], c_levels[i], kernel_size=4, stride=2, padding=1))
block = MixingResidualBlock(c_levels[i], c_levels[i] * 4)
down_blocks.append(block)
down_blocks.append(
nn.Sequential(
nn.Conv2d(c_levels[-1], latent_channels, kernel_size=1, bias=False),
nn.BatchNorm2d(latent_channels), # then normalize them to have mean 0 and std 1
)
)
self.down_blocks = nn.Sequential(*down_blocks)
# Vector Quantizer
self.vquantizer = VectorQuantizer(num_vq_embeddings, vq_embed_dim=latent_channels, legacy=False, beta=0.25)
# Decoder blocks
up_blocks = [nn.Sequential(nn.Conv2d(latent_channels, c_levels[-1], kernel_size=1))]
for i in range(levels):
for j in range(bottleneck_blocks if i == 0 else 1):
block = MixingResidualBlock(c_levels[levels - 1 - i], c_levels[levels - 1 - i] * 4)
up_blocks.append(block)
if i < levels - 1:
up_blocks.append(
nn.ConvTranspose2d(
c_levels[levels - 1 - i], c_levels[levels - 2 - i], kernel_size=4, stride=2, padding=1
)
)
self.up_blocks = nn.Sequential(*up_blocks)
self.out_block = nn.Sequential(
nn.Conv2d(c_levels[0], out_channels * up_down_scale_factor**2, kernel_size=1),
nn.PixelShuffle(up_down_scale_factor),
)
@apply_forward_hook
def encode(self, x: torch.FloatTensor, return_dict: bool = True) -> VQEncoderOutput:
h = self.in_block(x)
h = self.down_blocks(h)
if not return_dict:
return (h,)
return VQEncoderOutput(latents=h)
@apply_forward_hook
def decode(
self, h: torch.FloatTensor, force_not_quantize: bool = True, return_dict: bool = True | ) -> Union[DecoderOutput, torch.FloatTensor]: | 3 | 2023-11-18 01:40:55+00:00 | 24k |
ej0cl6/TextEE | TextEE/models/AMRIE/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 AMRIEE2EModel
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 | 17,409 |
logger = logging.getLogger(__name__)
class AMRIEE2ETrainer(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 get_idx_map(self, tokens1, tokens2):
len1, len2 = len(tokens1), len(tokens2)
idx1_s, idx1_e, idx2_s, idx2_e, = 0, 0, 0, 0
idx_map = np.zeros((len2+1, ), dtype=np.int32)
idx_map[-1] = len1
while idx1_e <= len1 and idx2_e <= len2:
if "".join(tokens1[idx1_s:idx1_e+1]) == "".join(tokens2[idx2_s:idx2_e+1]):
idx_map[idx2_s:idx2_e+1] = idx1_s
idx1_s = idx1_e+1
idx1_e = idx1_e+1
idx2_s = idx2_e+1
idx2_e = idx2_e+1
elif len("".join(tokens1[idx1_s:idx1_e+1])) <= len("".join(tokens2[idx2_s:idx2_e+1])):
idx1_e += 1
else:
idx2_e += 1
return idx_map
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"]
|
logger = logging.getLogger(__name__)
class AMRIEE2ETrainer(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 get_idx_map(self, tokens1, tokens2):
len1, len2 = len(tokens1), len(tokens2)
idx1_s, idx1_e, idx2_s, idx2_e, = 0, 0, 0, 0
idx_map = np.zeros((len2+1, ), dtype=np.int32)
idx_map[-1] = len1
while idx1_e <= len1 and idx2_e <= len2:
if "".join(tokens1[idx1_s:idx1_e+1]) == "".join(tokens2[idx2_s:idx2_e+1]):
idx_map[idx2_s:idx2_e+1] = idx1_s
idx1_s = idx1_e+1
idx1_e = idx1_e+1
idx2_s = idx2_e+1
idx2_e = idx2_e+1
elif len("".join(tokens1[idx1_s:idx1_e+1])) <= len("".join(tokens2[idx2_s:idx2_e+1])):
idx1_e += 1
else:
idx2_e += 1
return idx_map
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 = AMRIEE2EModel(self.config, self.vocabs, self.valid_patterns) | 1 | 2023-11-15 21:32:56+00:00 | 24k |
ahayler/s4c | models/bts/evaluator_nvs.py | [
{
"identifier": "make_test_dataset",
"path": "datasets/data_util.py",
"snippet": "def make_test_dataset(config):\n type = config.get(\"type\", \"KITTI_Raw\")\n if type == \"KITTI_Raw\":\n test_dataset = KittiRawDataset(\n data_path=config[\"data_path\"],\n pose_path=co... | import math
import torch
import lpips
import skimage.metrics
from ignite.contrib.handlers import TensorboardLogger
from ignite.engine import Engine
from torch import nn
from torch.nn import functional as F
from torch.utils.data import DataLoader
from datasets.data_util import make_test_dataset
from models.common.render import NeRFRenderer
from models.bts.model.models_bts import BTSNet
from models.bts.model.ray_sampler import ImageRaySampler
from utils.base_evaluator import base_evaluation
from utils.metrics import MeanMetric | 14,541 | render_dict["fine"] = dict(render_dict["coarse"])
render_dict["rgb_gt"] = all_rgb_gt
render_dict["rays"] = all_rays
render_dict = self.sampler.reconstruct(render_dict)
data["fine"].append(render_dict["fine"])
data["coarse"].append(render_dict["coarse"])
data["rgb_gt"] = render_dict["rgb_gt"]
data["rays"] = render_dict["rays"]
data["z_near"] = torch.tensor(self.z_near, device=images.device)
data["z_far"] = torch.tensor(self.z_far, device=images.device)
data.update(self.compute_depth_metrics(data))
data.update(self.compute_nvs_metrics(data))
globals()["IDX"] += 1
return data
def compute_depth_metrics(self, data):
# TODO: This is only correct for batchsize 1!
depth_gt = data["depths"][0]
depth_pred = data["fine"][0]["depth"][:, :1]
depth_pred = F.interpolate(depth_pred, depth_gt.shape[-2:])
# TODO: Maybe implement median scaling
depth_pred = torch.clamp(depth_pred, 1e-3, 80)
mask = depth_gt != 0
depth_gt = depth_gt[mask]
depth_pred = depth_pred[mask]
thresh = torch.maximum((depth_gt / depth_pred), (depth_pred / depth_gt))
a1 = (thresh < 1.25).to(torch.float)
a2 = (thresh < 1.25 ** 2).to(torch.float)
a3 = (thresh < 1.25 ** 3).to(torch.float)
a1 = a1.mean()
a2 = a2.mean()
a3 = a3.mean()
rmse = (depth_gt - depth_pred) ** 2
rmse = rmse.mean() ** .5
rmse_log = (torch.log(depth_gt) - torch.log(depth_pred)) ** 2
rmse_log = rmse_log.mean() ** .5
abs_rel = torch.abs(depth_gt - depth_pred) / depth_gt
abs_rel = abs_rel.mean()
sq_rel = ((depth_gt - depth_pred) ** 2) / depth_gt
sq_rel = sq_rel.mean()
metrics_dict = {
"abs_rel": abs_rel,
"sq_rel": sq_rel,
"rmse": rmse,
"rmse_log": rmse_log,
"a1": a1,
"a2": a2,
"a3": a3
}
return metrics_dict
def compute_nvs_metrics(self, data):
# TODO: This is only correct for batchsize 1!
# Following tucker et al. and others, we crop 5% on all sides
# idx of stereo frame (the target frame is always the "stereo" frame).
sf_id = data["rgb_gt"].shape[1] // 2
imgs_gt = data["rgb_gt"][:, sf_id:sf_id+1]
imgs_pred = data["fine"][0]["rgb"][:, sf_id:sf_id+1]
imgs_gt = imgs_gt.squeeze(0).permute(0, 3, 1, 2)
imgs_pred = imgs_pred.squeeze(0).squeeze(-2).permute(0, 3, 1, 2)
imgs_gt = F.interpolate(imgs_gt, self.eval_resolution)
imgs_pred = F.interpolate(imgs_pred, self.eval_resolution)
n, c, h, w = imgs_gt.shape
y0 = int(math.ceil(0.05 * h))
y1 = int(math.floor(0.95 * h))
x0 = int(math.ceil(0.05 * w))
x1 = int(math.floor(0.95 * w))
imgs_gt = imgs_gt[:, :, y0:y1, x0:x1]
imgs_pred = imgs_pred[:, :, y0:y1, x0:x1]
imgs_gt_np = imgs_gt.detach().squeeze().permute(1, 2, 0).cpu().numpy()
imgs_pred_np = imgs_pred.detach().squeeze().permute(1, 2, 0).cpu().numpy()
ssim_score = skimage.metrics.structural_similarity(imgs_pred_np, imgs_gt_np, multichannel=True, data_range=1)
psnr_score = skimage.metrics.peak_signal_noise_ratio(imgs_pred_np, imgs_gt_np, data_range=1)
lpips_score = self.lpips(imgs_pred, imgs_gt, normalize=True).mean()
metrics_dict = {
"ssim": ssim_score,
"psnr": psnr_score,
"lpips": lpips_score
}
return metrics_dict
def evaluation(local_rank, config):
return base_evaluation(local_rank, config, get_dataflow, initialize, get_metrics)
def get_dataflow(config):
test_dataset = make_test_dataset(config["data"])
test_loader = DataLoader(test_dataset, batch_size=1, num_workers=config["num_workers"], shuffle=False, drop_last=False)
return test_loader
def get_metrics(config, device):
names = ["abs_rel", "sq_rel", "rmse", "rmse_log", "a1", "a2", "a3", "ssim", "psnr", "lpips"]
|
IDX = 0
class BTSWrapper(nn.Module):
def __init__(self, renderer, config, ) -> None:
super().__init__()
self.renderer = renderer
self.z_near = config["z_near"]
self.z_far = config["z_far"]
self.ray_batch_size = config["ray_batch_size"]
self.sampler = ImageRaySampler(self.z_near, self.z_far)
self.eval_resolution = list(config.get("eval_resolution", None))
self.lpips = lpips.LPIPS()
@staticmethod
def get_loss_metric_names():
return ["loss", "loss_l2", "loss_mask", "loss_temporal"]
def forward(self, data):
data = dict(data)
images = torch.stack(data["imgs"], dim=1) # n, v, c, h, w
poses = torch.stack(data["poses"], dim=1) # n, v, 4, 4 w2c
projs = torch.stack(data["projs"], dim=1) # n, v, 4, 4 (-1, 1)
n, v, c, h, w = images.shape
device = images.device
# Use first frame as keyframe
to_base_pose = torch.inverse(poses[:, :1, :, :])
poses = to_base_pose.expand(-1, v, -1, -1) @ poses
if self.eval_resolution is not None:
images_resized = F.interpolate(images.view(n * v, c, h, w), size=self.eval_resolution).view(n, v, c, *self.eval_resolution)
else:
images_resized = images
ids_encoder = [0]
self.renderer.net.compute_grid_transforms(projs[:, ids_encoder], poses[:, ids_encoder])
self.renderer.net.encode(images_resized, projs, poses, ids_encoder=ids_encoder, ids_render=ids_encoder, images_alt=images * .5 + .5)
all_rays, all_rgb_gt = self.sampler.sample(images * .5 + .5, poses, projs)
data["fine"] = []
data["coarse"] = []
self.renderer.net.set_scale(0)
render_dict = self.renderer(all_rays, want_weights=True, want_alphas=True)
if "fine" not in render_dict:
render_dict["fine"] = dict(render_dict["coarse"])
render_dict["rgb_gt"] = all_rgb_gt
render_dict["rays"] = all_rays
render_dict = self.sampler.reconstruct(render_dict)
data["fine"].append(render_dict["fine"])
data["coarse"].append(render_dict["coarse"])
data["rgb_gt"] = render_dict["rgb_gt"]
data["rays"] = render_dict["rays"]
data["z_near"] = torch.tensor(self.z_near, device=images.device)
data["z_far"] = torch.tensor(self.z_far, device=images.device)
data.update(self.compute_depth_metrics(data))
data.update(self.compute_nvs_metrics(data))
globals()["IDX"] += 1
return data
def compute_depth_metrics(self, data):
# TODO: This is only correct for batchsize 1!
depth_gt = data["depths"][0]
depth_pred = data["fine"][0]["depth"][:, :1]
depth_pred = F.interpolate(depth_pred, depth_gt.shape[-2:])
# TODO: Maybe implement median scaling
depth_pred = torch.clamp(depth_pred, 1e-3, 80)
mask = depth_gt != 0
depth_gt = depth_gt[mask]
depth_pred = depth_pred[mask]
thresh = torch.maximum((depth_gt / depth_pred), (depth_pred / depth_gt))
a1 = (thresh < 1.25).to(torch.float)
a2 = (thresh < 1.25 ** 2).to(torch.float)
a3 = (thresh < 1.25 ** 3).to(torch.float)
a1 = a1.mean()
a2 = a2.mean()
a3 = a3.mean()
rmse = (depth_gt - depth_pred) ** 2
rmse = rmse.mean() ** .5
rmse_log = (torch.log(depth_gt) - torch.log(depth_pred)) ** 2
rmse_log = rmse_log.mean() ** .5
abs_rel = torch.abs(depth_gt - depth_pred) / depth_gt
abs_rel = abs_rel.mean()
sq_rel = ((depth_gt - depth_pred) ** 2) / depth_gt
sq_rel = sq_rel.mean()
metrics_dict = {
"abs_rel": abs_rel,
"sq_rel": sq_rel,
"rmse": rmse,
"rmse_log": rmse_log,
"a1": a1,
"a2": a2,
"a3": a3
}
return metrics_dict
def compute_nvs_metrics(self, data):
# TODO: This is only correct for batchsize 1!
# Following tucker et al. and others, we crop 5% on all sides
# idx of stereo frame (the target frame is always the "stereo" frame).
sf_id = data["rgb_gt"].shape[1] // 2
imgs_gt = data["rgb_gt"][:, sf_id:sf_id+1]
imgs_pred = data["fine"][0]["rgb"][:, sf_id:sf_id+1]
imgs_gt = imgs_gt.squeeze(0).permute(0, 3, 1, 2)
imgs_pred = imgs_pred.squeeze(0).squeeze(-2).permute(0, 3, 1, 2)
imgs_gt = F.interpolate(imgs_gt, self.eval_resolution)
imgs_pred = F.interpolate(imgs_pred, self.eval_resolution)
n, c, h, w = imgs_gt.shape
y0 = int(math.ceil(0.05 * h))
y1 = int(math.floor(0.95 * h))
x0 = int(math.ceil(0.05 * w))
x1 = int(math.floor(0.95 * w))
imgs_gt = imgs_gt[:, :, y0:y1, x0:x1]
imgs_pred = imgs_pred[:, :, y0:y1, x0:x1]
imgs_gt_np = imgs_gt.detach().squeeze().permute(1, 2, 0).cpu().numpy()
imgs_pred_np = imgs_pred.detach().squeeze().permute(1, 2, 0).cpu().numpy()
ssim_score = skimage.metrics.structural_similarity(imgs_pred_np, imgs_gt_np, multichannel=True, data_range=1)
psnr_score = skimage.metrics.peak_signal_noise_ratio(imgs_pred_np, imgs_gt_np, data_range=1)
lpips_score = self.lpips(imgs_pred, imgs_gt, normalize=True).mean()
metrics_dict = {
"ssim": ssim_score,
"psnr": psnr_score,
"lpips": lpips_score
}
return metrics_dict
def evaluation(local_rank, config):
return base_evaluation(local_rank, config, get_dataflow, initialize, get_metrics)
def get_dataflow(config):
test_dataset = make_test_dataset(config["data"])
test_loader = DataLoader(test_dataset, batch_size=1, num_workers=config["num_workers"], shuffle=False, drop_last=False)
return test_loader
def get_metrics(config, device):
names = ["abs_rel", "sq_rel", "rmse", "rmse_log", "a1", "a2", "a3", "ssim", "psnr", "lpips"] | metrics = {name: MeanMetric((lambda n: lambda x: x["output"][n])(name), device) for name in names} | 5 | 2023-11-12 21:53:27+00:00 | 24k |
newcastleuniversity/DISPEL | tests/processing/test_trace.py | [
{
"identifier": "Reading",
"path": "dispel/data/core.py",
"snippet": "class Reading(FlagMixIn):\n \"\"\"A data capture from an experiment.\n\n Attributes\n ----------\n evaluation\n The evaluation information for this reading\n session\n The session information for this read... | import networkx as nx
import pytest
from dispel.data.core import Reading
from dispel.data.epochs import EpochDefinition
from dispel.data.measures import MeasureValueDefinition, MeasureValueDefinitionPrototype
from dispel.data.raw import RawDataValueDefinition
from dispel.data.values import AbbreviatedValue as AV
from dispel.processing.core import (
CoreProcessingStepGroup,
Parameter,
ProcessingStep,
ProcessResultType,
)
from dispel.processing.data_set import transformation
from dispel.processing.epochs import (
CreateLevelEpochStep,
LevelEpochExtractStep,
LevelEpochIdFilter,
LevelEpochProcessingStepMixIn,
)
from dispel.processing.extract import (
AggregateMeasures,
ExtractStep,
MeasureDefinitionMixin,
)
from dispel.processing.trace import (
DataSetTrace,
EpochTrace,
MeasureTrace,
OriginTrace,
StepGroupTrace,
StepTrace,
Trace,
TraceRelation,
get_ancestor_source_graph,
get_ancestors,
get_edge_parameters,
get_traces,
inspect,
)
from dispel.processing.transform import TransformStep | 17,220 | """Tests for :mod:`dispel.processing.trace`."""
class _TestProcessingStep(ProcessingStep):
def process_reading(self, reading: Reading, **kwargs) -> ProcessResultType:
pass
class _TestTransformStep(TransformStep):
data_set_ids = ["input_dataset1", "input_dataset2"]
new_data_set_id = "output_dataset"
definitions = [
RawDataValueDefinition("col1_id", "col1_name"),
RawDataValueDefinition("col2_id", "col2_name"),
]
@staticmethod
@transformation
def _transform(data):
pass
| """Tests for :mod:`dispel.processing.trace`."""
class _TestProcessingStep(ProcessingStep):
def process_reading(self, reading: Reading, **kwargs) -> ProcessResultType:
pass
class _TestTransformStep(TransformStep):
data_set_ids = ["input_dataset1", "input_dataset2"]
new_data_set_id = "output_dataset"
definitions = [
RawDataValueDefinition("col1_id", "col1_name"),
RawDataValueDefinition("col2_id", "col2_name"),
]
@staticmethod
@transformation
def _transform(data):
pass
| class _TestExtractStep(ExtractStep): | 13 | 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 | 15,585 | 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
| # 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 | 3 | 2023-11-12 13:28:26+00:00 | 24k |
cyberark/ark-sdk-python | ark_sdk_python/cli_services/dpa/db/ark_dpa_db_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.db import ArkDPADBGeneratePolicy
from ark_sdk_python.models.common import 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.db import (
ArkDPADB,
ArkDPADBAddPolicy,
ArkDPADBAppliedTo,
ArkDPADBAuthorizationRule,
ArkDPADBBaseAuth,
ArkDPADBConnectAs,
ArkDPADBConnectionInformation,
ArkDPADBLDAPAuth,
ArkDPADBLocalDBAuth,
ArkDPADBMariaDB,
ArkDPADBMSSQL,
ArkDPADBMySQL,
ArkDPADBOracle,
ArkDPADBOracleDBAuth,
ArkDPADBOracleResource,
ArkDPADBPolicy,
ArkDPADBPolicyListItem,
ArkDPADBPostgres,
ArkDPADBProvidersData,
ArkDPADBResourceIdentifierType,
ArkDPADBUpdatePolicy,
)
from ark_sdk_python.services.dpa.policies.db.ark_dpa_db_policies_service import ArkDPADBPoliciesService
import inquirer | 14,687 | SUPPORTED_DATABASE_TYPES: Final[List[str]] = [
'MSSQL',
'MySQL',
'MariaDB',
'Postgres',
'Oracle',
]
DEFAULT_GENERATED_POLICY: Final[ArkDPADBPolicy] = ArkDPADBPolicy(
policy_name='Default DB Policy',
status=ArkDPARuleStatus.Draft,
description='Auto generated db policy',
providers_data=ArkDPADBProvidersData(
postgres=ArkDPADBPostgres(
resources=['postgres-onboarded-asset'],
),
),
start_date=date.today().strftime('%Y-%m-%d'),
end_date=(date.today() + timedelta(days=7)).strftime('%Y-%m-%d'),
user_access_rules=[],
)
DEFAULT_GENERATED_PROVIDERS: Final[Dict[ArkWorkspaceType, ArkDPADB]] = {
ArkWorkspaceType.MSSQL: ArkDPADBMSSQL(resources=['mssql-onboarded-asset']),
ArkWorkspaceType.MYSQL: ArkDPADBMySQL(resources=['mysql-onboarded-asset']),
ArkWorkspaceType.MARIADB: ArkDPADBMariaDB(resources=['mariadb-onboarded-asset']),
ArkWorkspaceType.POSTGRES: ArkDPADBPostgres(resources=['postgres-onboarded-asset']),
ArkWorkspaceType.ORACLE: ArkDPADBOracle(
resources=[
ArkDPADBOracleResource(
name='oracle-onboarded-asset',
services=['XE'],
),
],
),
}
DEFAULT_GENERATED_AUTH_METHODS: Final[Dict[ArkWorkspaceType, ArkDPADBBaseAuth]] = {
ArkWorkspaceType.MSSQL: ArkDPADBLDAPAuth(
assign_groups=['DomainSQLAdmins'],
applied_to=[
ArkDPADBAppliedTo(
name='mssql-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
ArkWorkspaceType.MYSQL: ArkDPADBLocalDBAuth(
roles=['db_admin'],
applied_to=[
ArkDPADBAppliedTo(
name='mysql-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
ArkWorkspaceType.MARIADB: ArkDPADBLocalDBAuth(
roles=['db_admin'],
applied_to=[
ArkDPADBAppliedTo(
name='mariadb-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
ArkWorkspaceType.POSTGRES: ArkDPADBLocalDBAuth(
roles=['rds_superuser'],
applied_to=[
ArkDPADBAppliedTo(
name='postgres-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
ArkWorkspaceType.ORACLE: ArkDPADBOracleDBAuth(
roles=[],
dba_role=True,
sysdba_role=True,
sysoper_role=False,
applied_to=[
ArkDPADBAppliedTo(
name='oracle-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
}
DEFAULT_GENERATED_AUTHORIZATION_RULE: Final[ArkDPADBAuthorizationRule] = ArkDPADBAuthorizationRule(
rule_name='Default DB Rule',
user_data=ArkDPAUserData(roles=['DpaAdmin'], groups=[], users=[]),
connection_information=ArkDPADBConnectionInformation(
grant_access=2,
idle_time=10,
days_of_week=[],
full_days=True,
hours_from='07:00',
hours_to='17:00',
time_zone='Asia/Jerusalem',
connect_as=ArkDPADBConnectAs(
db_auth=[
ArkDPADBLocalDBAuth(
roles=['rds_superuser'],
applied_to=[
ArkDPADBAppliedTo(
name='postgres-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
],
),
),
)
WORKSPACE_TO_PROVIDER_NAME: Final[Dict[ArkWorkspaceType, str]] = {
ArkWorkspaceType.MSSQL: 'mssql',
ArkWorkspaceType.MYSQL: 'mysql',
ArkWorkspaceType.POSTGRES: 'postgres',
ArkWorkspaceType.ORACLE: 'oracle',
ArkWorkspaceType.MARIADB: 'mariadb',
}
class ArkDPADBPoliciesEditorService(
|
SERVICE_CONFIG: Final[ArkServiceConfig] = ArkServiceConfig(
service_name='dpa-policies-db-editor', required_authenticator_names=['isp'], optional_authenticator_names=[]
)
SUPPORTED_DATABASE_TYPES: Final[List[str]] = [
'MSSQL',
'MySQL',
'MariaDB',
'Postgres',
'Oracle',
]
DEFAULT_GENERATED_POLICY: Final[ArkDPADBPolicy] = ArkDPADBPolicy(
policy_name='Default DB Policy',
status=ArkDPARuleStatus.Draft,
description='Auto generated db policy',
providers_data=ArkDPADBProvidersData(
postgres=ArkDPADBPostgres(
resources=['postgres-onboarded-asset'],
),
),
start_date=date.today().strftime('%Y-%m-%d'),
end_date=(date.today() + timedelta(days=7)).strftime('%Y-%m-%d'),
user_access_rules=[],
)
DEFAULT_GENERATED_PROVIDERS: Final[Dict[ArkWorkspaceType, ArkDPADB]] = {
ArkWorkspaceType.MSSQL: ArkDPADBMSSQL(resources=['mssql-onboarded-asset']),
ArkWorkspaceType.MYSQL: ArkDPADBMySQL(resources=['mysql-onboarded-asset']),
ArkWorkspaceType.MARIADB: ArkDPADBMariaDB(resources=['mariadb-onboarded-asset']),
ArkWorkspaceType.POSTGRES: ArkDPADBPostgres(resources=['postgres-onboarded-asset']),
ArkWorkspaceType.ORACLE: ArkDPADBOracle(
resources=[
ArkDPADBOracleResource(
name='oracle-onboarded-asset',
services=['XE'],
),
],
),
}
DEFAULT_GENERATED_AUTH_METHODS: Final[Dict[ArkWorkspaceType, ArkDPADBBaseAuth]] = {
ArkWorkspaceType.MSSQL: ArkDPADBLDAPAuth(
assign_groups=['DomainSQLAdmins'],
applied_to=[
ArkDPADBAppliedTo(
name='mssql-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
ArkWorkspaceType.MYSQL: ArkDPADBLocalDBAuth(
roles=['db_admin'],
applied_to=[
ArkDPADBAppliedTo(
name='mysql-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
ArkWorkspaceType.MARIADB: ArkDPADBLocalDBAuth(
roles=['db_admin'],
applied_to=[
ArkDPADBAppliedTo(
name='mariadb-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
ArkWorkspaceType.POSTGRES: ArkDPADBLocalDBAuth(
roles=['rds_superuser'],
applied_to=[
ArkDPADBAppliedTo(
name='postgres-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
ArkWorkspaceType.ORACLE: ArkDPADBOracleDBAuth(
roles=[],
dba_role=True,
sysdba_role=True,
sysoper_role=False,
applied_to=[
ArkDPADBAppliedTo(
name='oracle-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
}
DEFAULT_GENERATED_AUTHORIZATION_RULE: Final[ArkDPADBAuthorizationRule] = ArkDPADBAuthorizationRule(
rule_name='Default DB Rule',
user_data=ArkDPAUserData(roles=['DpaAdmin'], groups=[], users=[]),
connection_information=ArkDPADBConnectionInformation(
grant_access=2,
idle_time=10,
days_of_week=[],
full_days=True,
hours_from='07:00',
hours_to='17:00',
time_zone='Asia/Jerusalem',
connect_as=ArkDPADBConnectAs(
db_auth=[
ArkDPADBLocalDBAuth(
roles=['rds_superuser'],
applied_to=[
ArkDPADBAppliedTo(
name='postgres-onboarded-asset',
type=ArkDPADBResourceIdentifierType.RESOURCE,
)
],
),
],
),
),
)
WORKSPACE_TO_PROVIDER_NAME: Final[Dict[ArkWorkspaceType, str]] = {
ArkWorkspaceType.MSSQL: 'mssql',
ArkWorkspaceType.MYSQL: 'mysql',
ArkWorkspaceType.POSTGRES: 'postgres',
ArkWorkspaceType.ORACLE: 'oracle',
ArkWorkspaceType.MARIADB: 'mariadb',
}
class ArkDPADBPoliciesEditorService( | ArkDPABasePoliciesEditorService[ArkDPADBPolicy, ArkDPADBPolicyListItem, ArkDPADBAddPolicy, ArkDPADBUpdatePolicy, ArkDPADBGeneratePolicy] | 2 | 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 | 16,699 | # 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)
|
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(): | 6 | 2023-11-14 16:43:16+00:00 | 24k |
atlantic-quantum/Shipyard | tests/passes/test_include_files.py | [
{
"identifier": "Compiler",
"path": "shipyard/compiler.py",
"snippet": "class Compiler:\n version = \"0.1.1\"\n \"\"\"\n Compiler to compile openQASM programs to target programs for different AWG Cores.\n Currently supports compilation to ZI SEQC cores.\n\n Args:\n program_path (Pa... | import io
import pytest
from pathlib import Path
from openpulse import ast, parse
from shipyard.compiler import Compiler
from shipyard.compiler_error import SemanticError, TransformError
from shipyard.printers.zi.seqcprinter import SEQCPrinter
from shipyard.setup.internal import SetupInternal | 16,802 |
@pytest.fixture(name="basic_setup")
def fixture_basic_setup() -> SetupInternal:
json_path = Path(__file__).parent.parent / "setups/basic.json"
return SetupInternal.from_json(json_path)
@pytest.fixture(name="seqc_printer")
def fixture_seqc_printer(basic_setup: SetupInternal) -> SEQCPrinter:
return SEQCPrinter(io.StringIO(), basic_setup)
def load_ast(file: str) -> ast.Program:
path = Path(__file__).parent.parent / f"qasm/include_files/{file}.qasm"
with open(path, encoding="utf_8") as qasm_file:
qasm_code = qasm_file.read()
return parse(qasm_code)
def test_ramsey_nested_include(seqc_printer: SEQCPrinter, file="ramsey_nested"):
"""
Test for nested include files (one qasm on inc) for ramsey experiment
"""
qasm_path = Path(__file__).parent.parent / f"qasm/include_files/{file}.qasm"
setup_path = Path(__file__).parent.parent / "qasm/include_files/setup.json"
seqc_path = Path(__file__).parent.parent / "qasm/include_files/ramsey_seqc.seqc"
|
@pytest.fixture(name="basic_setup")
def fixture_basic_setup() -> SetupInternal:
json_path = Path(__file__).parent.parent / "setups/basic.json"
return SetupInternal.from_json(json_path)
@pytest.fixture(name="seqc_printer")
def fixture_seqc_printer(basic_setup: SetupInternal) -> SEQCPrinter:
return SEQCPrinter(io.StringIO(), basic_setup)
def load_ast(file: str) -> ast.Program:
path = Path(__file__).parent.parent / f"qasm/include_files/{file}.qasm"
with open(path, encoding="utf_8") as qasm_file:
qasm_code = qasm_file.read()
return parse(qasm_code)
def test_ramsey_nested_include(seqc_printer: SEQCPrinter, file="ramsey_nested"):
"""
Test for nested include files (one qasm on inc) for ramsey experiment
"""
qasm_path = Path(__file__).parent.parent / f"qasm/include_files/{file}.qasm"
setup_path = Path(__file__).parent.parent / "qasm/include_files/setup.json"
seqc_path = Path(__file__).parent.parent / "qasm/include_files/ramsey_seqc.seqc" | compiler = Compiler(qasm_path, setup_path) | 0 | 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,170 | 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
"""
| # 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): | 10 | 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
) | 16,427 | tuning_groups=[[1, 2], [3, 4]],
GP_model=GP_model)
# Optimisation with dynamic tuning
# Initialise wake steering object
wso_obj_tuning = WSOpt(wf_model=wf_model,
inflow=inflow,
variables=variables,
var_bounds=var_bounds,
var_initial=var_initial,
opt_method="SLSQP",
opt_options=None,
obj_function="Farm Power",
tuning_dynamic=True
)
# Assign dynamic tuning to wake steering optimisation
wso_obj_tuning.tuning_dyn_initialize([tuning_dyn_obj])
# Optimise and print yaw angles
opt_yaw_angles_vars, opt_yaw_angles_all = wso_obj_tuning.optimize_yaw()
print('Optimal farm yaw angles with dynamic parameter tuning:')
print(opt_yaw_angles_all)
# Extract wind farm power without any yaw
wf_pow_noyaw = wso_obj_tuning.wf_pow_noyaw
# %% Looping refinement
yaw_initial = opt_yaw_angles_all
# Number of loops for each turbine
n_iterations = 1
# One loop for each turbine variable
for turbine in [1, 2, 3, 4]*n_iterations:
# Wake steering optimisation inputs - single turbine
inflow = (yaw_initial, wd, ws, ti, shear)
variables = [turbine]
var_initial = [yaw_initial[turbine-1]]
# %% Looping GP dataset
# Higher fidelity dataset
# Initialise trainer and set farm layout
path = "./inputs/"
input_file_trainer = "gch.yaml"
trainer = WfModel(input_file_trainer, path)
trainer.set_aligned_layout(5, 1, 7, 5)
# Define training set
yaw_list = []
for yaw_var in np.linspace(-25, 25, 7):
yaw_single = yaw_initial.copy()
yaw_single[turbine-1] = yaw_var
yaw_list.append(yaw_single)
# Produce high-fidelity power measurement for each training condition
wt_pow_training_list = []
for i in range(len(yaw_list)):
_, wt_pow_training, _, _ = trainer.farm_eval(yaw=yaw_list[i],
wd=wd,
ws=ws,
ti=ti,
shear=shear)
wt_pow_training_list.append(wt_pow_training)
# Parameter tuning - Run a single optimisation for each training condition
# Initialise dataset
optimal_parameter_dataset = {}
for i, yaw in enumerate(yaw_list):
# Initialise trainee
trainee = wf_model
# Parameters to tune
param_class_list = ['wake_velocity_parameters']
param_name_list = ['we']
param_bounds_list = [(0.0, 0.1)]
# TURBO options
TURBO_opt = {"n_init": 2,
"max_evals": 100,
"batch_size": 4, # 1 = Serial
"verbose": True,
"use_ard": True,
"max_cholesky_size": 2000,
"n_training_steps": 50,
"min_cuda": 1024,
"device": "cpu",
"dtype": "float64"}
# Initialise parameter tuning object
tune_obj = Tuning(wf_model=trainee,
variables_class_list=param_class_list,
variables_names_list=param_name_list,
variables_bounds_list=param_bounds_list,
obj_func_name='RMSE',
opt_method='TURBO_1',
opt_options=TURBO_opt)
# Specify higher-fidelity tuning condition
tune_obj.tuning_conditions(yaw_angles_list=[yaw],
wind_directions_list=[wd],
wind_speeds_list=[ws],
turbulence_intensities_list=[ti],
wind_shear_list=[shear])
# Specify higher-fidelity turbine power measurements
tune_obj.tuning_data(data_power_list=[wt_pow_training_list[i]])
# Tune parameters, extract tuned dictionary, reinitialise wf_model object
trainee, trainee_dict_opt = tune_obj.tune_parameters()
# Extract tuned k parameter
|
"""
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,
'wake_deflection_parameters',
'kd',
0.3)
wf_model = floris_param_change_object(wf_model, wf_model_dict)
# Specify atmopheric conditions
ws = 8.0
wd = 270
ti = 0.05
shear = 0.0
# Wake steering optimisation inputs
yaw_initial = np.full(shape=(5), fill_value=0)
inflow = (yaw_initial, wd, ws, ti, shear)
variables = [1, 2, 3, 4]
var_bounds = (-25, 25)
var_initial = np.full(shape=(len(variables)), fill_value=0)
# Dynamic tuning object
# Parameter info
parameter_class = 'wake_velocity_parameters'
parameter_name = 'we'
# Import optimal parameter dataset and extract GP input
dataset_path = "./optimal_parameter_datasets/"
dataset_import = np.load(dataset_path+'we_5x1_2dim_grouping.npy', allow_pickle=True)
optimal_parameter_dataset = dataset_import.item()
yaw_data = []
param_data = []
for key in optimal_parameter_dataset.keys():
yaw_data.append([key[0], key[2]]) # Extract group yaw
param_data.append([optimal_parameter_dataset[key]])
# Construct Gaussian Process (GP)
GP_obj = GPWrap(parameter_class=parameter_class,
parameter_name=parameter_name,
dimensions=2)
GP_model = GP_obj.GP_so(yaw_data, param_data, num_restarts=100, noise=0.05)
# Tuning object initialisation
tuning_dyn_obj = TuningDyn_Grouping(param_class=parameter_class,
param_name=parameter_name,
tuning_groups=[[1, 2], [3, 4]],
GP_model=GP_model)
# Optimisation with dynamic tuning
# Initialise wake steering object
wso_obj_tuning = WSOpt(wf_model=wf_model,
inflow=inflow,
variables=variables,
var_bounds=var_bounds,
var_initial=var_initial,
opt_method="SLSQP",
opt_options=None,
obj_function="Farm Power",
tuning_dynamic=True
)
# Assign dynamic tuning to wake steering optimisation
wso_obj_tuning.tuning_dyn_initialize([tuning_dyn_obj])
# Optimise and print yaw angles
opt_yaw_angles_vars, opt_yaw_angles_all = wso_obj_tuning.optimize_yaw()
print('Optimal farm yaw angles with dynamic parameter tuning:')
print(opt_yaw_angles_all)
# Extract wind farm power without any yaw
wf_pow_noyaw = wso_obj_tuning.wf_pow_noyaw
# %% Looping refinement
yaw_initial = opt_yaw_angles_all
# Number of loops for each turbine
n_iterations = 1
# One loop for each turbine variable
for turbine in [1, 2, 3, 4]*n_iterations:
# Wake steering optimisation inputs - single turbine
inflow = (yaw_initial, wd, ws, ti, shear)
variables = [turbine]
var_initial = [yaw_initial[turbine-1]]
# %% Looping GP dataset
# Higher fidelity dataset
# Initialise trainer and set farm layout
path = "./inputs/"
input_file_trainer = "gch.yaml"
trainer = WfModel(input_file_trainer, path)
trainer.set_aligned_layout(5, 1, 7, 5)
# Define training set
yaw_list = []
for yaw_var in np.linspace(-25, 25, 7):
yaw_single = yaw_initial.copy()
yaw_single[turbine-1] = yaw_var
yaw_list.append(yaw_single)
# Produce high-fidelity power measurement for each training condition
wt_pow_training_list = []
for i in range(len(yaw_list)):
_, wt_pow_training, _, _ = trainer.farm_eval(yaw=yaw_list[i],
wd=wd,
ws=ws,
ti=ti,
shear=shear)
wt_pow_training_list.append(wt_pow_training)
# Parameter tuning - Run a single optimisation for each training condition
# Initialise dataset
optimal_parameter_dataset = {}
for i, yaw in enumerate(yaw_list):
# Initialise trainee
trainee = wf_model
# Parameters to tune
param_class_list = ['wake_velocity_parameters']
param_name_list = ['we']
param_bounds_list = [(0.0, 0.1)]
# TURBO options
TURBO_opt = {"n_init": 2,
"max_evals": 100,
"batch_size": 4, # 1 = Serial
"verbose": True,
"use_ard": True,
"max_cholesky_size": 2000,
"n_training_steps": 50,
"min_cuda": 1024,
"device": "cpu",
"dtype": "float64"}
# Initialise parameter tuning object
tune_obj = Tuning(wf_model=trainee,
variables_class_list=param_class_list,
variables_names_list=param_name_list,
variables_bounds_list=param_bounds_list,
obj_func_name='RMSE',
opt_method='TURBO_1',
opt_options=TURBO_opt)
# Specify higher-fidelity tuning condition
tune_obj.tuning_conditions(yaw_angles_list=[yaw],
wind_directions_list=[wd],
wind_speeds_list=[ws],
turbulence_intensities_list=[ti],
wind_shear_list=[shear])
# Specify higher-fidelity turbine power measurements
tune_obj.tuning_data(data_power_list=[wt_pow_training_list[i]])
# Tune parameters, extract tuned dictionary, reinitialise wf_model object
trainee, trainee_dict_opt = tune_obj.tune_parameters()
# Extract tuned k parameter | k_tuned = floris_extract_parameter(trainee_dict_opt, | 7 | 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,817 |
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)
# 新建帧，计算视频总共有多少帧，每帧多少ms
video.load_frames()
# 压缩视频
|
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)
# 新建帧，计算视频总共有多少帧，每帧多少ms
video.load_frames()
# 压缩视频 | cutter = VideoCutter( | 5 | 2023-11-13 05:27:34+00:00 | 24k |
microsoft/SoM | demo_gpt4v_som.py | [
{
"identifier": "interactive_seem_m2m_auto",
"path": "task_adapter/seem/tasks/interactive_seem_m2m_auto.py",
"snippet": "def interactive_seem_m2m_auto(model, image, text_size, label_mode='1', alpha=0.1, anno_mode=['Mask']):\n t = []\n t.append(transforms.Resize(int(text_size), interpolation=Image.... | import io
import gradio as gr
import torch
import argparse
import numpy as np
import matplotlib.colors as mcolors
from PIL import Image
from seem.modeling.BaseModel import BaseModel as BaseModel_Seem
from seem.utils.distributed import init_distributed as init_distributed_seem
from seem.modeling import build_model as build_model_seem
from task_adapter.seem.tasks import interactive_seem_m2m_auto, inference_seem_pano, inference_seem_interactive
from semantic_sam.BaseModel import BaseModel
from semantic_sam import build_model
from semantic_sam.utils.dist import init_distributed_mode
from semantic_sam.utils.arguments import load_opt_from_config_file
from semantic_sam.utils.constants import COCO_PANOPTIC_CLASSES
from task_adapter.semantic_sam.tasks import inference_semsam_m2m_auto, prompt_switch
from segment_anything import sam_model_registry
from task_adapter.sam.tasks.inference_sam_m2m_auto import inference_sam_m2m_auto
from task_adapter.sam.tasks.inference_sam_m2m_interactive import inference_sam_m2m_interactive
from task_adapter.utils.visualizer import Visualizer
from detectron2.data import MetadataCatalog
from scipy.ndimage import label
from gpt4v import request_gpt4v
from openai import OpenAI
from pydub import AudioSegment
from pydub.playback import play | 17,946 | # --------------------------------------------------------
# Set-of-Mark (SoM) Prompting for Visual Grounding in GPT-4V
# Copyright (c) 2023 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by:
# Jianwei Yang (jianwyan@microsoft.com)
# Xueyan Zou (xueyan@cs.wisc.edu)
# Hao Zhang (hzhangcx@connect.ust.hk)
# --------------------------------------------------------
# seem
# semantic sam
# sam
metadata = MetadataCatalog.get('coco_2017_train_panoptic')
css4_colors = mcolors.CSS4_COLORS
color_proposals = [list(mcolors.hex2color(color)) for color in css4_colors.values()]
client = OpenAI()
'''
build args
'''
semsam_cfg = "configs/semantic_sam_only_sa-1b_swinL.yaml"
seem_cfg = "configs/seem_focall_unicl_lang_v1.yaml"
semsam_ckpt = "./swinl_only_sam_many2many.pth"
sam_ckpt = "./sam_vit_h_4b8939.pth"
seem_ckpt = "./seem_focall_v1.pt"
opt_semsam = load_opt_from_config_file(semsam_cfg)
opt_seem = load_opt_from_config_file(seem_cfg)
opt_seem = init_distributed_seem(opt_seem)
'''
build model
'''
model_semsam = BaseModel(opt_semsam, build_model(opt_semsam)).from_pretrained(semsam_ckpt).eval().cuda()
model_sam = sam_model_registry["vit_h"](checkpoint=sam_ckpt).eval().cuda()
model_seem = BaseModel_Seem(opt_seem, build_model_seem(opt_seem)).from_pretrained(seem_ckpt).eval().cuda()
with torch.no_grad():
with torch.autocast(device_type='cuda', dtype=torch.float16):
model_seem.model.sem_seg_head.predictor.lang_encoder.get_text_embeddings(COCO_PANOPTIC_CLASSES + ["background"], is_eval=True)
history_images = []
history_masks = []
history_texts = []
@torch.no_grad()
def inference(image, slider, mode, alpha, label_mode, anno_mode, *args, **kwargs):
global history_images; history_images = []
global history_masks; history_masks = []
if slider < 1.5:
model_name = 'seem'
elif slider > 2.5:
model_name = 'sam'
else:
if mode == 'Automatic':
model_name = 'semantic-sam'
if slider < 1.5 + 0.14:
level = [1]
elif slider < 1.5 + 0.28:
level = [2]
elif slider < 1.5 + 0.42:
level = [3]
elif slider < 1.5 + 0.56:
level = [4]
elif slider < 1.5 + 0.70:
level = [5]
elif slider < 1.5 + 0.84:
level = [6]
else:
level = [6, 1, 2, 3, 4, 5]
else:
model_name = 'sam'
if label_mode == 'Alphabet':
label_mode = 'a'
else:
label_mode = '1'
text_size, hole_scale, island_scale=640,100,100
text, text_part, text_thresh = '','','0.0'
with torch.autocast(device_type='cuda', dtype=torch.float16):
semantic=False
if mode == "Interactive":
labeled_array, num_features = label(np.asarray(image['mask'].convert('L')))
spatial_masks = torch.stack([torch.from_numpy(labeled_array == i+1) for i in range(num_features)])
if model_name == 'semantic-sam':
model = model_semsam
output, mask = inference_semsam_m2m_auto(model, image['image'], level, text, text_part, text_thresh, text_size, hole_scale, island_scale, semantic, label_mode=label_mode, alpha=alpha, anno_mode=anno_mode, *args, **kwargs)
elif model_name == 'sam':
model = model_sam
if mode == "Automatic":
output, mask = inference_sam_m2m_auto(model, image['image'], text_size, label_mode, alpha, anno_mode)
elif mode == "Interactive":
output, mask = inference_sam_m2m_interactive(model, image['image'], spatial_masks, text_size, label_mode, alpha, anno_mode)
elif model_name == 'seem':
model = model_seem
if mode == "Automatic":
| # --------------------------------------------------------
# Set-of-Mark (SoM) Prompting for Visual Grounding in GPT-4V
# Copyright (c) 2023 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by:
# Jianwei Yang (jianwyan@microsoft.com)
# Xueyan Zou (xueyan@cs.wisc.edu)
# Hao Zhang (hzhangcx@connect.ust.hk)
# --------------------------------------------------------
# seem
# semantic sam
# sam
metadata = MetadataCatalog.get('coco_2017_train_panoptic')
css4_colors = mcolors.CSS4_COLORS
color_proposals = [list(mcolors.hex2color(color)) for color in css4_colors.values()]
client = OpenAI()
'''
build args
'''
semsam_cfg = "configs/semantic_sam_only_sa-1b_swinL.yaml"
seem_cfg = "configs/seem_focall_unicl_lang_v1.yaml"
semsam_ckpt = "./swinl_only_sam_many2many.pth"
sam_ckpt = "./sam_vit_h_4b8939.pth"
seem_ckpt = "./seem_focall_v1.pt"
opt_semsam = load_opt_from_config_file(semsam_cfg)
opt_seem = load_opt_from_config_file(seem_cfg)
opt_seem = init_distributed_seem(opt_seem)
'''
build model
'''
model_semsam = BaseModel(opt_semsam, build_model(opt_semsam)).from_pretrained(semsam_ckpt).eval().cuda()
model_sam = sam_model_registry["vit_h"](checkpoint=sam_ckpt).eval().cuda()
model_seem = BaseModel_Seem(opt_seem, build_model_seem(opt_seem)).from_pretrained(seem_ckpt).eval().cuda()
with torch.no_grad():
with torch.autocast(device_type='cuda', dtype=torch.float16):
model_seem.model.sem_seg_head.predictor.lang_encoder.get_text_embeddings(COCO_PANOPTIC_CLASSES + ["background"], is_eval=True)
history_images = []
history_masks = []
history_texts = []
@torch.no_grad()
def inference(image, slider, mode, alpha, label_mode, anno_mode, *args, **kwargs):
global history_images; history_images = []
global history_masks; history_masks = []
if slider < 1.5:
model_name = 'seem'
elif slider > 2.5:
model_name = 'sam'
else:
if mode == 'Automatic':
model_name = 'semantic-sam'
if slider < 1.5 + 0.14:
level = [1]
elif slider < 1.5 + 0.28:
level = [2]
elif slider < 1.5 + 0.42:
level = [3]
elif slider < 1.5 + 0.56:
level = [4]
elif slider < 1.5 + 0.70:
level = [5]
elif slider < 1.5 + 0.84:
level = [6]
else:
level = [6, 1, 2, 3, 4, 5]
else:
model_name = 'sam'
if label_mode == 'Alphabet':
label_mode = 'a'
else:
label_mode = '1'
text_size, hole_scale, island_scale=640,100,100
text, text_part, text_thresh = '','','0.0'
with torch.autocast(device_type='cuda', dtype=torch.float16):
semantic=False
if mode == "Interactive":
labeled_array, num_features = label(np.asarray(image['mask'].convert('L')))
spatial_masks = torch.stack([torch.from_numpy(labeled_array == i+1) for i in range(num_features)])
if model_name == 'semantic-sam':
model = model_semsam
output, mask = inference_semsam_m2m_auto(model, image['image'], level, text, text_part, text_thresh, text_size, hole_scale, island_scale, semantic, label_mode=label_mode, alpha=alpha, anno_mode=anno_mode, *args, **kwargs)
elif model_name == 'sam':
model = model_sam
if mode == "Automatic":
output, mask = inference_sam_m2m_auto(model, image['image'], text_size, label_mode, alpha, anno_mode)
elif mode == "Interactive":
output, mask = inference_sam_m2m_interactive(model, image['image'], spatial_masks, text_size, label_mode, alpha, anno_mode)
elif model_name == 'seem':
model = model_seem
if mode == "Automatic": | output, mask = inference_seem_pano(model, image['image'], text_size, label_mode, alpha, anno_mode) | 1 | 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,809 |
# 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()
|
# 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) | 0 | 2023-10-19 17:49:24+00:00 | 24k |
ZhengyiLuo/PerpetualHumanoidControl | scripts/render_smpl_o3d.py | [
{
"identifier": "SMPL_Parser",
"path": "uhc/smpllib/smpl_parser.py",
"snippet": "class SMPL_Parser(_SMPL):\n\n def __init__(self, create_transl=False, *args, **kwargs):\n \"\"\"SMPL model constructor\n Parameters\n ----------\n model_path: str\n The path to the ... | import glob
import os
import sys
import pdb
import os.path as osp
import open3d as o3d
import open3d.visualization.rendering as rendering
import imageio
import joblib
import numpy as np
import torch
import random
import matplotlib.pyplot as plt
import cv2
from tqdm import tqdm
from uhc.smpllib.smpl_parser import (
SMPL_Parser,
SMPLH_Parser,
SMPLX_Parser,
)
from uhc.smpllib.smpl_mujoco import SMPL_BONE_ORDER_NAMES as joint_names
from poselib.poselib.skeleton.skeleton3d import SkeletonTree, SkeletonMotion, SkeletonState
from scipy.spatial.transform import Rotation as sRot
from tqdm import tqdm | 19,684 |
sys.path.append(os.getcwd())
paused, reset, recording, image_list, writer, control, curr_zoom = False, False, False, [], None, None, 0.01
def main():
render = rendering.OffscreenRenderer(2560, 960)
# render.scene.set_clear_color(np.array([0, 0, 0, 1]))
############ Load SMPL Data ############
pkl_dir = "output/renderings/smpl_im_comp_8-2023-02-05-15:36:14.pkl"
mujoco_joint_names = ['Pelvis', 'L_Hip', 'L_Knee', 'L_Ankle', 'L_Toe', 'R_Hip', 'R_Knee', 'R_Ankle', 'R_Toe', 'Torso', 'Spine', 'Chest', 'Neck', 'Head', 'L_Thorax', 'L_Shoulder', 'L_Elbow', 'L_Wrist', 'L_Hand', 'R_Thorax', 'R_Shoulder', 'R_Elbow', 'R_Wrist', 'R_Hand']
Name = pkl_dir.split("/")[-1].split(".")[0]
pkl_data = joblib.load(pkl_dir)
data_dir = "data/smpl"
mujoco_2_smpl = [mujoco_joint_names.index(q) for q in joint_names if q in mujoco_joint_names]
smpl_parser_n = SMPL_Parser(model_path=data_dir, gender="neutral")
smpl_parser_m = SMPL_Parser(model_path=data_dir, gender="male")
smpl_parser_f = SMPL_Parser(model_path=data_dir, gender="female")
data_seq = pkl_data['0_0']
pose_quat, trans = data_seq['body_quat'].numpy()[::2], data_seq['trans'].numpy()[::2]
|
sys.path.append(os.getcwd())
paused, reset, recording, image_list, writer, control, curr_zoom = False, False, False, [], None, None, 0.01
def main():
render = rendering.OffscreenRenderer(2560, 960)
# render.scene.set_clear_color(np.array([0, 0, 0, 1]))
############ Load SMPL Data ############
pkl_dir = "output/renderings/smpl_im_comp_8-2023-02-05-15:36:14.pkl"
mujoco_joint_names = ['Pelvis', 'L_Hip', 'L_Knee', 'L_Ankle', 'L_Toe', 'R_Hip', 'R_Knee', 'R_Ankle', 'R_Toe', 'Torso', 'Spine', 'Chest', 'Neck', 'Head', 'L_Thorax', 'L_Shoulder', 'L_Elbow', 'L_Wrist', 'L_Hand', 'R_Thorax', 'R_Shoulder', 'R_Elbow', 'R_Wrist', 'R_Hand']
Name = pkl_dir.split("/")[-1].split(".")[0]
pkl_data = joblib.load(pkl_dir)
data_dir = "data/smpl"
mujoco_2_smpl = [mujoco_joint_names.index(q) for q in joint_names if q in mujoco_joint_names]
smpl_parser_n = SMPL_Parser(model_path=data_dir, gender="neutral")
smpl_parser_m = SMPL_Parser(model_path=data_dir, gender="male")
smpl_parser_f = SMPL_Parser(model_path=data_dir, gender="female")
data_seq = pkl_data['0_0']
pose_quat, trans = data_seq['body_quat'].numpy()[::2], data_seq['trans'].numpy()[::2] | skeleton_tree = SkeletonTree.from_dict(data_seq['skeleton_tree']) | 4 | 2023-10-15 19:05:47+00:00 | 24k |
e4s2023/E4S2023 | face_swap_video_pipeline.py | [
{
"identifier": "OurSwapFacePipelineOptions",
"path": "options/our_swap_face_pipeline_options.py",
"snippet": "class OurSwapFacePipelineOptions:\n\n\tdef __init__(self):\n\t\tself.parser = ArgumentParser()\n\t\tself.initialize()\n\n\tdef initialize(self):\n\t\tself.parser.add_argument('--exp_dir', type=... | import argparse
import copy
import os
import datetime
import glob
import cv2
import numpy as np
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from tqdm import tqdm
from PIL import Image
from skimage.transform import resize
from torch.nn import functional as F
from options.our_swap_face_pipeline_options import OurSwapFacePipelineOptions
from utils import torch_utils
from models.networks import Net3
from datasets.dataset import get_transforms, TO_TENSOR, NORMALIZE
from gradio_utils.face_swapping import (
read_video_as_frames,
save_frames_as_video,
crop_and_align_face,
logical_or_reduce,
create_masks,
get_facial_mask_from_seg19,
get_edge,
blending_two_images_with_mask,
SoftErosion,
)
from swap_face_fine.face_vid2vid.drive_demo import init_facevid2vid_pretrained_model, drive_source_demo
from swap_face_fine.face_parsing.face_parsing_demo import (
init_faceParsing_pretrained_model,
faceParsing_demo,
vis_parsing_maps
)
from swap_face_fine.gpen.gpen_demo import GPENInfer
from swap_face_fine.inference_codeformer import CodeFormerInfer
from swap_face_fine.realesr.image_infer import RealESRBatchInfer
from training.video_swap_ft_coach import VideoSwapPTICoach
from swap_face_fine.swap_face_mask import swap_head_mask_hole_first, swap_comp_style_vector
from swap_face_fine.multi_band_blending import blending
from swap_face_fine.Blender.inference import BlenderInfer | 20,415 | S_mask = faceParsing_demo(face_parsing_model, source, convert_to_seg12=True)
D_mask = [faceParsing_demo(face_parsing_model, d, convert_to_seg12=True) for d in drivens]
save_img_dir = os.path.join(self.out_dir, "imgs")
save_mask_dir = os.path.join(self.out_dir, "mask")
os.makedirs(save_img_dir, exist_ok=True)
os.makedirs(save_mask_dir, exist_ok=True)
for i in range(len(T_mask)):
targets[i].save(os.path.join(save_img_dir, "T_%04d.png" % i))
Image.fromarray(T_mask[i]).save(os.path.join(save_mask_dir, "T_mask_%04d.png" % i))
Image.fromarray(D_mask[i]).save(os.path.join(save_mask_dir, "D_mask_%04d.png" % i))
D_mask_vis = vis_parsing_maps(drivens[i], D_mask[i])
Image.fromarray(D_mask_vis).save(os.path.join(save_mask_dir, "D_mask_vis_%04d.png" % i))
Image.fromarray(S_mask).save(os.path.join(save_mask_dir, "S_mask.png"))
return {
"targets_mask": T_mask,
"source_mask": S_mask,
"drivens_mask": D_mask,
}
def _process_face_reenact(self, targets, source,
use_recolor: bool = False):
self._load_face_reenact_model()
generator = self.face_reenact_model["generator"]
kp_detector = self.face_reenact_model["kp_detector"]
he_estimator = self.face_reenact_model["he_estimator"]
estimate_jacobian = self.face_reenact_model["estimate_jacobian"]
print("[FaceSwapVideoPipeline] face reenacting...")
targets_256 = [resize(np.array(im) / 255.0, (256, 256)) for im in targets]
source_256 = resize(np.array(source) / 255.0, (256, 256))
predictions = drive_source_demo(source_256, targets_256,
generator, kp_detector, he_estimator, estimate_jacobian)
predictions = [(pred * 255).astype(np.uint8) for pred in predictions] # RGB
predictions = self._process_face_enhance(
predictions, model_name="gpen",
) # fixed as gpen
''' color transfer before pasting back '''
predictions_recolor = [None] * len(predictions)
if use_recolor:
predictions_recolor = [None] * len(predictions)
face_parsing_model = self._load_face_parsing_model()["model"]
face_enhance_model = self._load_face_enhance_model("codeformer")["codeformer"]
recolor_save_dir = os.path.join(self.out_dir, "recolor_before_rgi")
os.makedirs(recolor_save_dir, exist_ok=True)
face_recolor_model = self._load_face_recolor_model()["model"]
mask_softer_model = self._load_mask_softer()["model"]
for i in range(len(predictions)):
# swapped_face_image = Image.fromarray(predictions[i])
swapped_face_image = predictions[i]
swapped_face_image.save(os.path.join(recolor_save_dir, "recolor_input_%04d.png" % i))
T = targets[i].resize(swapped_face_image.size)
swap_mask_19 = faceParsing_demo(face_parsing_model, swapped_face_image, convert_to_seg12=False)
target_mask_19 = faceParsing_demo(face_parsing_model, T, convert_to_seg12=False)
recolor: Image = face_recolor_model.infer_image(
swapped_face_image, T,
Image.fromarray(swap_mask_19), Image.fromarray(target_mask_19)
)
recolor.save(os.path.join(recolor_save_dir, "recolor_gen_%04d.png" % i))
recolor = recolor.resize(swapped_face_image.size)
recolor = face_enhance_model.infer_image(recolor) # no need to super-res?
recolor = recolor.resize((512, 512)).resize(recolor.size) # resize down to avoid too high-res in video
recolor.save(os.path.join(recolor_save_dir, "gen_enhance_%04d.png" % i))
# only copy low-frequency parts
# blending_mask = get_facial_mask_from_seg19(
# torch.LongTensor(swap_mask_19[None, None, :, :]),
# target_size=recolor.size, edge_softer=mask_softer_model, is_seg19=True
# )
# edge = get_edge(swapped_face_image)
# edge = np.array(edge).astype(np.float32) / 255.
# blending_mask = (blending_mask - edge).clip(0., 1.)
# Image.fromarray((blending_mask.squeeze() * 255.).astype(np.uint8)).save(
# os.path.join(recolor_save_dir, "blend_mask_%04d.png" % i)
# )
# recolor = blending_two_images_with_mask(
# swapped_face_image, recolor, up_ratio=0.95, up_mask=blending_mask.copy()
# )
# recolor.save(os.path.join(recolor_save_dir, "recolor_blend_%04d.png" % i))
predictions_recolor[i] = np.array(recolor) # RGB
imgs_save_dir = os.path.join(self.out_dir, "imgs")
os.makedirs(imgs_save_dir, exist_ok=True)
for i in range(len(predictions_recolor)):
Image.fromarray(predictions_recolor[i]).save(
os.path.join(imgs_save_dir, "%s%04d.png" % ("D_recolor_", i)))
''' end '''
self._free_face_reenact_model()
return predictions, predictions_recolor
def _process_face_enhance(self, lq_images: list,
model_name: str = "gpen",
save_prefix: str = "D_",
):
self._load_face_enhance_model(model_name)
enhance_model = self.face_enhance_model[model_name]
print("[FaceSwapVideoPipeline] face enhancing...")
hq_images = [enhance_model.infer_image(Image.fromarray(lq)) for lq in lq_images]
save_dir = os.path.join(self.out_dir, "imgs")
os.makedirs(save_dir, exist_ok=True)
for i in range(len(hq_images)):
hq_images[i].save(os.path.join(save_dir, "%s%04d.png" % (save_prefix, i)))
return hq_images
@torch.no_grad()
def _process_extract_init_style_vectors(self, drivens, targets, drivens_mask, targets_mask):
save_dir = os.path.join(self.out_dir, "styleVec")
os.makedirs(save_dir, exist_ok=True)
net = self._load_e4s_model()
for i, (d, t) in enumerate(zip(drivens, targets)):
|
class FaceSwapVideoPipeline(object):
def __init__(self,
e4s_opt: argparse.Namespace,
use_time_subfolder: bool = True,
):
self.exp_root = e4s_opt.exp_dir
self.out_dir = e4s_opt.exp_dir
self.pti_save_fn = None
self.use_time_subfolder = use_time_subfolder
self.e4s_opt = e4s_opt
self.e4s_model = None
self.device = e4s_opt.device
# models are lazy loaded
self.face_reenact_model = {}
self.face_parsing_model = {}
self.face_enhance_model = {}
self.face_recolor_model = {}
self.mask_softer_model = {}
self.num_seg_cls = 12 # fixed
def forward(self,
target_video_path: str,
source_image_path: str,
result_video_fn: str = "output.mp4",
use_crop: bool = True,
target_frames_cnt: int = -1,
use_pti: bool = True,
pti_resume_weight_path: str = "./video_outputs/finetuned_G_lr0.001000_iters80.pth",
):
"""
@param target_video_path:
@param source_image_path:
@param result_video_fn:
@param use_crop:
@param target_frames_cnt:
@param use_pti:
@param pti_resume_weight_path: if opt.max_pti_steps == 0, the pipeline will use this pre-trained weight file
"""
# 0. update time, used as output directory
self._update_out_dir()
# 1. prepare input target and source
target_paths, source_paths = self._prepare_inputs(
target_video_path, source_image_path, target_frames_cnt=target_frames_cnt,
)
target_frames_cnt = len(target_paths)
# 2. crop and align
crop_results = self._process_crop_align(
target_paths, source_paths, use_crop=use_crop,
)
T = crop_results["targets_crop"]
S = crop_results["source_crop"]
T_ori = crop_results["targets_ori"]
T_inv_trans = crop_results["targets_inv_trans"]
# 3. face reenactment
drivens, drivens_recolor = self._process_face_reenact(
T, S, use_recolor=True
)
# 4. face enhancement
# drivens = self._process_face_enhance(
# drivens, model_name="codeformer",
# )
# if drivens_recolor[0] is not None:
# drivens_recolor = self._process_face_enhance(
# drivens_recolor, model_name="codeformer", save_prefix="D_recolor_"
# )
# 5. face parsing
parsing_results = self._process_face_parsing(
T, S, drivens
)
T_mask = parsing_results["targets_mask"]
S_mask = parsing_results["source_mask"]
D_mask = parsing_results["drivens_mask"]
# 6. extract initial style vectors
self._process_extract_init_style_vectors(
drivens, T, drivens_mask=D_mask, targets_mask=T_mask
)
# 7. PTI tuning
if use_pti:
self._process_pti_tuning(
pti_resume_weight_path, target_frames_cnt=target_frames_cnt,
)
# 8. face swapping
swap_results = self._process_face_swapping(
target_frames_cnt, T_inv_trans, T_ori,
)
swaps_face = swap_results["swaps_face"] # each is: PIL.Image
swaps_mask = swap_results["swaps_mask"] # each is: np.ndarray(512,512), in {0,...,9}
# 9. prepare outputs
self._prepare_outputs(
result_video_fn, target_video_path
)
def _update_out_dir(self):
if not self.use_time_subfolder:
return
now = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
out_dir = os.path.join(self.exp_root, now)
os.makedirs(out_dir, exist_ok=True)
self.out_dir = out_dir
self.e4s_opt.exp_dir = out_dir
print(f"[FaceSwapVideoPipeline] out directory changed to: {self.out_dir}")
return
def _prepare_inputs(self, target_video_path: str, source_image_path: str,
target_frames_cnt: int = 120,
):
in_target_frames_folder = os.path.join(self.out_dir, "in_frames/")
t_frames, t_paths = read_video_as_frames(target_video_path, in_target_frames_folder)
t_frames = t_frames[:target_frames_cnt]
t_paths = t_paths[:target_frames_cnt] # many targets
s_paths = [source_image_path] # only 1 source
# save inputs
target_save_path = os.path.join(self.out_dir, "target.mp4")
source_save_path = os.path.join(self.out_dir, "source.png")
os.system(f"cp {target_video_path} {target_save_path}")
os.system(f"cp {source_image_path} {source_save_path}")
return t_paths, s_paths
def _process_crop_align(self, t_paths: list, s_paths: list, use_crop: bool):
if use_crop:
target_files = [(os.path.basename(f).split('.')[0], f) for f in t_paths]
source_files = [(os.path.basename(f).split('.')[0], f) for f in s_paths]
target_crops, target_orig_images, target_quads, target_inv_transforms = crop_and_align_face(
target_files, image_size=1024, scale=1.0, center_sigma=1.0, xy_sigma=3.0, use_fa=False
)
T = [crop.convert("RGB") for crop in target_crops]
source_crops, source_orig_images, source_quads, source_inv_transforms = crop_and_align_face(
source_files, image_size=1024, scale=1.0, center_sigma=0, xy_sigma=0, use_fa=False
)
S = source_crops[0].convert("RGB")
T_ori = target_orig_images
T_inv_trans = target_inv_transforms
else:
T = [Image.open(t).convert("RGB").resize((1024, 1024)) for t in t_paths]
S = Image.open(s_paths[0]).convert("RGB").resize((1024, 1024))
T_ori = T
T_inv_trans = None
return {
"targets_crop": T,
"source_crop": S,
"targets_ori": T_ori,
"targets_inv_trans": T_inv_trans
}
def _process_face_parsing(self, targets, source, drivens):
self._load_face_parsing_model()
face_parsing_model = self.face_parsing_model["model"]
print("[FaceSwapVideoPipeline] face parsing...")
T_mask = [faceParsing_demo(face_parsing_model, frm, convert_to_seg12=True) for frm in targets] # 12
S_mask = faceParsing_demo(face_parsing_model, source, convert_to_seg12=True)
D_mask = [faceParsing_demo(face_parsing_model, d, convert_to_seg12=True) for d in drivens]
save_img_dir = os.path.join(self.out_dir, "imgs")
save_mask_dir = os.path.join(self.out_dir, "mask")
os.makedirs(save_img_dir, exist_ok=True)
os.makedirs(save_mask_dir, exist_ok=True)
for i in range(len(T_mask)):
targets[i].save(os.path.join(save_img_dir, "T_%04d.png" % i))
Image.fromarray(T_mask[i]).save(os.path.join(save_mask_dir, "T_mask_%04d.png" % i))
Image.fromarray(D_mask[i]).save(os.path.join(save_mask_dir, "D_mask_%04d.png" % i))
D_mask_vis = vis_parsing_maps(drivens[i], D_mask[i])
Image.fromarray(D_mask_vis).save(os.path.join(save_mask_dir, "D_mask_vis_%04d.png" % i))
Image.fromarray(S_mask).save(os.path.join(save_mask_dir, "S_mask.png"))
return {
"targets_mask": T_mask,
"source_mask": S_mask,
"drivens_mask": D_mask,
}
def _process_face_reenact(self, targets, source,
use_recolor: bool = False):
self._load_face_reenact_model()
generator = self.face_reenact_model["generator"]
kp_detector = self.face_reenact_model["kp_detector"]
he_estimator = self.face_reenact_model["he_estimator"]
estimate_jacobian = self.face_reenact_model["estimate_jacobian"]
print("[FaceSwapVideoPipeline] face reenacting...")
targets_256 = [resize(np.array(im) / 255.0, (256, 256)) for im in targets]
source_256 = resize(np.array(source) / 255.0, (256, 256))
predictions = drive_source_demo(source_256, targets_256,
generator, kp_detector, he_estimator, estimate_jacobian)
predictions = [(pred * 255).astype(np.uint8) for pred in predictions] # RGB
predictions = self._process_face_enhance(
predictions, model_name="gpen",
) # fixed as gpen
''' color transfer before pasting back '''
predictions_recolor = [None] * len(predictions)
if use_recolor:
predictions_recolor = [None] * len(predictions)
face_parsing_model = self._load_face_parsing_model()["model"]
face_enhance_model = self._load_face_enhance_model("codeformer")["codeformer"]
recolor_save_dir = os.path.join(self.out_dir, "recolor_before_rgi")
os.makedirs(recolor_save_dir, exist_ok=True)
face_recolor_model = self._load_face_recolor_model()["model"]
mask_softer_model = self._load_mask_softer()["model"]
for i in range(len(predictions)):
# swapped_face_image = Image.fromarray(predictions[i])
swapped_face_image = predictions[i]
swapped_face_image.save(os.path.join(recolor_save_dir, "recolor_input_%04d.png" % i))
T = targets[i].resize(swapped_face_image.size)
swap_mask_19 = faceParsing_demo(face_parsing_model, swapped_face_image, convert_to_seg12=False)
target_mask_19 = faceParsing_demo(face_parsing_model, T, convert_to_seg12=False)
recolor: Image = face_recolor_model.infer_image(
swapped_face_image, T,
Image.fromarray(swap_mask_19), Image.fromarray(target_mask_19)
)
recolor.save(os.path.join(recolor_save_dir, "recolor_gen_%04d.png" % i))
recolor = recolor.resize(swapped_face_image.size)
recolor = face_enhance_model.infer_image(recolor) # no need to super-res?
recolor = recolor.resize((512, 512)).resize(recolor.size) # resize down to avoid too high-res in video
recolor.save(os.path.join(recolor_save_dir, "gen_enhance_%04d.png" % i))
# only copy low-frequency parts
# blending_mask = get_facial_mask_from_seg19(
# torch.LongTensor(swap_mask_19[None, None, :, :]),
# target_size=recolor.size, edge_softer=mask_softer_model, is_seg19=True
# )
# edge = get_edge(swapped_face_image)
# edge = np.array(edge).astype(np.float32) / 255.
# blending_mask = (blending_mask - edge).clip(0., 1.)
# Image.fromarray((blending_mask.squeeze() * 255.).astype(np.uint8)).save(
# os.path.join(recolor_save_dir, "blend_mask_%04d.png" % i)
# )
# recolor = blending_two_images_with_mask(
# swapped_face_image, recolor, up_ratio=0.95, up_mask=blending_mask.copy()
# )
# recolor.save(os.path.join(recolor_save_dir, "recolor_blend_%04d.png" % i))
predictions_recolor[i] = np.array(recolor) # RGB
imgs_save_dir = os.path.join(self.out_dir, "imgs")
os.makedirs(imgs_save_dir, exist_ok=True)
for i in range(len(predictions_recolor)):
Image.fromarray(predictions_recolor[i]).save(
os.path.join(imgs_save_dir, "%s%04d.png" % ("D_recolor_", i)))
''' end '''
self._free_face_reenact_model()
return predictions, predictions_recolor
def _process_face_enhance(self, lq_images: list,
model_name: str = "gpen",
save_prefix: str = "D_",
):
self._load_face_enhance_model(model_name)
enhance_model = self.face_enhance_model[model_name]
print("[FaceSwapVideoPipeline] face enhancing...")
hq_images = [enhance_model.infer_image(Image.fromarray(lq)) for lq in lq_images]
save_dir = os.path.join(self.out_dir, "imgs")
os.makedirs(save_dir, exist_ok=True)
for i in range(len(hq_images)):
hq_images[i].save(os.path.join(save_dir, "%s%04d.png" % (save_prefix, i)))
return hq_images
@torch.no_grad()
def _process_extract_init_style_vectors(self, drivens, targets, drivens_mask, targets_mask):
save_dir = os.path.join(self.out_dir, "styleVec")
os.makedirs(save_dir, exist_ok=True)
net = self._load_e4s_model()
for i, (d, t) in enumerate(zip(drivens, targets)): | driven = transforms.Compose([TO_TENSOR, NORMALIZE])(d) | 4 | 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,764 |
@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)
agents.reset()
messages: list[tuple[str, str, Message]] = []
# Main Event Loop
done = False
for agent_name in env.agents:
messages.append(
("Environment", agent_name, environment_messages[agent_name])
)
while not done:
# gather agent messages
agent_messages: dict[str, AgentAction] = dict()
for agent_name in env.agents:
if agents_info is not None:
agents[agent_name].goal = agents_info[agent_name]["goal"]
agent_messages[agent_name] = agents[agent_name].act(
environment_messages[agent_name]
)
messages.append(
(agent_name, "Environment", agent_messages[agent_name])
)
# send agent messages to environment
environment_messages, _, terminated, ___, ____ = env.step(
agent_messages
)
for agent_name in env.agents:
messages.append(
("Environment", agent_name, environment_messages[agent_name])
)
done = all(terminated.values())
return messages
@gin.configurable
async def arun_one_episode(
env: ParallelSotopiaEnv,
agent_list: Sequence[BaseAgent[Observation, AgentAction]],
model_dict: dict[str, LLM_Name],
omniscient: bool = False,
script_like: bool = False,
json_in_script: bool = False,
tag: str | None = None,
push_to_db: bool = False,
) -> list[tuple[str, str, Message]]:
agents = Agents({agent.agent_name: agent for agent in agent_list})
environment_messages = env.reset(agents=agents, omniscient=omniscient)
agents_model_names = [model_dict["agent1"], model_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 agent_model == "redis":
agents[agent_name] = RedisAgent(agent_name)
elif script_like and not json_in_script:
|
@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)
agents.reset()
messages: list[tuple[str, str, Message]] = []
# Main Event Loop
done = False
for agent_name in env.agents:
messages.append(
("Environment", agent_name, environment_messages[agent_name])
)
while not done:
# gather agent messages
agent_messages: dict[str, AgentAction] = dict()
for agent_name in env.agents:
if agents_info is not None:
agents[agent_name].goal = agents_info[agent_name]["goal"]
agent_messages[agent_name] = agents[agent_name].act(
environment_messages[agent_name]
)
messages.append(
(agent_name, "Environment", agent_messages[agent_name])
)
# send agent messages to environment
environment_messages, _, terminated, ___, ____ = env.step(
agent_messages
)
for agent_name in env.agents:
messages.append(
("Environment", agent_name, environment_messages[agent_name])
)
done = all(terminated.values())
return messages
@gin.configurable
async def arun_one_episode(
env: ParallelSotopiaEnv,
agent_list: Sequence[BaseAgent[Observation, AgentAction]],
model_dict: dict[str, LLM_Name],
omniscient: bool = False,
script_like: bool = False,
json_in_script: bool = False,
tag: str | None = None,
push_to_db: bool = False,
) -> list[tuple[str, str, Message]]:
agents = Agents({agent.agent_name: agent for agent in agent_list})
environment_messages = env.reset(agents=agents, omniscient=omniscient)
agents_model_names = [model_dict["agent1"], model_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 agent_model == "redis":
agents[agent_name] = RedisAgent(agent_name)
elif script_like and not json_in_script: | agents[agent_name] = ScriptWritingAgent( | 3 | 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,
) | 15,743 |
@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)
| """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( | 7 | 2023-10-18 13:12:20+00:00 | 24k |
amitfin/oref_alert | custom_components/oref_alert/coordinator.py | [
{
"identifier": "CONF_ALERT_MAX_AGE",
"path": "custom_components/oref_alert/const.py",
"snippet": "CONF_ALERT_MAX_AGE: Final = \"alert_max_age\""
},
{
"identifier": "CONF_POLL_INTERVAL",
"path": "custom_components/oref_alert/const.py",
"snippet": "CONF_POLL_INTERVAL: Final = \"poll_inter... | import asyncio
import homeassistant.util.dt as dt_util
from dataclasses import dataclass
from datetime import timedelta
from functools import cmp_to_key
from json import JSONDecodeError
from typing import Any
from aiohttp.client_exceptions import ContentTypeError
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
from .const import (
CONF_ALERT_MAX_AGE,
CONF_POLL_INTERVAL,
DEFAULT_POLL_INTERVAL,
DOMAIN,
IST,
LOGGER,
)
from .metadata.areas import AREAS | 17,932 | """DataUpdateCoordinator for oref_alert integration."""
OREF_ALERTS_URL = "https://www.oref.org.il/WarningMessages/alert/alerts.json"
OREF_HISTORY_URL = "https://www.oref.org.il/WarningMessages/History/AlertsHistory.json"
OREF_HEADERS = {
"Referer": "https://www.oref.org.il/",
"X-Requested-With": "XMLHttpRequest",
"Content-Type": "application/json",
}
REQUEST_RETRIES = 3
REAL_TIME_ALERT_LOGIC_WINDOW = 2
@dataclass
class OrefAlertCoordinatorData:
"""Class for holding coordinator data."""
alerts: list[Any]
active_alerts: list[Any]
def _sort_alerts(item1: dict[str, Any], item2: dict[str, Any]) -> int:
"""Sort by descending-order "date" and then ascending-order "name"."""
if item1["alertDate"] < item2["alertDate"]:
return 1
if item1["alertDate"] > item2["alertDate"]:
return -1
if item1["data"] > item2["data"]:
return 1
if item1["data"] < item2["data"]:
return -1
return 0
def _compare_fields(alert: dict[str, Any], area: str, category: int) -> bool:
"""Compare an alert with area and category (time is ignored)."""
return alert["data"] == area and alert["category"] == category
class OrefAlertDataUpdateCoordinator(DataUpdateCoordinator[OrefAlertCoordinatorData]):
"""Class to manage fetching Oref Alert data."""
def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry):
"""Initialize global data updater."""
super().__init__(
hass,
LOGGER,
name=DOMAIN,
update_interval=timedelta(
seconds=config_entry.options.get(
| """DataUpdateCoordinator for oref_alert integration."""
OREF_ALERTS_URL = "https://www.oref.org.il/WarningMessages/alert/alerts.json"
OREF_HISTORY_URL = "https://www.oref.org.il/WarningMessages/History/AlertsHistory.json"
OREF_HEADERS = {
"Referer": "https://www.oref.org.il/",
"X-Requested-With": "XMLHttpRequest",
"Content-Type": "application/json",
}
REQUEST_RETRIES = 3
REAL_TIME_ALERT_LOGIC_WINDOW = 2
@dataclass
class OrefAlertCoordinatorData:
"""Class for holding coordinator data."""
alerts: list[Any]
active_alerts: list[Any]
def _sort_alerts(item1: dict[str, Any], item2: dict[str, Any]) -> int:
"""Sort by descending-order "date" and then ascending-order "name"."""
if item1["alertDate"] < item2["alertDate"]:
return 1
if item1["alertDate"] > item2["alertDate"]:
return -1
if item1["data"] > item2["data"]:
return 1
if item1["data"] < item2["data"]:
return -1
return 0
def _compare_fields(alert: dict[str, Any], area: str, category: int) -> bool:
"""Compare an alert with area and category (time is ignored)."""
return alert["data"] == area and alert["category"] == category
class OrefAlertDataUpdateCoordinator(DataUpdateCoordinator[OrefAlertCoordinatorData]):
"""Class to manage fetching Oref Alert data."""
def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry):
"""Initialize global data updater."""
super().__init__(
hass,
LOGGER,
name=DOMAIN,
update_interval=timedelta(
seconds=config_entry.options.get( | CONF_POLL_INTERVAL, DEFAULT_POLL_INTERVAL | 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 | 20,712 | reg_type=self.helper.args.moe.reg_type,
std_correction=self.helper.args.moe.std_correction,
topk_mode=self.helper.args.moe.topk_mode,
head_projection_size=self.helper.args.transformer.head_projection_size,
activation_after_topk=self.helper.args.moe.activation_after_topk,
weight_grouping=self.helper.args.moe.weight_grouping,
kmeans_distance=self.helper.args.moe.kmeans_distance,
drop_parallel=self.helper.args.moe.drop_parallel,
block_expert_sel_in_grad=self.helper.args.moe.block_expert_sel_in_grad,
mlp_selection=self.helper.args.moe.mlp_selection,
classification_target=self.helper.args.moe.classification_target,
norm_key_init=self.helper.args.moe.norm_key_init,
normalize_expert_sel_init=self.helper.args.moe.norm_expert_sel_init,
norm_value_init=self.helper.args.moe.norm_value_init,
norm_standard_parallel_values=self.helper.args.moe.norm_standard_parallel_values,
identical_init=self.helper.args.moe.identical_init,
topological_sel_reg=self.helper.args.moe.topological_sel_reg,
topological_expert_reg=self.helper.args.moe.topological_expert_reg,
gumbel_select_only=self.helper.args.moe.gumbel_select_only,
topk_value_norm_compensation=self.helper.args.moe.topk_value_norm_compensation,
norm_expert_scores=self.helper.args.moe.norm_expert_scores,
sel_input_cluster_init=self.helper.args.moe.sel_input_cluster_init,
init_norm_mode=self.helper.args.moe.init_norm_mode,
sel_bias=self.helper.args.moe.sel_bias,
bias=self.helper.args.moe.bias,
rescale_normed=self.helper.args.moe.rescale_normed,
sel_norm=self.helper.args.moe.sel_norm,
rescale_grads=self.helper.args.moe.rescale_grads,
gumbel_decay=self.helper.args.moe.gumbel_decay,
ln_affine=self.helper.args.transformer.ln_affine,
sinkhorn_local=self.helper.args.moe.sinkhorn_local,
sinkhorn_n_iters=self.helper.args.moe.sinkhron_n_iters,
moe_dropout_factor=self.helper.args.moe.dropout_factor,
drop_expert=self.helper.args.moe.drop_expert,
expert_size_init=self.helper.args.moe.expert_size_init,
sync_distributed=self.helper.args.moe.sync_distributed,
modulation_amplitude=self.helper.args.moe.modulation_amplitude,
invisible_selection=self.helper.args.moe.invisible_selection,
slope_multiplier=self.helper.args.moe.slope_multiplier,
moe_init_scale=self.helper.args.moe.init_scale)
else:
assert False, "Invalid variant"
layers = [mklayer() for _ in range(self.helper.args.transformer.encoder_n_layers)]
return layers
def fix_init(self, model):
init_std = 0.02
torch.nn.init.normal_(model.embedding.weight, 0.0, init_std)
# torch.nn.init.normal_(model.embedding_adapter.weight, 0.0, init_std)
initialized = 0
for m in model.modules():
if isinstance(m, (torch.nn.Linear, torch.nn.Embedding)) and hasattr(m, "weight"):
torch.nn.init.normal_(m.weight, 0.0, init_std)
initialized += m.weight.numel()
if isinstance(m, (torch.nn.Linear, torch.nn.LayerNorm)) and m.bias is not None:
torch.nn.init.constant_(m.bias, 0)
initialized += m.bias.numel()
if isinstance(m, (torch.nn.LayerNorm)) and m.weight is not None:
torch.nn.init.normal_(m.weight, 1.0, init_std)
initialized += m.weight.numel()
if isinstance(m, MoE):
torch.nn.init.normal_(m.keys, 0.0, init_std)
torch.nn.init.normal_(m.values, 0.0, init_std)
if m.expert_sel is not None:
torch.nn.init.normal_(m.expert_sel, 0.0, init_std)
initialized += m.expert_sel.numel()
initialized += m.keys.numel() + m.values.numel()
print(f"Reinitialized {initialized/self.n_weights*100:.3f}% weights")
def create_model(self) -> torch.nn.Module:
# pyright: reportOptionalMemberAccess=false
tlayers = self.get_layers()
if self.helper.args.transformer.output_mode != "normal" and self.is_preln():
raise ValueError("accumulated_output not supported with pre-ln")
model = TransformerLanguageModel(
len(self.train_set.vocabulary), self.helper.args.embedding_size,
self.helper.args.state_size, self.helper.args.dropout,
tied_embedding=self.helper.args.tied_embedding,
layers=tlayers, n_prev_states=self.helper.args.lm.trafo.context_blocks,
n_prev_states_test=self.helper.args.lm.trafo.test_context_blocks,
same_length_eval=self.helper.args.lm.trafo.same_length_eval,
p_drop_layer=self.helper.args.transformer.p_drop_layer,
same_length=self.helper.args.lm.trafo.same_length,
use_last_state=self.helper.args.lm.trafo.last_layer_context,
norm_before_output=self.is_preln(), output_mode=self.helper.args.transformer.output_mode,)
self.n_weights = sum(p.numel() for p in model.parameters())
with torch.no_grad():
if self.is_preln():
model.embedding_scale = 1.0
elif self.helper.args.lm.trafo.xl_init:
self.fix_init(model)
elif self.helper.args.lm.trafo.embedding_mode_init=="scale_to_sqrt_dmodel":
norm = model.embedding.weight.norm(dim=-1).mean()
model.embedding_scale = math.sqrt(self.helper.args.state_size) / norm
elif self.helper.args.lm.trafo.embedding_mode_init=="one_and_scale_to_sqrt_dmodel":
norm = model.embedding.weight.norm(dim=-1).mean()
model.embedding_scale = math.sqrt(self.helper.args.state_size)
model.embedding.weight.mul_(1.0 / norm)
elif self.helper.args.lm.trafo.embedding_mode_init=="init_to_sqrt_dmodel":
norm = model.embedding.weight.norm(dim=-1, keepdim=True)
model.embedding_scale=1.0
model.embedding.weight.mul_(math.sqrt(self.helper.args.state_size) / norm)
return model
def moe_recluster(self):
for n, m in self.model.named_modules():
if isinstance(m, MoE):
perm = m.regroup_weights()
m.patch_optimizer_state(self.optimizer, perm)
|
@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(
**base_args, **extra_args, test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,
n_layers=self.helper.args.transformer.encoder_n_layers, k=self.helper.args.transformer.topk_value,
use_norm=self.helper.args.transformer.topk_use_norm,
head_projection_size=self.helper.args.transformer.head_projection_size,)
elif self.helper.args.transformer.variant in {"preln_kvmem"}:
mklayer = lambda: PrelnRelativeKVMemTransformerEncoderLayer(
**base_args, **extra_args, test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,
n_layers=self.helper.args.transformer.encoder_n_layers, n_keys=self.helper.args.pkm.n_keys,
pkm_stochastic=self.helper.args.pkm.stochastic, pkm_heads=self.helper.args.pkm.n_heads,
pkm_custom_init=self.helper.args.pkm.custom_init, pkm_slice_values=self.helper.args.pkm.slice_values,
pkm_knn=self.helper.args.pkm.knn, linproj=self.helper.args.kvmem.linproj,
head_merge_topk=self.helper.args.kvmem.head_merge_topk,
load_balance=self.helper.args.kvmem.load_balance, kvmem_dropout=self.helper.args.kvmem.dropout,
kvmem_randomize_indices=self.helper.args.kvmem.randomize_indices,
kvmem_query_bias=self.helper.args.kvmem.query_bias,
standard_parallel=self.helper.args.kvmem.standard_parallel,
approx_topk=self.helper.args.kvmem.approx_topk,
factorize=self.helper.args.kvmem.factorize,
full_key=self.helper.args.kvmem.full_key,
key_redundancy_factor=self.helper.args.kvmem.key_redundancy_factor,
two_stage=self.helper.args.kvmem.two_stage,
head_exclusive=self.helper.args.kvmem.head_exclusive,
head_projection_size=self.helper.args.transformer.head_projection_size,)
elif self.helper.args.transformer.variant in {"preln_moe", "preln_moe_universal", "moe", "moe_universal"}:
# def __init__(self, d_model, nhead, n_bins: int, bin_size: int, n_layers: int, dim_feedforward=2048,
mklayer = lambda: RelativeMoeTransformerEncoderLayer(
**base_args, **extra_args, preln=self.is_preln(),
test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,
n_layers=self.helper.args.transformer.encoder_n_layers,
standard_parallel=self.helper.args.kvmem.standard_parallel,
custom_init=self.helper.args.pkm.custom_init,
n_experts=self.helper.args.moe.n_experts,
expert_size=self.helper.args.moe.expert_size,
dropout_mode=self.helper.args.kvmem.dropout,
knn=self.helper.args.pkm.knn,
selection_mode=self.helper.args.moe.selection_mode,
perplexity_reg=self.helper.args.moe.perplexity_reg,
key_mode=self.helper.args.moe.key_mode,
half_key=self.helper.args.moe.half_key,
n_heads=self.helper.args.pkm.n_heads,
norm_keys=self.helper.args.moe.norm_keys,
perplexity_reg_mode=self.helper.args.moe.perplexity_reg_mode,
n_random=self.helper.args.moe.n_random,
reg_type=self.helper.args.moe.reg_type,
std_correction=self.helper.args.moe.std_correction,
topk_mode=self.helper.args.moe.topk_mode,
head_projection_size=self.helper.args.transformer.head_projection_size,
activation_after_topk=self.helper.args.moe.activation_after_topk,
weight_grouping=self.helper.args.moe.weight_grouping,
kmeans_distance=self.helper.args.moe.kmeans_distance,
drop_parallel=self.helper.args.moe.drop_parallel,
block_expert_sel_in_grad=self.helper.args.moe.block_expert_sel_in_grad,
mlp_selection=self.helper.args.moe.mlp_selection,
classification_target=self.helper.args.moe.classification_target,
norm_key_init=self.helper.args.moe.norm_key_init,
normalize_expert_sel_init=self.helper.args.moe.norm_expert_sel_init,
norm_value_init=self.helper.args.moe.norm_value_init,
norm_standard_parallel_values=self.helper.args.moe.norm_standard_parallel_values,
identical_init=self.helper.args.moe.identical_init,
topological_sel_reg=self.helper.args.moe.topological_sel_reg,
topological_expert_reg=self.helper.args.moe.topological_expert_reg,
gumbel_select_only=self.helper.args.moe.gumbel_select_only,
topk_value_norm_compensation=self.helper.args.moe.topk_value_norm_compensation,
norm_expert_scores=self.helper.args.moe.norm_expert_scores,
sel_input_cluster_init=self.helper.args.moe.sel_input_cluster_init,
init_norm_mode=self.helper.args.moe.init_norm_mode,
sel_bias=self.helper.args.moe.sel_bias,
bias=self.helper.args.moe.bias,
rescale_normed=self.helper.args.moe.rescale_normed,
sel_norm=self.helper.args.moe.sel_norm,
rescale_grads=self.helper.args.moe.rescale_grads,
gumbel_decay=self.helper.args.moe.gumbel_decay,
ln_affine=self.helper.args.transformer.ln_affine,
sinkhorn_local=self.helper.args.moe.sinkhorn_local,
sinkhorn_n_iters=self.helper.args.moe.sinkhron_n_iters,
moe_dropout_factor=self.helper.args.moe.dropout_factor,
drop_expert=self.helper.args.moe.drop_expert,
expert_size_init=self.helper.args.moe.expert_size_init,
sync_distributed=self.helper.args.moe.sync_distributed,
modulation_amplitude=self.helper.args.moe.modulation_amplitude,
invisible_selection=self.helper.args.moe.invisible_selection,
slope_multiplier=self.helper.args.moe.slope_multiplier,
moe_init_scale=self.helper.args.moe.init_scale)
else:
assert False, "Invalid variant"
layers = [mklayer() for _ in range(self.helper.args.transformer.encoder_n_layers)]
return layers
def fix_init(self, model):
init_std = 0.02
torch.nn.init.normal_(model.embedding.weight, 0.0, init_std)
# torch.nn.init.normal_(model.embedding_adapter.weight, 0.0, init_std)
initialized = 0
for m in model.modules():
if isinstance(m, (torch.nn.Linear, torch.nn.Embedding)) and hasattr(m, "weight"):
torch.nn.init.normal_(m.weight, 0.0, init_std)
initialized += m.weight.numel()
if isinstance(m, (torch.nn.Linear, torch.nn.LayerNorm)) and m.bias is not None:
torch.nn.init.constant_(m.bias, 0)
initialized += m.bias.numel()
if isinstance(m, (torch.nn.LayerNorm)) and m.weight is not None:
torch.nn.init.normal_(m.weight, 1.0, init_std)
initialized += m.weight.numel()
if isinstance(m, MoE):
torch.nn.init.normal_(m.keys, 0.0, init_std)
torch.nn.init.normal_(m.values, 0.0, init_std)
if m.expert_sel is not None:
torch.nn.init.normal_(m.expert_sel, 0.0, init_std)
initialized += m.expert_sel.numel()
initialized += m.keys.numel() + m.values.numel()
print(f"Reinitialized {initialized/self.n_weights*100:.3f}% weights")
def create_model(self) -> torch.nn.Module:
# pyright: reportOptionalMemberAccess=false
tlayers = self.get_layers()
if self.helper.args.transformer.output_mode != "normal" and self.is_preln():
raise ValueError("accumulated_output not supported with pre-ln")
model = TransformerLanguageModel(
len(self.train_set.vocabulary), self.helper.args.embedding_size,
self.helper.args.state_size, self.helper.args.dropout,
tied_embedding=self.helper.args.tied_embedding,
layers=tlayers, n_prev_states=self.helper.args.lm.trafo.context_blocks,
n_prev_states_test=self.helper.args.lm.trafo.test_context_blocks,
same_length_eval=self.helper.args.lm.trafo.same_length_eval,
p_drop_layer=self.helper.args.transformer.p_drop_layer,
same_length=self.helper.args.lm.trafo.same_length,
use_last_state=self.helper.args.lm.trafo.last_layer_context,
norm_before_output=self.is_preln(), output_mode=self.helper.args.transformer.output_mode,)
self.n_weights = sum(p.numel() for p in model.parameters())
with torch.no_grad():
if self.is_preln():
model.embedding_scale = 1.0
elif self.helper.args.lm.trafo.xl_init:
self.fix_init(model)
elif self.helper.args.lm.trafo.embedding_mode_init=="scale_to_sqrt_dmodel":
norm = model.embedding.weight.norm(dim=-1).mean()
model.embedding_scale = math.sqrt(self.helper.args.state_size) / norm
elif self.helper.args.lm.trafo.embedding_mode_init=="one_and_scale_to_sqrt_dmodel":
norm = model.embedding.weight.norm(dim=-1).mean()
model.embedding_scale = math.sqrt(self.helper.args.state_size)
model.embedding.weight.mul_(1.0 / norm)
elif self.helper.args.lm.trafo.embedding_mode_init=="init_to_sqrt_dmodel":
norm = model.embedding.weight.norm(dim=-1, keepdim=True)
model.embedding_scale=1.0
model.embedding.weight.mul_(math.sqrt(self.helper.args.state_size) / norm)
return model
def moe_recluster(self):
for n, m in self.model.named_modules():
if isinstance(m, MoE):
perm = m.regroup_weights()
m.patch_optimizer_state(self.optimizer, perm)
| def train_step(self) -> Tuple[Result, Dict[str, Any]]: | 9 | 2023-10-16 11:26:45+00:00 | 24k |
boppreh/hello_tls | src/hello_tls/protocol.py | [
{
"identifier": "Protocol",
"path": "src/hello_tls/names_and_numbers.py",
"snippet": "class Protocol(Enum):\n # Keep protocols in order of preference.\n TLS1_3 = b\"\\x03\\x04\"\n TLS1_2 = b\"\\x03\\x03\"\n TLS1_1 = b\"\\x03\\x02\"\n TLS1_0 = b\"\\x03\\x01\"\n SSLv3 = b\"\\x03\\x00\"\n... | from typing import Iterator, List, Sequence, Optional, Iterable, Callable, Tuple
from contextlib import contextmanager
from dataclasses import dataclass
from .names_and_numbers import Protocol, RecordType, HandshakeType, CompressionMethod, CipherSuite, ExtensionType, Group, AlertLevel, AlertDescription, PskKeyExchangeMode
import logging | 14,906 |
logger = logging.getLogger(__name__)
class ScanError(Exception):
""" Base error class for errors that occur during scanning. """
pass
class ServerAlertError(ScanError):
def __init__(self, level: AlertLevel, description: AlertDescription):
super().__init__(self, f'Server error: {level}: {description}')
self.level = level
self.description = description
class BadServerResponse(ScanError):
""" Error for server responses that can't be parsed. """
pass
@dataclass
class ServerHello:
version: Protocol
compression: CompressionMethod
cipher_suite: CipherSuite
group: Optional[Group]
def _make_stream_parser(packets: Iterable[bytes]) -> Tuple[Callable[[int], bytes], Callable[[], int]]:
"""
Returns helper functions to parse a stream of packets.
"""
start = 0
packets_iter = iter(packets)
data = b''
def read_next(length: int) -> bytes:
nonlocal start, data
while start + length > len(data):
try:
data += next(packets_iter)
except StopIteration:
raise BadServerResponse('Server response ended unexpectedly')
value = data[start:start+length]
start += length
return value
return read_next, lambda: start
def _bytes_to_int(b: bytes) -> int:
return int.from_bytes(b, byteorder='big')
def parse_server_hello(packets: Iterable[bytes]) -> ServerHello:
"""
Parses a Server Hello packet and returns the cipher suite accepted by the server.
"""
read_next, current_position = _make_stream_parser(packets)
|
logger = logging.getLogger(__name__)
class ScanError(Exception):
""" Base error class for errors that occur during scanning. """
pass
class ServerAlertError(ScanError):
def __init__(self, level: AlertLevel, description: AlertDescription):
super().__init__(self, f'Server error: {level}: {description}')
self.level = level
self.description = description
class BadServerResponse(ScanError):
""" Error for server responses that can't be parsed. """
pass
@dataclass
class ServerHello:
version: Protocol
compression: CompressionMethod
cipher_suite: CipherSuite
group: Optional[Group]
def _make_stream_parser(packets: Iterable[bytes]) -> Tuple[Callable[[int], bytes], Callable[[], int]]:
"""
Returns helper functions to parse a stream of packets.
"""
start = 0
packets_iter = iter(packets)
data = b''
def read_next(length: int) -> bytes:
nonlocal start, data
while start + length > len(data):
try:
data += next(packets_iter)
except StopIteration:
raise BadServerResponse('Server response ended unexpectedly')
value = data[start:start+length]
start += length
return value
return read_next, lambda: start
def _bytes_to_int(b: bytes) -> int:
return int.from_bytes(b, byteorder='big')
def parse_server_hello(packets: Iterable[bytes]) -> ServerHello:
"""
Parses a Server Hello packet and returns the cipher suite accepted by the server.
"""
read_next, current_position = _make_stream_parser(packets)
| record_type = RecordType(read_next(1)) | 1 | 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 | 17,664 |
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')
|
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)) | 8 | 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 | 15,267 | # 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,
PeftType.ADAPTION_PROMPT: AdaptionPromptModel,
PeftType.MMOELORAS: MMOELoraModelS,
}
class PeftModel(PushToHubMixin, torch.nn.Module):
"""
Base model encompassing various Peft methods.
Args:
model ([`~transformers.PreTrainedModel`]): The base transformer model used for Peft.
peft_config ([`PeftConfig`]): The configuration of the Peft model.
**Attributes**:
- **base_model** ([`~transformers.PreTrainedModel`]) -- The base transformer model used for Peft.
- **peft_config** ([`PeftConfig`]) -- The configuration of the Peft model.
- **modules_to_save** (`list` of `str`) -- The list of sub-module names to save when
saving the model.
- **prompt_encoder** ([`PromptEncoder`]) -- The prompt encoder used for Peft if
using [`PromptLearningConfig`].
- **prompt_tokens** (`torch.Tensor`) -- The virtual prompt tokens used for Peft if
using [`PromptLearningConfig`].
- **transformer_backbone_name** (`str`) -- The name of the transformer
backbone in the base model if using [`PromptLearningConfig`].
- **word_embeddings** (`torch.nn.Embedding`) -- The word embeddings of the transformer backbone
in the base model if using [`PromptLearningConfig`].
"""
def __init__(self, model, peft_config: PeftConfig, adapter_name="default"):
super().__init__()
self.base_model = model
self.config = self.base_model.config
self.modules_to_save = None
self.peft_config = {}
self.active_adapter = adapter_name
self.peft_type = peft_config.peft_type
self.base_model_torch_dtype = getattr(model, "dtype", None)
if not isinstance(peft_config, PromptLearningConfig):
self.peft_config[adapter_name] = peft_config
self.base_model = PEFT_TYPE_TO_MODEL_MAPPING[peft_config.peft_type](
self.base_model, self.peft_config, adapter_name
)
self.set_additional_trainable_modules(peft_config, adapter_name)
else:
self.add_adapter(adapter_name, peft_config)
def save_pretrained(self, save_directory, **kwargs):
r"""
This function saves the adapter model and the adapter configuration files to a directory, so that it can be
reloaded using the [`LoraModel.from_pretrained`] class method, and also used by the [`LoraModel.push_to_hub`]
method.
Args:
save_directory (`str`):
Directory where the adapter model and configuration files will be saved (will be created if it does not
exist).
kwargs (additional keyword arguments, *optional*):
Additional keyword arguments passed along to the `push_to_hub` method.
"""
if os.path.isfile(save_directory):
raise ValueError(f"Provided path ({save_directory}) should be a directory, not a file")
os.makedirs(save_directory, exist_ok=True)
for adapter_name, peft_config in self.peft_config.items():
# save only the trainable weights
output_state_dict = get_peft_model_state_dict(
self, state_dict=kwargs.get("state_dict", None), adapter_name=adapter_name
) # save the weights based on the adapter name
output_dir = os.path.join(save_directory, adapter_name) if adapter_name != "default" else save_directory
os.makedirs(output_dir, exist_ok=True)
| # 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,
PeftType.ADAPTION_PROMPT: AdaptionPromptModel,
PeftType.MMOELORAS: MMOELoraModelS,
}
class PeftModel(PushToHubMixin, torch.nn.Module):
"""
Base model encompassing various Peft methods.
Args:
model ([`~transformers.PreTrainedModel`]): The base transformer model used for Peft.
peft_config ([`PeftConfig`]): The configuration of the Peft model.
**Attributes**:
- **base_model** ([`~transformers.PreTrainedModel`]) -- The base transformer model used for Peft.
- **peft_config** ([`PeftConfig`]) -- The configuration of the Peft model.
- **modules_to_save** (`list` of `str`) -- The list of sub-module names to save when
saving the model.
- **prompt_encoder** ([`PromptEncoder`]) -- The prompt encoder used for Peft if
using [`PromptLearningConfig`].
- **prompt_tokens** (`torch.Tensor`) -- The virtual prompt tokens used for Peft if
using [`PromptLearningConfig`].
- **transformer_backbone_name** (`str`) -- The name of the transformer
backbone in the base model if using [`PromptLearningConfig`].
- **word_embeddings** (`torch.nn.Embedding`) -- The word embeddings of the transformer backbone
in the base model if using [`PromptLearningConfig`].
"""
def __init__(self, model, peft_config: PeftConfig, adapter_name="default"):
super().__init__()
self.base_model = model
self.config = self.base_model.config
self.modules_to_save = None
self.peft_config = {}
self.active_adapter = adapter_name
self.peft_type = peft_config.peft_type
self.base_model_torch_dtype = getattr(model, "dtype", None)
if not isinstance(peft_config, PromptLearningConfig):
self.peft_config[adapter_name] = peft_config
self.base_model = PEFT_TYPE_TO_MODEL_MAPPING[peft_config.peft_type](
self.base_model, self.peft_config, adapter_name
)
self.set_additional_trainable_modules(peft_config, adapter_name)
else:
self.add_adapter(adapter_name, peft_config)
def save_pretrained(self, save_directory, **kwargs):
r"""
This function saves the adapter model and the adapter configuration files to a directory, so that it can be
reloaded using the [`LoraModel.from_pretrained`] class method, and also used by the [`LoraModel.push_to_hub`]
method.
Args:
save_directory (`str`):
Directory where the adapter model and configuration files will be saved (will be created if it does not
exist).
kwargs (additional keyword arguments, *optional*):
Additional keyword arguments passed along to the `push_to_hub` method.
"""
if os.path.isfile(save_directory):
raise ValueError(f"Provided path ({save_directory}) should be a directory, not a file")
os.makedirs(save_directory, exist_ok=True)
for adapter_name, peft_config in self.peft_config.items():
# save only the trainable weights
output_state_dict = get_peft_model_state_dict(
self, state_dict=kwargs.get("state_dict", None), adapter_name=adapter_name
) # save the weights based on the adapter name
output_dir = os.path.join(save_directory, adapter_name) if adapter_name != "default" else save_directory
os.makedirs(output_dir, exist_ok=True) | torch.save(output_state_dict, os.path.join(output_dir, WEIGHTS_NAME)) | 15 | 2023-10-19 10:55:50+00:00 | 24k |
YuroFR/freqtrade-modded-crypto-trading-bot | freqtrade/exchange/exchange.py | [
{
"identifier": "DEFAULT_AMOUNT_RESERVE_PERCENT",
"path": "freqtrade/constants.py",
"snippet": "DOCS_LINK = \"https://www.freqtrade.io/en/stable\"\nDEFAULT_CONFIG = 'config.json'\nPROCESS_THROTTLE_SECS = 5 # sec\nHYPEROPT_EPOCH = 100 # epochs\nRETRY_TIMEOUT = 30 # sec\nTIMEOUT_UNITS = ['minutes', 'se... | import asyncio
import inspect
import logging
import signal
import ccxt
import ccxt.async_support as ccxt_async
from copy import deepcopy
from datetime import datetime, timedelta, timezone
from math import floor
from threading import Lock
from typing import Any, Coroutine, Dict, List, Literal, Optional, Tuple, Union
from cachetools import TTLCache
from ccxt import TICK_SIZE
from dateutil import parser
from pandas import DataFrame, concat
from freqtrade.constants import (DEFAULT_AMOUNT_RESERVE_PERCENT, NON_OPEN_EXCHANGE_STATES, BidAsk,
BuySell, Config, EntryExit, ExchangeConfig,
ListPairsWithTimeframes, MakerTaker, OBLiteral, PairWithTimeframe)
from freqtrade.data.converter import clean_ohlcv_dataframe, ohlcv_to_dataframe, trades_dict_to_list
from freqtrade.enums import OPTIMIZE_MODES, CandleType, MarginMode, PriceType, TradingMode
from freqtrade.exceptions import (DDosProtection, ExchangeError, InsufficientFundsError,
InvalidOrderException, OperationalException, PricingError,
RetryableOrderError, TemporaryError)
from freqtrade.exchange.common import (API_FETCH_ORDER_RETRY_COUNT, remove_exchange_credentials,
retrier, retrier_async)
from freqtrade.exchange.exchange_utils import (ROUND, ROUND_DOWN, ROUND_UP, CcxtModuleType,
amount_to_contract_precision, amount_to_contracts,
amount_to_precision, contracts_to_amount,
date_minus_candles, is_exchange_known_ccxt,
market_is_active, price_to_precision,
timeframe_to_minutes, timeframe_to_msecs,
timeframe_to_next_date, timeframe_to_prev_date,
timeframe_to_seconds)
from freqtrade.exchange.types import OHLCVResponse, OrderBook, Ticker, Tickers
from freqtrade.misc import (chunks, deep_merge_dicts, file_dump_json, file_load_json,
safe_value_fallback2)
from freqtrade.plugins.pairlist.pairlist_helpers import expand_pairlist
from freqtrade.util import dt_from_ts, dt_now
from freqtrade.util.datetime_helpers import dt_humanize, dt_ts
from freqtrade.persistence import Order | 15,001 | leverage: float,
wallet_balance: float,
mm_ex_1: float = 0.0, # (Binance) Cross only
upnl_ex_1: float = 0.0, # (Binance) Cross only
) -> Optional[float]:
"""
Set's the margin mode on the exchange to cross or isolated for a specific pair
"""
if self.trading_mode == TradingMode.SPOT:
return None
elif (self.trading_mode != TradingMode.FUTURES):
raise OperationalException(
f"{self.name} does not support {self.margin_mode} {self.trading_mode}")
liquidation_price = None
if self._config['dry_run'] or not self.exchange_has("fetchPositions"):
liquidation_price = self.dry_run_liquidation_price(
pair=pair,
open_rate=open_rate,
is_short=is_short,
amount=amount,
leverage=leverage,
stake_amount=stake_amount,
wallet_balance=wallet_balance,
mm_ex_1=mm_ex_1,
upnl_ex_1=upnl_ex_1
)
else:
positions = self.fetch_positions(pair)
if len(positions) > 0:
pos = positions[0]
liquidation_price = pos['liquidationPrice']
if liquidation_price is not None:
buffer_amount = abs(open_rate - liquidation_price) * self.liquidation_buffer
liquidation_price_buffer = (
liquidation_price - buffer_amount
if is_short else
liquidation_price + buffer_amount
)
return max(liquidation_price_buffer, 0.0)
else:
return None
def dry_run_liquidation_price(
self,
pair: str,
open_rate: float, # Entry price of position
is_short: bool,
amount: float,
stake_amount: float,
leverage: float,
wallet_balance: float, # Or margin balance
mm_ex_1: float = 0.0, # (Binance) Cross only
upnl_ex_1: float = 0.0, # (Binance) Cross only
) -> Optional[float]:
"""
Important: Must be fetching data from cached values as this is used by backtesting!
PERPETUAL:
gate: https://www.gate.io/help/futures/futures/27724/liquidation-price-bankruptcy-price
> Liquidation Price = (Entry Price ± Margin / Contract Multiplier / Size) /
[ 1 ± (Maintenance Margin Ratio + Taker Rate)]
Wherein, "+" or "-" depends on whether the contract goes long or short:
"-" for long, and "+" for short.
okex: https://www.okex.com/support/hc/en-us/articles/
360053909592-VI-Introduction-to-the-isolated-mode-of-Single-Multi-currency-Portfolio-margin
:param pair: Pair to calculate liquidation price for
:param open_rate: Entry price of position
:param is_short: True if the trade is a short, false otherwise
:param amount: Absolute value of position size incl. leverage (in base currency)
:param stake_amount: Stake amount - Collateral in settle currency.
:param leverage: Leverage used for this position.
:param trading_mode: SPOT, MARGIN, FUTURES, etc.
:param margin_mode: Either ISOLATED or CROSS
:param wallet_balance: Amount of margin_mode in the wallet being used to trade
Cross-Margin Mode: crossWalletBalance
Isolated-Margin Mode: isolatedWalletBalance
# * Not required by Gate or OKX
:param mm_ex_1:
:param upnl_ex_1:
"""
market = self.markets[pair]
taker_fee_rate = market['taker']
mm_ratio, _ = self.get_maintenance_ratio_and_amt(pair, stake_amount)
if self.trading_mode == TradingMode.FUTURES and self.margin_mode == MarginMode.ISOLATED:
if market['inverse']:
raise OperationalException(
"Freqtrade does not yet support inverse contracts")
value = wallet_balance / amount
mm_ratio_taker = (mm_ratio + taker_fee_rate)
if is_short:
return (open_rate + value) / (1 + mm_ratio_taker)
else:
return (open_rate - value) / (1 - mm_ratio_taker)
else:
raise OperationalException(
"Freqtrade only supports isolated futures for leverage trading")
def get_maintenance_ratio_and_amt(
self,
pair: str,
nominal_value: float,
) -> Tuple[float, Optional[float]]:
"""
Important: Must be fetching data from cached values as this is used by backtesting!
:param pair: Market symbol
:param nominal_value: The total trade amount in quote currency including leverage
maintenance amount only on Binance
:return: (maintenance margin ratio, maintenance amount)
"""
| # pragma pylint: disable=W0603
"""
Cryptocurrency Exchanges support
"""
logger = logging.getLogger(__name__)
class Exchange:
# Parameters to add directly to buy/sell calls (like agreeing to trading agreement)
_params: Dict = {}
# Additional parameters - added to the ccxt object
_ccxt_params: Dict = {}
# Dict to specify which options each exchange implements
# This defines defaults, which can be selectively overridden by subclasses using _ft_has
# or by specifying them in the configuration.
_ft_has_default: Dict = {
"stoploss_on_exchange": False,
"stop_price_param": "stopLossPrice", # Used for stoploss_on_exchange request
"stop_price_prop": "stopLossPrice", # Used for stoploss_on_exchange response parsing
"order_time_in_force": ["GTC"],
"ohlcv_params": {},
"ohlcv_candle_limit": 500,
"ohlcv_has_history": True, # Some exchanges (Kraken) don't provide history via ohlcv
"ohlcv_partial_candle": True,
"ohlcv_require_since": False,
# Check https://github.com/ccxt/ccxt/issues/10767 for removal of ohlcv_volume_currency
"ohlcv_volume_currency": "base", # "base" or "quote"
"tickers_have_quoteVolume": True,
"tickers_have_bid_ask": True, # bid / ask empty for fetch_tickers
"tickers_have_price": True,
"trades_pagination": "time", # Possible are "time" or "id"
"trades_pagination_arg": "since",
"l2_limit_range": None,
"l2_limit_range_required": True, # Allow Empty L2 limit (kucoin)
"mark_ohlcv_price": "mark",
"mark_ohlcv_timeframe": "8h",
"ccxt_futures_name": "swap",
"needs_trading_fees": False, # use fetch_trading_fees to cache fees
"order_props_in_contracts": ['amount', 'filled', 'remaining'],
# Override createMarketBuyOrderRequiresPrice where ccxt has it wrong
"marketOrderRequiresPrice": False,
}
_ft_has: Dict = {}
_ft_has_futures: Dict = {}
_supported_trading_mode_margin_pairs: List[Tuple[TradingMode, MarginMode]] = [
# TradingMode.SPOT always supported and not required in this list
]
def __init__(self, config: Config, *, exchange_config: Optional[ExchangeConfig] = None,
validate: bool = True, load_leverage_tiers: bool = False) -> None:
"""
Initializes this module with the given config,
it does basic validation whether the specified exchange and pairs are valid.
:return: None
"""
self._api: ccxt.Exchange
self._api_async: ccxt_async.Exchange = None
self._markets: Dict = {}
self._trading_fees: Dict[str, Any] = {}
self._leverage_tiers: Dict[str, List[Dict]] = {}
# Lock event loop. This is necessary to avoid race-conditions when using force* commands
# Due to funding fee fetching.
self._loop_lock = Lock()
self.loop = self._init_async_loop()
self._config: Config = {}
self._config.update(config)
# Holds last candle refreshed time of each pair
self._pairs_last_refresh_time: Dict[PairWithTimeframe, int] = {}
# Timestamp of last markets refresh
self._last_markets_refresh: int = 0
# Cache for 10 minutes ...
self._cache_lock = Lock()
self._fetch_tickers_cache: TTLCache = TTLCache(maxsize=2, ttl=60 * 10)
# Cache values for 1800 to avoid frequent polling of the exchange for prices
# Caching only applies to RPC methods, so prices for open trades are still
# refreshed once every iteration.
self._exit_rate_cache: TTLCache = TTLCache(maxsize=100, ttl=1800)
self._entry_rate_cache: TTLCache = TTLCache(maxsize=100, ttl=1800)
# Holds candles
self._klines: Dict[PairWithTimeframe, DataFrame] = {}
# Holds all open sell orders for dry_run
self._dry_run_open_orders: Dict[str, Any] = {}
if config['dry_run']:
logger.info('Instance is running with dry_run enabled')
logger.info(f"Using CCXT {ccxt.__version__}")
exchange_conf: Dict[str, Any] = exchange_config if exchange_config else config['exchange']
remove_exchange_credentials(exchange_conf, config.get('dry_run', False))
self.log_responses = exchange_conf.get('log_responses', False)
# Leverage properties
self.trading_mode: TradingMode = config.get('trading_mode', TradingMode.SPOT)
self.margin_mode: MarginMode = (
MarginMode(config.get('margin_mode'))
if config.get('margin_mode')
else MarginMode.NONE
)
self.liquidation_buffer = config.get('liquidation_buffer', 0.05)
# Deep merge ft_has with default ft_has options
self._ft_has = deep_merge_dicts(self._ft_has, deepcopy(self._ft_has_default))
if self.trading_mode == TradingMode.FUTURES:
self._ft_has = deep_merge_dicts(self._ft_has_futures, self._ft_has)
if exchange_conf.get('_ft_has_params'):
self._ft_has = deep_merge_dicts(exchange_conf.get('_ft_has_params'),
self._ft_has)
logger.info("Overriding exchange._ft_has with config params, result: %s", self._ft_has)
# Assign this directly for easy access
self._ohlcv_partial_candle = self._ft_has['ohlcv_partial_candle']
self._trades_pagination = self._ft_has['trades_pagination']
self._trades_pagination_arg = self._ft_has['trades_pagination_arg']
# Initialize ccxt objects
ccxt_config = self._ccxt_config
ccxt_config = deep_merge_dicts(exchange_conf.get('ccxt_config', {}), ccxt_config)
ccxt_config = deep_merge_dicts(exchange_conf.get('ccxt_sync_config', {}), ccxt_config)
self._api = self._init_ccxt(exchange_conf, ccxt_kwargs=ccxt_config)
ccxt_async_config = self._ccxt_config
ccxt_async_config = deep_merge_dicts(exchange_conf.get('ccxt_config', {}),
ccxt_async_config)
ccxt_async_config = deep_merge_dicts(exchange_conf.get('ccxt_async_config', {}),
ccxt_async_config)
self._api_async = self._init_ccxt(
exchange_conf, ccxt_async, ccxt_kwargs=ccxt_async_config)
logger.info(f'Using Exchange "{self.name}"')
self.required_candle_call_count = 1
if validate:
# Initial markets load
self._load_markets()
self.validate_config(config)
self._startup_candle_count: int = config.get('startup_candle_count', 0)
self.required_candle_call_count = self.validate_required_startup_candles(
self._startup_candle_count, config.get('timeframe', ''))
# Converts the interval provided in minutes in config to seconds
self.markets_refresh_interval: int = exchange_conf.get(
"markets_refresh_interval", 60) * 60 * 1000
if self.trading_mode != TradingMode.SPOT and load_leverage_tiers:
self.fill_leverage_tiers()
self.additional_exchange_init()
def __del__(self):
"""
Destructor - clean up async stuff
"""
self.close()
def close(self):
logger.debug("Exchange object destroyed, closing async loop")
if (self._api_async and inspect.iscoroutinefunction(self._api_async.close)
and self._api_async.session):
logger.debug("Closing async ccxt session.")
self.loop.run_until_complete(self._api_async.close())
if self.loop and not self.loop.is_closed():
self.loop.close()
def _init_async_loop(self) -> asyncio.AbstractEventLoop:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
return loop
def validate_config(self, config):
# Check if timeframe is available
self.validate_timeframes(config.get('timeframe'))
# Check if all pairs are available
self.validate_stakecurrency(config['stake_currency'])
if not config['exchange'].get('skip_pair_validation'):
self.validate_pairs(config['exchange']['pair_whitelist'])
self.validate_ordertypes(config.get('order_types', {}))
self.validate_order_time_in_force(config.get('order_time_in_force', {}))
self.validate_trading_mode_and_margin_mode(self.trading_mode, self.margin_mode)
self.validate_pricing(config['exit_pricing'])
self.validate_pricing(config['entry_pricing'])
def _init_ccxt(self, exchange_config: Dict[str, Any], ccxt_module: CcxtModuleType = ccxt,
ccxt_kwargs: Dict = {}) -> ccxt.Exchange:
"""
Initialize ccxt with given config and return valid
ccxt instance.
"""
# Find matching class for the given exchange name
name = exchange_config['name']
if not is_exchange_known_ccxt(name, ccxt_module):
raise OperationalException(f'Exchange {name} is not supported by ccxt')
ex_config = {
'apiKey': exchange_config.get('key'),
'secret': exchange_config.get('secret'),
'password': exchange_config.get('password'),
'uid': exchange_config.get('uid', ''),
}
if ccxt_kwargs:
logger.info('Applying additional ccxt config: %s', ccxt_kwargs)
if self._ccxt_params:
# Inject static options after the above output to not confuse users.
ccxt_kwargs = deep_merge_dicts(self._ccxt_params, ccxt_kwargs)
if ccxt_kwargs:
ex_config.update(ccxt_kwargs)
try:
api = getattr(ccxt_module, name.lower())(ex_config)
except (KeyError, AttributeError) as e:
raise OperationalException(f'Exchange {name} is not supported') from e
except ccxt.BaseError as e:
raise OperationalException(f"Initialization of ccxt failed. Reason: {e}") from e
return api
@property
def _ccxt_config(self) -> Dict:
# Parameters to add directly to ccxt sync/async initialization.
if self.trading_mode == TradingMode.MARGIN:
return {
"options": {
"defaultType": "margin"
}
}
elif self.trading_mode == TradingMode.FUTURES:
return {
"options": {
"defaultType": self._ft_has["ccxt_futures_name"]
}
}
else:
return {}
@property
def name(self) -> str:
"""exchange Name (from ccxt)"""
return self._api.name
@property
def id(self) -> str:
"""exchange ccxt id"""
return self._api.id
@property
def timeframes(self) -> List[str]:
return list((self._api.timeframes or {}).keys())
@property
def markets(self) -> Dict[str, Any]:
"""exchange ccxt markets"""
if not self._markets:
logger.info("Markets were not loaded. Loading them now..")
self._load_markets()
return self._markets
@property
def precisionMode(self) -> int:
"""exchange ccxt precisionMode"""
return self._api.precisionMode
def additional_exchange_init(self) -> None:
"""
Additional exchange initialization logic.
.api will be available at this point.
Must be overridden in child methods if required.
"""
pass
def _log_exchange_response(self, endpoint, response) -> None:
""" Log exchange responses """
if self.log_responses:
logger.info(f"API {endpoint}: {response}")
def ohlcv_candle_limit(
self, timeframe: str, candle_type: CandleType, since_ms: Optional[int] = None) -> int:
"""
Exchange ohlcv candle limit
Uses ohlcv_candle_limit_per_timeframe if the exchange has different limits
per timeframe (e.g. bittrex), otherwise falls back to ohlcv_candle_limit
:param timeframe: Timeframe to check
:param candle_type: Candle-type
:param since_ms: Starting timestamp
:return: Candle limit as integer
"""
return int(self._ft_has.get('ohlcv_candle_limit_per_timeframe', {}).get(
timeframe, self._ft_has.get('ohlcv_candle_limit')))
def get_markets(self, base_currencies: List[str] = [], quote_currencies: List[str] = [],
spot_only: bool = False, margin_only: bool = False, futures_only: bool = False,
tradable_only: bool = True,
active_only: bool = False) -> Dict[str, Any]:
"""
Return exchange ccxt markets, filtered out by base currency and quote currency
if this was requested in parameters.
"""
markets = self.markets
if not markets:
raise OperationalException("Markets were not loaded.")
if base_currencies:
markets = {k: v for k, v in markets.items() if v['base'] in base_currencies}
if quote_currencies:
markets = {k: v for k, v in markets.items() if v['quote'] in quote_currencies}
if tradable_only:
markets = {k: v for k, v in markets.items() if self.market_is_tradable(v)}
if spot_only:
markets = {k: v for k, v in markets.items() if self.market_is_spot(v)}
if margin_only:
markets = {k: v for k, v in markets.items() if self.market_is_margin(v)}
if futures_only:
markets = {k: v for k, v in markets.items() if self.market_is_future(v)}
if active_only:
markets = {k: v for k, v in markets.items() if market_is_active(v)}
return markets
def get_quote_currencies(self) -> List[str]:
"""
Return a list of supported quote currencies
"""
markets = self.markets
return sorted(set([x['quote'] for _, x in markets.items()]))
def get_pair_quote_currency(self, pair: str) -> str:
""" Return a pair's quote currency (base/quote:settlement) """
return self.markets.get(pair, {}).get('quote', '')
def get_pair_base_currency(self, pair: str) -> str:
""" Return a pair's base currency (base/quote:settlement) """
return self.markets.get(pair, {}).get('base', '')
def market_is_future(self, market: Dict[str, Any]) -> bool:
return (
market.get(self._ft_has["ccxt_futures_name"], False) is True and
market.get('linear', False) is True
)
def market_is_spot(self, market: Dict[str, Any]) -> bool:
return market.get('spot', False) is True
def market_is_margin(self, market: Dict[str, Any]) -> bool:
return market.get('margin', False) is True
def market_is_tradable(self, market: Dict[str, Any]) -> bool:
"""
Check if the market symbol is tradable by Freqtrade.
Ensures that Configured mode aligns to
"""
return (
market.get('quote', None) is not None
and market.get('base', None) is not None
and (self.precisionMode != TICK_SIZE
# Too low precision will falsify calculations
or market.get('precision', {}).get('price') > 1e-11)
and ((self.trading_mode == TradingMode.SPOT and self.market_is_spot(market))
or (self.trading_mode == TradingMode.MARGIN and self.market_is_margin(market))
or (self.trading_mode == TradingMode.FUTURES and self.market_is_future(market)))
)
def klines(self, pair_interval: PairWithTimeframe, copy: bool = True) -> DataFrame:
if pair_interval in self._klines:
return self._klines[pair_interval].copy() if copy else self._klines[pair_interval]
else:
return DataFrame()
def get_contract_size(self, pair: str) -> Optional[float]:
if self.trading_mode == TradingMode.FUTURES:
market = self.markets.get(pair, {})
contract_size: float = 1.0
if not market:
return None
if market.get('contractSize') is not None:
# ccxt has contractSize in markets as string
contract_size = float(market['contractSize'])
return contract_size
else:
return 1
def _trades_contracts_to_amount(self, trades: List) -> List:
if len(trades) > 0 and 'symbol' in trades[0]:
contract_size = self.get_contract_size(trades[0]['symbol'])
if contract_size != 1:
for trade in trades:
trade['amount'] = trade['amount'] * contract_size
return trades
def _order_contracts_to_amount(self, order: Dict) -> Dict:
if 'symbol' in order and order['symbol'] is not None:
contract_size = self.get_contract_size(order['symbol'])
if contract_size != 1:
for prop in self._ft_has.get('order_props_in_contracts', []):
if prop in order and order[prop] is not None:
order[prop] = order[prop] * contract_size
return order
def _amount_to_contracts(self, pair: str, amount: float) -> float:
contract_size = self.get_contract_size(pair)
return amount_to_contracts(amount, contract_size)
def _contracts_to_amount(self, pair: str, num_contracts: float) -> float:
contract_size = self.get_contract_size(pair)
return contracts_to_amount(num_contracts, contract_size)
def amount_to_contract_precision(self, pair: str, amount: float) -> float:
"""
Helper wrapper around amount_to_contract_precision
"""
contract_size = self.get_contract_size(pair)
return amount_to_contract_precision(amount, self.get_precision_amount(pair),
self.precisionMode, contract_size)
def _load_async_markets(self, reload: bool = False) -> None:
try:
if self._api_async:
self.loop.run_until_complete(
self._api_async.load_markets(reload=reload, params={}))
except (asyncio.TimeoutError, ccxt.BaseError) as e:
logger.warning('Could not load async markets. Reason: %s', e)
return
def _load_markets(self) -> None:
""" Initialize markets both sync and async """
try:
self._markets = self._api.load_markets(params={})
self._load_async_markets()
self._last_markets_refresh = dt_ts()
if self._ft_has['needs_trading_fees']:
self._trading_fees = self.fetch_trading_fees()
except ccxt.BaseError:
logger.exception('Unable to initialize markets.')
def reload_markets(self) -> None:
"""Reload markets both sync and async if refresh interval has passed """
# Check whether markets have to be reloaded
if (self._last_markets_refresh > 0) and (
self._last_markets_refresh + self.markets_refresh_interval > dt_ts()):
return None
logger.debug("Performing scheduled market reload..")
try:
self._markets = self._api.load_markets(reload=True, params={})
# Also reload async markets to avoid issues with newly listed pairs
self._load_async_markets(reload=True)
self._last_markets_refresh = dt_ts()
self.fill_leverage_tiers()
except ccxt.BaseError:
logger.exception("Could not reload markets.")
def validate_stakecurrency(self, stake_currency: str) -> None:
"""
Checks stake-currency against available currencies on the exchange.
Only runs on startup. If markets have not been loaded, there's been a problem with
the connection to the exchange.
:param stake_currency: Stake-currency to validate
:raise: OperationalException if stake-currency is not available.
"""
if not self._markets:
raise OperationalException(
'Could not load markets, therefore cannot start. '
'Please investigate the above error for more details.'
)
quote_currencies = self.get_quote_currencies()
if stake_currency not in quote_currencies:
raise OperationalException(
f"{stake_currency} is not available as stake on {self.name}. "
f"Available currencies are: {', '.join(quote_currencies)}")
def validate_pairs(self, pairs: List[str]) -> None:
"""
Checks if all given pairs are tradable on the current exchange.
:param pairs: list of pairs
:raise: OperationalException if one pair is not available
:return: None
"""
if not self.markets:
logger.warning('Unable to validate pairs (assuming they are correct).')
return
extended_pairs = expand_pairlist(pairs, list(self.markets), keep_invalid=True)
invalid_pairs = []
for pair in extended_pairs:
# Note: ccxt has BaseCurrency/QuoteCurrency format for pairs
if self.markets and pair not in self.markets:
raise OperationalException(
f'Pair {pair} is not available on {self.name} {self.trading_mode.value}. '
f'Please remove {pair} from your whitelist.')
# From ccxt Documentation:
# markets.info: An associative array of non-common market properties,
# including fees, rates, limits and other general market information.
# The internal info array is different for each particular market,
# its contents depend on the exchange.
# It can also be a string or similar ... so we need to verify that first.
elif (isinstance(self.markets[pair].get('info'), dict)
and self.markets[pair].get('info', {}).get('prohibitedIn', False)):
# Warn users about restricted pairs in whitelist.
# We cannot determine reliably if Users are affected.
logger.warning(f"Pair {pair} is restricted for some users on this exchange."
f"Please check if you are impacted by this restriction "
f"on the exchange and eventually remove {pair} from your whitelist.")
if (self._config['stake_currency'] and
self.get_pair_quote_currency(pair) != self._config['stake_currency']):
invalid_pairs.append(pair)
if invalid_pairs:
raise OperationalException(
f"Stake-currency '{self._config['stake_currency']}' not compatible with "
f"pair-whitelist. Please remove the following pairs: {invalid_pairs}")
def get_valid_pair_combination(self, curr_1: str, curr_2: str) -> str:
"""
Get valid pair combination of curr_1 and curr_2 by trying both combinations.
"""
for pair in [f"{curr_1}/{curr_2}", f"{curr_2}/{curr_1}"]:
if pair in self.markets and self.markets[pair].get('active'):
return pair
raise ValueError(f"Could not combine {curr_1} and {curr_2} to get a valid pair.")
def validate_timeframes(self, timeframe: Optional[str]) -> None:
"""
Check if timeframe from config is a supported timeframe on the exchange
"""
if not hasattr(self._api, "timeframes") or self._api.timeframes is None:
# If timeframes attribute is missing (or is None), the exchange probably
# has no fetchOHLCV method.
# Therefore we also show that.
raise OperationalException(
f"The ccxt library does not provide the list of timeframes "
f"for the exchange {self.name} and this exchange "
f"is therefore not supported. ccxt fetchOHLCV: {self.exchange_has('fetchOHLCV')}")
if timeframe and (timeframe not in self.timeframes):
raise OperationalException(
f"Invalid timeframe '{timeframe}'. This exchange supports: {self.timeframes}")
if timeframe and timeframe_to_minutes(timeframe) < 1:
raise OperationalException("Timeframes < 1m are currently not supported by Freqtrade.")
def validate_ordertypes(self, order_types: Dict) -> None:
"""
Checks if order-types configured in strategy/config are supported
"""
if any(v == 'market' for k, v in order_types.items()):
if not self.exchange_has('createMarketOrder'):
raise OperationalException(
f'Exchange {self.name} does not support market orders.')
self.validate_stop_ordertypes(order_types)
def validate_stop_ordertypes(self, order_types: Dict) -> None:
"""
Validate stoploss order types
"""
if (order_types.get("stoploss_on_exchange")
and not self._ft_has.get("stoploss_on_exchange", False)):
raise OperationalException(
f'On exchange stoploss is not supported for {self.name}.'
)
if self.trading_mode == TradingMode.FUTURES:
price_mapping = self._ft_has.get('stop_price_type_value_mapping', {}).keys()
if (
order_types.get("stoploss_on_exchange", False) is True
and 'stoploss_price_type' in order_types
and order_types['stoploss_price_type'] not in price_mapping
):
raise OperationalException(
f'On exchange stoploss price type is not supported for {self.name}.'
)
def validate_pricing(self, pricing: Dict) -> None:
if pricing.get('use_order_book', False) and not self.exchange_has('fetchL2OrderBook'):
raise OperationalException(f'Orderbook not available for {self.name}.')
if (not pricing.get('use_order_book', False) and (
not self.exchange_has('fetchTicker')
or not self._ft_has['tickers_have_price'])):
raise OperationalException(f'Ticker pricing not available for {self.name}.')
def validate_order_time_in_force(self, order_time_in_force: Dict) -> None:
"""
Checks if order time in force configured in strategy/config are supported
"""
if any(v.upper() not in self._ft_has["order_time_in_force"]
for k, v in order_time_in_force.items()):
raise OperationalException(
f'Time in force policies are not supported for {self.name} yet.')
def validate_required_startup_candles(self, startup_candles: int, timeframe: str) -> int:
"""
Checks if required startup_candles is more than ohlcv_candle_limit().
Requires a grace-period of 5 candles - so a startup-period up to 494 is allowed by default.
"""
candle_limit = self.ohlcv_candle_limit(
timeframe, self._config['candle_type_def'],
int(date_minus_candles(timeframe, startup_candles).timestamp() * 1000)
if timeframe else None)
# Require one more candle - to account for the still open candle.
candle_count = startup_candles + 1
# Allow 5 calls to the exchange per pair
required_candle_call_count = int(
(candle_count / candle_limit) + (0 if candle_count % candle_limit == 0 else 1))
if self._ft_has['ohlcv_has_history']:
if required_candle_call_count > 5:
# Only allow 5 calls per pair to somewhat limit the impact
raise OperationalException(
f"This strategy requires {startup_candles} candles to start, "
"which is more than 5x "
f"the amount of candles {self.name} provides for {timeframe}.")
elif required_candle_call_count > 1:
raise OperationalException(
f"This strategy requires {startup_candles} candles to start, which is more than "
f"the amount of candles {self.name} provides for {timeframe}.")
if required_candle_call_count > 1:
logger.warning(f"Using {required_candle_call_count} calls to get OHLCV. "
f"This can result in slower operations for the bot. Please check "
f"if you really need {startup_candles} candles for your strategy")
return required_candle_call_count
def validate_trading_mode_and_margin_mode(
self,
trading_mode: TradingMode,
margin_mode: Optional[MarginMode] # Only None when trading_mode = TradingMode.SPOT
):
"""
Checks if freqtrade can perform trades using the configured
trading mode(Margin, Futures) and MarginMode(Cross, Isolated)
Throws OperationalException:
If the trading_mode/margin_mode type are not supported by freqtrade on this exchange
"""
if trading_mode != TradingMode.SPOT and (
(trading_mode, margin_mode) not in self._supported_trading_mode_margin_pairs
):
mm_value = margin_mode and margin_mode.value
raise OperationalException(
f"Freqtrade does not support {mm_value} {trading_mode.value} on {self.name}"
)
def get_option(self, param: str, default: Optional[Any] = None) -> Any:
"""
Get parameter value from _ft_has
"""
return self._ft_has.get(param, default)
def exchange_has(self, endpoint: str) -> bool:
"""
Checks if exchange implements a specific API endpoint.
Wrapper around ccxt 'has' attribute
:param endpoint: Name of endpoint (e.g. 'fetchOHLCV', 'fetchTickers')
:return: bool
"""
return endpoint in self._api.has and self._api.has[endpoint]
def get_precision_amount(self, pair: str) -> Optional[float]:
"""
Returns the amount precision of the exchange.
:param pair: Pair to get precision for
:return: precision for amount or None. Must be used in combination with precisionMode
"""
return self.markets.get(pair, {}).get('precision', {}).get('amount', None)
def get_precision_price(self, pair: str) -> Optional[float]:
"""
Returns the price precision of the exchange.
:param pair: Pair to get precision for
:return: precision for price or None. Must be used in combination with precisionMode
"""
return self.markets.get(pair, {}).get('precision', {}).get('price', None)
def amount_to_precision(self, pair: str, amount: float) -> float:
"""
Returns the amount to buy or sell to a precision the Exchange accepts
"""
return amount_to_precision(amount, self.get_precision_amount(pair), self.precisionMode)
def price_to_precision(self, pair: str, price: float, *, rounding_mode: int = ROUND) -> float:
"""
Returns the price rounded to the precision the Exchange accepts.
The default price_rounding_mode in conf is ROUND.
For stoploss calculations, must use ROUND_UP for longs, and ROUND_DOWN for shorts.
"""
return price_to_precision(price, self.get_precision_price(pair),
self.precisionMode, rounding_mode=rounding_mode)
def price_get_one_pip(self, pair: str, price: float) -> float:
"""
Get's the "1 pip" value for this pair.
Used in PriceFilter to calculate the 1pip movements.
"""
precision = self.markets[pair]['precision']['price']
if self.precisionMode == TICK_SIZE:
return precision
else:
return 1 / pow(10, precision)
def get_min_pair_stake_amount(
self,
pair: str,
price: float,
stoploss: float,
leverage: Optional[float] = 1.0
) -> Optional[float]:
return self._get_stake_amount_limit(pair, price, stoploss, 'min', leverage)
def get_max_pair_stake_amount(self, pair: str, price: float, leverage: float = 1.0) -> float:
max_stake_amount = self._get_stake_amount_limit(pair, price, 0.0, 'max', leverage)
if max_stake_amount is None:
# * Should never be executed
raise OperationalException(f'{self.name}.get_max_pair_stake_amount should'
'never set max_stake_amount to None')
return max_stake_amount
def _get_stake_amount_limit(
self,
pair: str,
price: float,
stoploss: float,
limit: Literal['min', 'max'],
leverage: Optional[float] = 1.0
) -> Optional[float]:
isMin = limit == 'min'
try:
market = self.markets[pair]
except KeyError:
raise ValueError(f"Can't get market information for symbol {pair}")
if isMin:
# reserve some percent defined in config (5% default) + stoploss
margin_reserve: float = 1.0 + self._config.get('amount_reserve_percent',
DEFAULT_AMOUNT_RESERVE_PERCENT)
stoploss_reserve = (
margin_reserve / (1 - abs(stoploss)) if abs(stoploss) != 1 else 1.5
)
# it should not be more than 50%
stoploss_reserve = max(min(stoploss_reserve, 1.5), 1)
else:
margin_reserve = 1.0
stoploss_reserve = 1.0
stake_limits = []
limits = market['limits']
if (limits['cost'][limit] is not None):
stake_limits.append(
self._contracts_to_amount(pair, limits['cost'][limit]) * stoploss_reserve
)
if (limits['amount'][limit] is not None):
stake_limits.append(
self._contracts_to_amount(pair, limits['amount'][limit]) * price * margin_reserve
)
if not stake_limits:
return None if isMin else float('inf')
# The value returned should satisfy both limits: for amount (base currency) and
# for cost (quote, stake currency), so max() is used here.
# See also #2575 at github.
return self._get_stake_amount_considering_leverage(
max(stake_limits) if isMin else min(stake_limits),
leverage or 1.0
)
def _get_stake_amount_considering_leverage(self, stake_amount: float, leverage: float) -> float:
"""
Takes the minimum stake amount for a pair with no leverage and returns the minimum
stake amount when leverage is considered
:param stake_amount: The stake amount for a pair before leverage is considered
:param leverage: The amount of leverage being used on the current trade
"""
return stake_amount / leverage
# Dry-run methods
def create_dry_run_order(self, pair: str, ordertype: str, side: str, amount: float,
rate: float, leverage: float, params: Dict = {},
stop_loss: bool = False) -> Dict[str, Any]:
now = dt_now()
order_id = f'dry_run_{side}_{pair}_{now.timestamp()}'
# Rounding here must respect to contract sizes
_amount = self._contracts_to_amount(
pair, self.amount_to_precision(pair, self._amount_to_contracts(pair, amount)))
dry_order: Dict[str, Any] = {
'id': order_id,
'symbol': pair,
'price': rate,
'average': rate,
'amount': _amount,
'cost': _amount * rate,
'type': ordertype,
'side': side,
'filled': 0,
'remaining': _amount,
'datetime': now.strftime('%Y-%m-%dT%H:%M:%S.%fZ'),
'timestamp': dt_ts(now),
'status': "open",
'fee': None,
'info': {},
'leverage': leverage
}
if stop_loss:
dry_order["info"] = {"stopPrice": dry_order["price"]}
dry_order[self._ft_has['stop_price_prop']] = dry_order["price"]
# Workaround to avoid filling stoploss orders immediately
dry_order["ft_order_type"] = "stoploss"
orderbook: Optional[OrderBook] = None
if self.exchange_has('fetchL2OrderBook'):
orderbook = self.fetch_l2_order_book(pair, 20)
if ordertype == "limit" and orderbook:
# Allow a 1% price difference
allowed_diff = 0.01
if self._dry_is_price_crossed(pair, side, rate, orderbook, allowed_diff):
logger.info(
f"Converted order {pair} to market order due to price {rate} crossing spread "
f"by more than {allowed_diff:.2%}.")
dry_order["type"] = "market"
if dry_order["type"] == "market" and not dry_order.get("ft_order_type"):
# Update market order pricing
average = self.get_dry_market_fill_price(pair, side, amount, rate, orderbook)
dry_order.update({
'average': average,
'filled': _amount,
'remaining': 0.0,
'status': "closed",
'cost': (dry_order['amount'] * average)
})
# market orders will always incurr taker fees
dry_order = self.add_dry_order_fee(pair, dry_order, 'taker')
dry_order = self.check_dry_limit_order_filled(
dry_order, immediate=True, orderbook=orderbook)
self._dry_run_open_orders[dry_order["id"]] = dry_order
# Copy order and close it - so the returned order is open unless it's a market order
return dry_order
def add_dry_order_fee(
self,
pair: str,
dry_order: Dict[str, Any],
taker_or_maker: MakerTaker,
) -> Dict[str, Any]:
fee = self.get_fee(pair, taker_or_maker=taker_or_maker)
dry_order.update({
'fee': {
'currency': self.get_pair_quote_currency(pair),
'cost': dry_order['cost'] * fee,
'rate': fee
}
})
return dry_order
def get_dry_market_fill_price(self, pair: str, side: str, amount: float, rate: float,
orderbook: Optional[OrderBook]) -> float:
"""
Get the market order fill price based on orderbook interpolation
"""
if self.exchange_has('fetchL2OrderBook'):
if not orderbook:
orderbook = self.fetch_l2_order_book(pair, 20)
ob_type: OBLiteral = 'asks' if side == 'buy' else 'bids'
slippage = 0.05
max_slippage_val = rate * ((1 + slippage) if side == 'buy' else (1 - slippage))
remaining_amount = amount
filled_value = 0.0
book_entry_price = 0.0
for book_entry in orderbook[ob_type]:
book_entry_price = book_entry[0]
book_entry_coin_volume = book_entry[1]
if remaining_amount > 0:
if remaining_amount < book_entry_coin_volume:
# Orderbook at this slot bigger than remaining amount
filled_value += remaining_amount * book_entry_price
break
else:
filled_value += book_entry_coin_volume * book_entry_price
remaining_amount -= book_entry_coin_volume
else:
break
else:
# If remaining_amount wasn't consumed completely (break was not called)
filled_value += remaining_amount * book_entry_price
forecast_avg_filled_price = max(filled_value, 0) / amount
# Limit max. slippage to specified value
if side == 'buy':
forecast_avg_filled_price = min(forecast_avg_filled_price, max_slippage_val)
else:
forecast_avg_filled_price = max(forecast_avg_filled_price, max_slippage_val)
return self.price_to_precision(pair, forecast_avg_filled_price)
return rate
def _dry_is_price_crossed(self, pair: str, side: str, limit: float,
orderbook: Optional[OrderBook] = None, offset: float = 0.0) -> bool:
if not self.exchange_has('fetchL2OrderBook'):
return True
if not orderbook:
orderbook = self.fetch_l2_order_book(pair, 1)
try:
if side == 'buy':
price = orderbook['asks'][0][0]
if limit * (1 - offset) >= price:
return True
else:
price = orderbook['bids'][0][0]
if limit * (1 + offset) <= price:
return True
except IndexError:
# Ignore empty orderbooks when filling - can be filled with the next iteration.
pass
return False
def check_dry_limit_order_filled(
self, order: Dict[str, Any], immediate: bool = False,
orderbook: Optional[OrderBook] = None) -> Dict[str, Any]:
"""
Check dry-run limit order fill and update fee (if it filled).
"""
if (order['status'] != "closed"
and order['type'] in ["limit"]
and not order.get('ft_order_type')):
pair = order['symbol']
if self._dry_is_price_crossed(pair, order['side'], order['price'], orderbook):
order.update({
'status': 'closed',
'filled': order['amount'],
'remaining': 0,
})
self.add_dry_order_fee(
pair,
order,
'taker' if immediate else 'maker',
)
return order
def fetch_dry_run_order(self, order_id) -> Dict[str, Any]:
"""
Return dry-run order
Only call if running in dry-run mode.
"""
try:
order = self._dry_run_open_orders[order_id]
order = self.check_dry_limit_order_filled(order)
return order
except KeyError as e:
order = Order.order_by_id(order_id)
if order:
ccxt_order = order.to_ccxt_object(self._ft_has['stop_price_prop'])
self._dry_run_open_orders[order_id] = ccxt_order
return ccxt_order
# Gracefully handle errors with dry-run orders.
raise InvalidOrderException(
f'Tried to get an invalid dry-run-order (id: {order_id}). Message: {e}') from e
# Order handling
def _lev_prep(self, pair: str, leverage: float, side: BuySell, accept_fail: bool = False):
if self.trading_mode != TradingMode.SPOT:
self.set_margin_mode(pair, self.margin_mode, accept_fail)
self._set_leverage(leverage, pair, accept_fail)
def _get_params(
self,
side: BuySell,
ordertype: str,
leverage: float,
reduceOnly: bool,
time_in_force: str = 'GTC',
) -> Dict:
params = self._params.copy()
if time_in_force != 'GTC' and ordertype != 'market':
params.update({'timeInForce': time_in_force.upper()})
if reduceOnly:
params.update({'reduceOnly': True})
return params
def _order_needs_price(self, ordertype: str) -> bool:
return (
ordertype != 'market'
or self._api.options.get("createMarketBuyOrderRequiresPrice", False)
or self._ft_has.get('marketOrderRequiresPrice', False)
)
def create_order(
self,
*,
pair: str,
ordertype: str,
side: BuySell,
amount: float,
rate: float,
leverage: float,
reduceOnly: bool = False,
time_in_force: str = 'GTC',
) -> Dict:
if self._config['dry_run']:
dry_order = self.create_dry_run_order(
pair, ordertype, side, amount, self.price_to_precision(pair, rate), leverage)
return dry_order
params = self._get_params(side, ordertype, leverage, reduceOnly, time_in_force)
try:
# Set the precision for amount and price(rate) as accepted by the exchange
amount = self.amount_to_precision(pair, self._amount_to_contracts(pair, amount))
needs_price = self._order_needs_price(ordertype)
rate_for_order = self.price_to_precision(pair, rate) if needs_price else None
if not reduceOnly:
self._lev_prep(pair, leverage, side)
order = self._api.create_order(
pair,
ordertype,
side,
amount,
rate_for_order,
params,
)
if order.get('status') is None:
# Map empty status to open.
order['status'] = 'open'
if order.get('type') is None:
order['type'] = ordertype
self._log_exchange_response('create_order', order)
order = self._order_contracts_to_amount(order)
return order
except ccxt.InsufficientFunds as e:
raise InsufficientFundsError(
f'Insufficient funds to create {ordertype} {side} order on market {pair}. '
f'Tried to {side} amount {amount} at rate {rate}.'
f'Message: {e}') from e
except ccxt.InvalidOrder as e:
raise InvalidOrderException(
f'Could not create {ordertype} {side} order on market {pair}. '
f'Tried to {side} amount {amount} at rate {rate}. '
f'Message: {e}') from e
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not place {side} order due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
"""
Verify stop_loss against stoploss-order value (limit or price)
Returns True if adjustment is necessary.
"""
if not self._ft_has.get('stoploss_on_exchange'):
raise OperationalException(f"stoploss is not implemented for {self.name}.")
price_param = self._ft_has['stop_price_prop']
return (
order.get(price_param, None) is None
or ((side == "sell" and stop_loss > float(order[price_param])) or
(side == "buy" and stop_loss < float(order[price_param])))
)
def _get_stop_order_type(self, user_order_type) -> Tuple[str, str]:
available_order_Types: Dict[str, str] = self._ft_has["stoploss_order_types"]
if user_order_type in available_order_Types.keys():
ordertype = available_order_Types[user_order_type]
else:
# Otherwise pick only one available
ordertype = list(available_order_Types.values())[0]
user_order_type = list(available_order_Types.keys())[0]
return ordertype, user_order_type
def _get_stop_limit_rate(self, stop_price: float, order_types: Dict, side: str) -> float:
# Limit price threshold: As limit price should always be below stop-price
limit_price_pct = order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
if side == "sell":
limit_rate = stop_price * limit_price_pct
else:
limit_rate = stop_price * (2 - limit_price_pct)
bad_stop_price = ((stop_price < limit_rate) if side ==
"sell" else (stop_price > limit_rate))
# Ensure rate is less than stop price
if bad_stop_price:
# This can for example happen if the stop / liquidation price is set to 0
# Which is possible if a market-order closes right away.
# The InvalidOrderException will bubble up to exit_positions, where it will be
# handled gracefully.
raise InvalidOrderException(
"In stoploss limit order, stop price should be more than limit price. "
f"Stop price: {stop_price}, Limit price: {limit_rate}, "
f"Limit Price pct: {limit_price_pct}"
)
return limit_rate
def _get_stop_params(self, side: BuySell, ordertype: str, stop_price: float) -> Dict:
params = self._params.copy()
# Verify if stopPrice works for your exchange, else configure stop_price_param
params.update({self._ft_has['stop_price_param']: stop_price})
return params
@retrier(retries=0)
def create_stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict,
side: BuySell, leverage: float) -> Dict:
"""
creates a stoploss order.
requires `_ft_has['stoploss_order_types']` to be set as a dict mapping limit and market
to the corresponding exchange type.
The precise ordertype is determined by the order_types dict or exchange default.
The exception below should never raise, since we disallow
starting the bot in validate_ordertypes()
This may work with a limited number of other exchanges, but correct working
needs to be tested individually.
WARNING: setting `stoploss_on_exchange` to True will NOT auto-enable stoploss on exchange.
`stoploss_adjust` must still be implemented for this to work.
"""
if not self._ft_has['stoploss_on_exchange']:
raise OperationalException(f"stoploss is not implemented for {self.name}.")
user_order_type = order_types.get('stoploss', 'market')
ordertype, user_order_type = self._get_stop_order_type(user_order_type)
round_mode = ROUND_DOWN if side == 'buy' else ROUND_UP
stop_price_norm = self.price_to_precision(pair, stop_price, rounding_mode=round_mode)
limit_rate = None
if user_order_type == 'limit':
limit_rate = self._get_stop_limit_rate(stop_price, order_types, side)
limit_rate = self.price_to_precision(pair, limit_rate, rounding_mode=round_mode)
if self._config['dry_run']:
dry_order = self.create_dry_run_order(
pair,
ordertype,
side,
amount,
stop_price_norm,
stop_loss=True,
leverage=leverage,
)
return dry_order
try:
params = self._get_stop_params(side=side, ordertype=ordertype,
stop_price=stop_price_norm)
if self.trading_mode == TradingMode.FUTURES:
params['reduceOnly'] = True
if 'stoploss_price_type' in order_types and 'stop_price_type_field' in self._ft_has:
price_type = self._ft_has['stop_price_type_value_mapping'][
order_types.get('stoploss_price_type', PriceType.LAST)]
params[self._ft_has['stop_price_type_field']] = price_type
amount = self.amount_to_precision(pair, self._amount_to_contracts(pair, amount))
self._lev_prep(pair, leverage, side, accept_fail=True)
order = self._api.create_order(symbol=pair, type=ordertype, side=side,
amount=amount, price=limit_rate, params=params)
self._log_exchange_response('create_stoploss_order', order)
order = self._order_contracts_to_amount(order)
logger.info(f"stoploss {user_order_type} order added for {pair}. "
f"stop price: {stop_price}. limit: {limit_rate}")
return order
except ccxt.InsufficientFunds as e:
raise InsufficientFundsError(
f'Insufficient funds to create {ordertype} sell order on market {pair}. '
f'Tried to sell amount {amount} at rate {limit_rate}. '
f'Message: {e}') from e
except ccxt.InvalidOrder as e:
# Errors:
# `Order would trigger immediately.`
raise InvalidOrderException(
f'Could not create {ordertype} sell order on market {pair}. '
f'Tried to sell amount {amount} at rate {limit_rate}. '
f'Message: {e}') from e
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f"Could not place stoploss order due to {e.__class__.__name__}. "
f"Message: {e}") from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
@retrier(retries=API_FETCH_ORDER_RETRY_COUNT)
def fetch_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
if self._config['dry_run']:
return self.fetch_dry_run_order(order_id)
try:
order = self._api.fetch_order(order_id, pair, params=params)
self._log_exchange_response('fetch_order', order)
order = self._order_contracts_to_amount(order)
return order
except ccxt.OrderNotFound as e:
raise RetryableOrderError(
f'Order not found (pair: {pair} id: {order_id}). Message: {e}') from e
except ccxt.InvalidOrder as e:
raise InvalidOrderException(
f'Tried to get an invalid order (pair: {pair} id: {order_id}). Message: {e}') from e
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get order due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
def fetch_stoploss_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
return self.fetch_order(order_id, pair, params)
def fetch_order_or_stoploss_order(self, order_id: str, pair: str,
stoploss_order: bool = False) -> Dict:
"""
Simple wrapper calling either fetch_order or fetch_stoploss_order depending on
the stoploss_order parameter
:param order_id: OrderId to fetch order
:param pair: Pair corresponding to order_id
:param stoploss_order: If true, uses fetch_stoploss_order, otherwise fetch_order.
"""
if stoploss_order:
return self.fetch_stoploss_order(order_id, pair)
return self.fetch_order(order_id, pair)
def check_order_canceled_empty(self, order: Dict) -> bool:
"""
Verify if an order has been cancelled without being partially filled
:param order: Order dict as returned from fetch_order()
:return: True if order has been cancelled without being filled, False otherwise.
"""
return (order.get('status') in NON_OPEN_EXCHANGE_STATES
and order.get('filled') == 0.0)
@retrier
def cancel_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
if self._config['dry_run']:
try:
order = self.fetch_dry_run_order(order_id)
order.update({'status': 'canceled', 'filled': 0.0, 'remaining': order['amount']})
return order
except InvalidOrderException:
return {}
try:
order = self._api.cancel_order(order_id, pair, params=params)
self._log_exchange_response('cancel_order', order)
order = self._order_contracts_to_amount(order)
return order
except ccxt.InvalidOrder as e:
raise InvalidOrderException(
f'Could not cancel order. Message: {e}') from e
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not cancel order due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
def cancel_stoploss_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
return self.cancel_order(order_id, pair, params)
def is_cancel_order_result_suitable(self, corder) -> bool:
if not isinstance(corder, dict):
return False
required = ('fee', 'status', 'amount')
return all(corder.get(k, None) is not None for k in required)
def cancel_order_with_result(self, order_id: str, pair: str, amount: float) -> Dict:
"""
Cancel order returning a result.
Creates a fake result if cancel order returns a non-usable result
and fetch_order does not work (certain exchanges don't return cancelled orders)
:param order_id: Orderid to cancel
:param pair: Pair corresponding to order_id
:param amount: Amount to use for fake response
:return: Result from either cancel_order if usable, or fetch_order
"""
try:
corder = self.cancel_order(order_id, pair)
if self.is_cancel_order_result_suitable(corder):
return corder
except InvalidOrderException:
logger.warning(f"Could not cancel order {order_id} for {pair}.")
try:
order = self.fetch_order(order_id, pair)
except InvalidOrderException:
logger.warning(f"Could not fetch cancelled order {order_id}.")
order = {
'id': order_id,
'status': 'canceled',
'amount': amount,
'filled': 0.0,
'fee': {},
'info': {}
}
return order
def cancel_stoploss_order_with_result(self, order_id: str, pair: str, amount: float) -> Dict:
"""
Cancel stoploss order returning a result.
Creates a fake result if cancel order returns a non-usable result
and fetch_order does not work (certain exchanges don't return cancelled orders)
:param order_id: stoploss-order-id to cancel
:param pair: Pair corresponding to order_id
:param amount: Amount to use for fake response
:return: Result from either cancel_order if usable, or fetch_order
"""
corder = self.cancel_stoploss_order(order_id, pair)
if self.is_cancel_order_result_suitable(corder):
return corder
try:
order = self.fetch_stoploss_order(order_id, pair)
except InvalidOrderException:
logger.warning(f"Could not fetch cancelled stoploss order {order_id}.")
order = {'fee': {}, 'status': 'canceled', 'amount': amount, 'info': {}}
return order
@retrier
def get_balances(self) -> dict:
try:
balances = self._api.fetch_balance()
# Remove additional info from ccxt results
balances.pop("info", None)
balances.pop("free", None)
balances.pop("total", None)
balances.pop("used", None)
return balances
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get balance due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
@retrier
def fetch_positions(self, pair: Optional[str] = None) -> List[Dict]:
"""
Fetch positions from the exchange.
If no pair is given, all positions are returned.
:param pair: Pair for the query
"""
if self._config['dry_run'] or self.trading_mode != TradingMode.FUTURES:
return []
try:
symbols = []
if pair:
symbols.append(pair)
positions: List[Dict] = self._api.fetch_positions(symbols)
self._log_exchange_response('fetch_positions', positions)
return positions
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get positions due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
def _fetch_orders_emulate(self, pair: str, since_ms: int) -> List[Dict]:
orders = []
if self.exchange_has('fetchClosedOrders'):
orders = self._api.fetch_closed_orders(pair, since=since_ms)
if self.exchange_has('fetchOpenOrders'):
orders_open = self._api.fetch_open_orders(pair, since=since_ms)
orders.extend(orders_open)
return orders
@retrier(retries=0)
def fetch_orders(self, pair: str, since: datetime, params: Optional[Dict] = None) -> List[Dict]:
"""
Fetch all orders for a pair "since"
:param pair: Pair for the query
:param since: Starting time for the query
"""
if self._config['dry_run']:
return []
try:
since_ms = int((since.timestamp() - 10) * 1000)
if self.exchange_has('fetchOrders'):
if not params:
params = {}
try:
orders: List[Dict] = self._api.fetch_orders(pair, since=since_ms, params=params)
except ccxt.NotSupported:
# Some exchanges don't support fetchOrders
# attempt to fetch open and closed orders separately
orders = self._fetch_orders_emulate(pair, since_ms)
else:
orders = self._fetch_orders_emulate(pair, since_ms)
self._log_exchange_response('fetch_orders', orders)
orders = [self._order_contracts_to_amount(o) for o in orders]
return orders
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not fetch positions due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
@retrier
def fetch_trading_fees(self) -> Dict[str, Any]:
"""
Fetch user account trading fees
Can be cached, should not update often.
"""
if (self._config['dry_run'] or self.trading_mode != TradingMode.FUTURES
or not self.exchange_has('fetchTradingFees')):
return {}
try:
trading_fees: Dict[str, Any] = self._api.fetch_trading_fees()
self._log_exchange_response('fetch_trading_fees', trading_fees)
return trading_fees
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not fetch trading fees due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
@retrier
def fetch_bids_asks(self, symbols: Optional[List[str]] = None, cached: bool = False) -> Dict:
"""
:param cached: Allow cached result
:return: fetch_tickers result
"""
if not self.exchange_has('fetchBidsAsks'):
return {}
if cached:
with self._cache_lock:
tickers = self._fetch_tickers_cache.get('fetch_bids_asks')
if tickers:
return tickers
try:
tickers = self._api.fetch_bids_asks(symbols)
with self._cache_lock:
self._fetch_tickers_cache['fetch_bids_asks'] = tickers
return tickers
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching bids/asks in batch. '
f'Message: {e}') from e
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load bids/asks due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
@retrier
def get_tickers(self, symbols: Optional[List[str]] = None, cached: bool = False) -> Tickers:
"""
:param cached: Allow cached result
:return: fetch_tickers result
"""
tickers: Tickers
if not self.exchange_has('fetchTickers'):
return {}
if cached:
with self._cache_lock:
tickers = self._fetch_tickers_cache.get('fetch_tickers') # type: ignore
if tickers:
return tickers
try:
tickers = self._api.fetch_tickers(symbols)
with self._cache_lock:
self._fetch_tickers_cache['fetch_tickers'] = tickers
return tickers
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching tickers in batch. '
f'Message: {e}') from e
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load tickers due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
# Pricing info
@retrier
def fetch_ticker(self, pair: str) -> Ticker:
try:
if (pair not in self.markets or
self.markets[pair].get('active', False) is False):
raise ExchangeError(f"Pair {pair} not available")
data: Ticker = self._api.fetch_ticker(pair)
return data
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load ticker due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
@staticmethod
def get_next_limit_in_list(limit: int, limit_range: Optional[List[int]],
range_required: bool = True):
"""
Get next greater value in the list.
Used by fetch_l2_order_book if the api only supports a limited range
"""
if not limit_range:
return limit
result = min([x for x in limit_range if limit <= x] + [max(limit_range)])
if not range_required and limit > result:
# Range is not required - we can use None as parameter.
return None
return result
@retrier
def fetch_l2_order_book(self, pair: str, limit: int = 100) -> OrderBook:
"""
Get L2 order book from exchange.
Can be limited to a certain amount (if supported).
Returns a dict in the format
{'asks': [price, volume], 'bids': [price, volume]}
"""
limit1 = self.get_next_limit_in_list(limit, self._ft_has['l2_limit_range'],
self._ft_has['l2_limit_range_required'])
try:
return self._api.fetch_l2_order_book(pair, limit1)
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching order book.'
f'Message: {e}') from e
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get order book due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
def _get_price_side(self, side: str, is_short: bool, conf_strategy: Dict) -> BidAsk:
price_side = conf_strategy['price_side']
if price_side in ('same', 'other'):
price_map = {
('entry', 'long', 'same'): 'bid',
('entry', 'long', 'other'): 'ask',
('entry', 'short', 'same'): 'ask',
('entry', 'short', 'other'): 'bid',
('exit', 'long', 'same'): 'ask',
('exit', 'long', 'other'): 'bid',
('exit', 'short', 'same'): 'bid',
('exit', 'short', 'other'): 'ask',
}
price_side = price_map[(side, 'short' if is_short else 'long', price_side)]
return price_side
def get_rate(self, pair: str, refresh: bool,
side: EntryExit, is_short: bool,
order_book: Optional[OrderBook] = None, ticker: Optional[Ticker] = None) -> float:
"""
Calculates bid/ask target
bid rate - between current ask price and last price
ask rate - either using ticker bid or first bid based on orderbook
or remain static in any other case since it's not updating.
:param pair: Pair to get rate for
:param refresh: allow cached data
:param side: "buy" or "sell"
:return: float: Price
:raises PricingError if orderbook price could not be determined.
"""
name = side.capitalize()
strat_name = 'entry_pricing' if side == "entry" else 'exit_pricing'
cache_rate: TTLCache = self._entry_rate_cache if side == "entry" else self._exit_rate_cache
if not refresh:
with self._cache_lock:
rate = cache_rate.get(pair)
# Check if cache has been invalidated
if rate:
logger.debug(f"Using cached {side} rate for {pair}.")
return rate
conf_strategy = self._config.get(strat_name, {})
price_side = self._get_price_side(side, is_short, conf_strategy)
if conf_strategy.get('use_order_book', False):
order_book_top = conf_strategy.get('order_book_top', 1)
if order_book is None:
order_book = self.fetch_l2_order_book(pair, order_book_top)
rate = self._get_rate_from_ob(pair, side, order_book, name, price_side,
order_book_top)
else:
logger.debug(f"Using Last {price_side.capitalize()} / Last Price")
if ticker is None:
ticker = self.fetch_ticker(pair)
rate = self._get_rate_from_ticker(side, ticker, conf_strategy, price_side)
if rate is None:
raise PricingError(f"{name}-Rate for {pair} was empty.")
with self._cache_lock:
cache_rate[pair] = rate
return rate
def _get_rate_from_ticker(self, side: EntryExit, ticker: Ticker, conf_strategy: Dict[str, Any],
price_side: BidAsk) -> Optional[float]:
"""
Get rate from ticker.
"""
ticker_rate = ticker[price_side]
if ticker['last'] and ticker_rate:
if side == 'entry' and ticker_rate > ticker['last']:
balance = conf_strategy.get('price_last_balance', 0.0)
ticker_rate = ticker_rate + balance * (ticker['last'] - ticker_rate)
elif side == 'exit' and ticker_rate < ticker['last']:
balance = conf_strategy.get('price_last_balance', 0.0)
ticker_rate = ticker_rate - balance * (ticker_rate - ticker['last'])
rate = ticker_rate
return rate
def _get_rate_from_ob(self, pair: str, side: EntryExit, order_book: OrderBook, name: str,
price_side: BidAsk, order_book_top: int) -> float:
"""
Get rate from orderbook
:raises: PricingError if rate could not be determined.
"""
logger.debug('order_book %s', order_book)
# top 1 = index 0
try:
obside: OBLiteral = 'bids' if price_side == 'bid' else 'asks'
rate = order_book[obside][order_book_top - 1][0]
except (IndexError, KeyError) as e:
logger.warning(
f"{pair} - {name} Price at location {order_book_top} from orderbook "
f"could not be determined. Orderbook: {order_book}"
)
raise PricingError from e
logger.debug(f"{pair} - {name} price from orderbook {price_side.capitalize()}"
f"side - top {order_book_top} order book {side} rate {rate:.8f}")
return rate
def get_rates(self, pair: str, refresh: bool, is_short: bool) -> Tuple[float, float]:
entry_rate = None
exit_rate = None
if not refresh:
with self._cache_lock:
entry_rate = self._entry_rate_cache.get(pair)
exit_rate = self._exit_rate_cache.get(pair)
if entry_rate:
logger.debug(f"Using cached buy rate for {pair}.")
if exit_rate:
logger.debug(f"Using cached sell rate for {pair}.")
entry_pricing = self._config.get('entry_pricing', {})
exit_pricing = self._config.get('exit_pricing', {})
order_book = ticker = None
if not entry_rate and entry_pricing.get('use_order_book', False):
order_book_top = max(entry_pricing.get('order_book_top', 1),
exit_pricing.get('order_book_top', 1))
order_book = self.fetch_l2_order_book(pair, order_book_top)
entry_rate = self.get_rate(pair, refresh, 'entry', is_short, order_book=order_book)
elif not entry_rate:
ticker = self.fetch_ticker(pair)
entry_rate = self.get_rate(pair, refresh, 'entry', is_short, ticker=ticker)
if not exit_rate:
exit_rate = self.get_rate(pair, refresh, 'exit',
is_short, order_book=order_book, ticker=ticker)
return entry_rate, exit_rate
# Fee handling
@retrier
def get_trades_for_order(self, order_id: str, pair: str, since: datetime,
params: Optional[Dict] = None) -> List:
"""
Fetch Orders using the "fetch_my_trades" endpoint and filter them by order-id.
The "since" argument passed in is coming from the database and is in UTC,
as timezone-native datetime object.
From the python documentation:
> Naive datetime instances are assumed to represent local time
Therefore, calling "since.timestamp()" will get the UTC timestamp, after applying the
transformation from local timezone to UTC.
This works for timezones UTC+ since then the result will contain trades from a few hours
instead of from the last 5 seconds, however fails for UTC- timezones,
since we're then asking for trades with a "since" argument in the future.
:param order_id order_id: Order-id as given when creating the order
:param pair: Pair the order is for
:param since: datetime object of the order creation time. Assumes object is in UTC.
"""
if self._config['dry_run']:
return []
if not self.exchange_has('fetchMyTrades'):
return []
try:
# Allow 5s offset to catch slight time offsets (discovered in #1185)
# since needs to be int in milliseconds
_params = params if params else {}
my_trades = self._api.fetch_my_trades(
pair, int((since.replace(tzinfo=timezone.utc).timestamp() - 5) * 1000),
params=_params)
matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
self._log_exchange_response('get_trades_for_order', matched_trades)
matched_trades = self._trades_contracts_to_amount(matched_trades)
return matched_trades
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get trades due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
def get_order_id_conditional(self, order: Dict[str, Any]) -> str:
return order['id']
@retrier
def get_fee(self, symbol: str, type: str = '', side: str = '', amount: float = 1,
price: float = 1, taker_or_maker: MakerTaker = 'maker') -> float:
"""
Retrieve fee from exchange
:param symbol: Pair
:param type: Type of order (market, limit, ...)
:param side: Side of order (buy, sell)
:param amount: Amount of order
:param price: Price of order
:param taker_or_maker: 'maker' or 'taker' (ignored if "type" is provided)
"""
if type and type == 'market':
taker_or_maker = 'taker'
try:
if self._config['dry_run'] and self._config.get('fee', None) is not None:
return self._config['fee']
# validate that markets are loaded before trying to get fee
if self._api.markets is None or len(self._api.markets) == 0:
self._api.load_markets(params={})
return self._api.calculate_fee(symbol=symbol, type=type, side=side, amount=amount,
price=price, takerOrMaker=taker_or_maker)['rate']
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get fee info due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
@staticmethod
def order_has_fee(order: Dict) -> bool:
"""
Verifies if the passed in order dict has the needed keys to extract fees,
and that these keys (currency, cost) are not empty.
:param order: Order or trade (one trade) dict
:return: True if the fee substructure contains currency and cost, false otherwise
"""
if not isinstance(order, dict):
return False
return ('fee' in order and order['fee'] is not None
and (order['fee'].keys() >= {'currency', 'cost'})
and order['fee']['currency'] is not None
and order['fee']['cost'] is not None
)
def calculate_fee_rate(
self, fee: Dict, symbol: str, cost: float, amount: float) -> Optional[float]:
"""
Calculate fee rate if it's not given by the exchange.
:param fee: ccxt Fee dict - must contain cost / currency / rate
:param symbol: Symbol of the order
:param cost: Total cost of the order
:param amount: Amount of the order
"""
if fee.get('rate') is not None:
return fee.get('rate')
fee_curr = fee.get('currency')
if fee_curr is None:
return None
fee_cost = float(fee['cost'])
# Calculate fee based on order details
if fee_curr == self.get_pair_base_currency(symbol):
# Base currency - divide by amount
return round(fee_cost / amount, 8)
elif fee_curr == self.get_pair_quote_currency(symbol):
# Quote currency - divide by cost
return round(fee_cost / cost, 8) if cost else None
else:
# If Fee currency is a different currency
if not cost:
# If cost is None or 0.0 -> falsy, return None
return None
try:
comb = self.get_valid_pair_combination(fee_curr, self._config['stake_currency'])
tick = self.fetch_ticker(comb)
fee_to_quote_rate = safe_value_fallback2(tick, tick, 'last', 'ask')
except (ValueError, ExchangeError):
fee_to_quote_rate = self._config['exchange'].get('unknown_fee_rate', None)
if not fee_to_quote_rate:
return None
return round((fee_cost * fee_to_quote_rate) / cost, 8)
def extract_cost_curr_rate(self, fee: Dict, symbol: str, cost: float,
amount: float) -> Tuple[float, str, Optional[float]]:
"""
Extract tuple of cost, currency, rate.
Requires order_has_fee to run first!
:param fee: ccxt Fee dict - must contain cost / currency / rate
:param symbol: Symbol of the order
:param cost: Total cost of the order
:param amount: Amount of the order
:return: Tuple with cost, currency, rate of the given fee dict
"""
return (float(fee['cost']),
fee['currency'],
self.calculate_fee_rate(
fee,
symbol,
cost,
amount
)
)
# Historic data
def get_historic_ohlcv(self, pair: str, timeframe: str,
since_ms: int, candle_type: CandleType,
is_new_pair: bool = False,
until_ms: Optional[int] = None) -> List:
"""
Get candle history using asyncio and returns the list of candles.
Handles all async work for this.
Async over one pair, assuming we get `self.ohlcv_candle_limit()` candles per call.
:param pair: Pair to download
:param timeframe: Timeframe to get data for
:param since_ms: Timestamp in milliseconds to get history from
:param until_ms: Timestamp in milliseconds to get history up to
:param candle_type: '', mark, index, premiumIndex, or funding_rate
:return: List with candle (OHLCV) data
"""
pair, _, _, data, _ = self.loop.run_until_complete(
self._async_get_historic_ohlcv(pair=pair, timeframe=timeframe,
since_ms=since_ms, until_ms=until_ms,
is_new_pair=is_new_pair, candle_type=candle_type))
logger.info(f"Downloaded data for {pair} with length {len(data)}.")
return data
async def _async_get_historic_ohlcv(self, pair: str, timeframe: str,
since_ms: int, candle_type: CandleType,
is_new_pair: bool = False, raise_: bool = False,
until_ms: Optional[int] = None
) -> OHLCVResponse:
"""
Download historic ohlcv
:param is_new_pair: used by binance subclass to allow "fast" new pair downloading
:param candle_type: Any of the enum CandleType (must match trading mode!)
"""
one_call = timeframe_to_msecs(timeframe) * self.ohlcv_candle_limit(
timeframe, candle_type, since_ms)
logger.debug(
"one_call: %s msecs (%s)",
one_call,
dt_humanize(dt_now() - timedelta(milliseconds=one_call), only_distance=True)
)
input_coroutines = [self._async_get_candle_history(
pair, timeframe, candle_type, since) for since in
range(since_ms, until_ms or dt_ts(), one_call)]
data: List = []
# Chunk requests into batches of 100 to avoid overwelming ccxt Throttling
for input_coro in chunks(input_coroutines, 100):
results = await asyncio.gather(*input_coro, return_exceptions=True)
for res in results:
if isinstance(res, Exception):
logger.warning(f"Async code raised an exception: {repr(res)}")
if raise_:
raise
continue
else:
# Deconstruct tuple if it's not an exception
p, _, c, new_data, _ = res
if p == pair and c == candle_type:
data.extend(new_data)
# Sort data again after extending the result - above calls return in "async order"
data = sorted(data, key=lambda x: x[0])
return pair, timeframe, candle_type, data, self._ohlcv_partial_candle
def _build_coroutine(
self, pair: str, timeframe: str, candle_type: CandleType,
since_ms: Optional[int], cache: bool) -> Coroutine[Any, Any, OHLCVResponse]:
not_all_data = cache and self.required_candle_call_count > 1
if cache and (pair, timeframe, candle_type) in self._klines:
candle_limit = self.ohlcv_candle_limit(timeframe, candle_type)
min_date = date_minus_candles(timeframe, candle_limit - 5).timestamp()
# Check if 1 call can get us updated candles without hole in the data.
if min_date < self._pairs_last_refresh_time.get((pair, timeframe, candle_type), 0):
# Cache can be used - do one-off call.
not_all_data = False
else:
# Time jump detected, evict cache
logger.info(
f"Time jump detected. Evicting cache for {pair}, {timeframe}, {candle_type}")
del self._klines[(pair, timeframe, candle_type)]
if (not since_ms and (self._ft_has["ohlcv_require_since"] or not_all_data)):
# Multiple calls for one pair - to get more history
one_call = timeframe_to_msecs(timeframe) * self.ohlcv_candle_limit(
timeframe, candle_type, since_ms)
move_to = one_call * self.required_candle_call_count
now = timeframe_to_next_date(timeframe)
since_ms = int((now - timedelta(seconds=move_to // 1000)).timestamp() * 1000)
if since_ms:
return self._async_get_historic_ohlcv(
pair, timeframe, since_ms=since_ms, raise_=True, candle_type=candle_type)
else:
# One call ... "regular" refresh
return self._async_get_candle_history(
pair, timeframe, since_ms=since_ms, candle_type=candle_type)
def _build_ohlcv_dl_jobs(
self, pair_list: ListPairsWithTimeframes, since_ms: Optional[int],
cache: bool) -> Tuple[List[Coroutine], List[Tuple[str, str, CandleType]]]:
"""
Build Coroutines to execute as part of refresh_latest_ohlcv
"""
input_coroutines: List[Coroutine[Any, Any, OHLCVResponse]] = []
cached_pairs = []
for pair, timeframe, candle_type in set(pair_list):
if (timeframe not in self.timeframes
and candle_type in (CandleType.SPOT, CandleType.FUTURES)):
logger.warning(
f"Cannot download ({pair}, {timeframe}) combination as this timeframe is "
f"not available on {self.name}. Available timeframes are "
f"{', '.join(self.timeframes)}.")
continue
if ((pair, timeframe, candle_type) not in self._klines or not cache
or self._now_is_time_to_refresh(pair, timeframe, candle_type)):
input_coroutines.append(
self._build_coroutine(pair, timeframe, candle_type, since_ms, cache))
else:
logger.debug(
f"Using cached candle (OHLCV) data for {pair}, {timeframe}, {candle_type} ..."
)
cached_pairs.append((pair, timeframe, candle_type))
return input_coroutines, cached_pairs
def _process_ohlcv_df(self, pair: str, timeframe: str, c_type: CandleType, ticks: List[List],
cache: bool, drop_incomplete: bool) -> DataFrame:
# keeping last candle time as last refreshed time of the pair
if ticks and cache:
idx = -2 if drop_incomplete and len(ticks) > 1 else -1
self._pairs_last_refresh_time[(pair, timeframe, c_type)] = ticks[idx][0] // 1000
# keeping parsed dataframe in cache
ohlcv_df = ohlcv_to_dataframe(ticks, timeframe, pair=pair, fill_missing=True,
drop_incomplete=drop_incomplete)
if cache:
if (pair, timeframe, c_type) in self._klines:
old = self._klines[(pair, timeframe, c_type)]
# Reassign so we return the updated, combined df
ohlcv_df = clean_ohlcv_dataframe(concat([old, ohlcv_df], axis=0), timeframe, pair,
fill_missing=True, drop_incomplete=False)
candle_limit = self.ohlcv_candle_limit(timeframe, self._config['candle_type_def'])
# Age out old candles
ohlcv_df = ohlcv_df.tail(candle_limit + self._startup_candle_count)
ohlcv_df = ohlcv_df.reset_index(drop=True)
self._klines[(pair, timeframe, c_type)] = ohlcv_df
else:
self._klines[(pair, timeframe, c_type)] = ohlcv_df
return ohlcv_df
def refresh_latest_ohlcv(self, pair_list: ListPairsWithTimeframes, *,
since_ms: Optional[int] = None, cache: bool = True,
drop_incomplete: Optional[bool] = None
) -> Dict[PairWithTimeframe, DataFrame]:
"""
Refresh in-memory OHLCV asynchronously and set `_klines` with the result
Loops asynchronously over pair_list and downloads all pairs async (semi-parallel).
Only used in the dataprovider.refresh() method.
:param pair_list: List of 2 element tuples containing pair, interval to refresh
:param since_ms: time since when to download, in milliseconds
:param cache: Assign result to _klines. Usefull for one-off downloads like for pairlists
:param drop_incomplete: Control candle dropping.
Specifying None defaults to _ohlcv_partial_candle
:return: Dict of [{(pair, timeframe): Dataframe}]
"""
logger.debug("Refreshing candle (OHLCV) data for %d pairs", len(pair_list))
# Gather coroutines to run
input_coroutines, cached_pairs = self._build_ohlcv_dl_jobs(pair_list, since_ms, cache)
results_df = {}
# Chunk requests into batches of 100 to avoid overwelming ccxt Throttling
for input_coro in chunks(input_coroutines, 100):
async def gather_stuff():
return await asyncio.gather(*input_coro, return_exceptions=True)
with self._loop_lock:
results = self.loop.run_until_complete(gather_stuff())
for res in results:
if isinstance(res, Exception):
logger.warning(f"Async code raised an exception: {repr(res)}")
continue
# Deconstruct tuple (has 5 elements)
pair, timeframe, c_type, ticks, drop_hint = res
drop_incomplete_ = drop_hint if drop_incomplete is None else drop_incomplete
ohlcv_df = self._process_ohlcv_df(
pair, timeframe, c_type, ticks, cache, drop_incomplete_)
results_df[(pair, timeframe, c_type)] = ohlcv_df
# Return cached klines
for pair, timeframe, c_type in cached_pairs:
results_df[(pair, timeframe, c_type)] = self.klines(
(pair, timeframe, c_type),
copy=False
)
return results_df
def _now_is_time_to_refresh(self, pair: str, timeframe: str, candle_type: CandleType) -> bool:
# Timeframe in seconds
interval_in_sec = timeframe_to_seconds(timeframe)
plr = self._pairs_last_refresh_time.get((pair, timeframe, candle_type), 0) + interval_in_sec
# current,active candle open date
now = int(timeframe_to_prev_date(timeframe).timestamp())
return plr < now
@retrier_async
async def _async_get_candle_history(
self,
pair: str,
timeframe: str,
candle_type: CandleType,
since_ms: Optional[int] = None,
) -> OHLCVResponse:
"""
Asynchronously get candle history data using fetch_ohlcv
:param candle_type: '', mark, index, premiumIndex, or funding_rate
returns tuple: (pair, timeframe, ohlcv_list)
"""
try:
# Fetch OHLCV asynchronously
s = '(' + dt_from_ts(since_ms).isoformat() + ') ' if since_ms is not None else ''
logger.debug(
"Fetching pair %s, %s, interval %s, since %s %s...",
pair, candle_type, timeframe, since_ms, s
)
params = deepcopy(self._ft_has.get('ohlcv_params', {}))
candle_limit = self.ohlcv_candle_limit(
timeframe, candle_type=candle_type, since_ms=since_ms)
if candle_type and candle_type != CandleType.SPOT:
params.update({'price': candle_type.value})
if candle_type != CandleType.FUNDING_RATE:
data = await self._api_async.fetch_ohlcv(
pair, timeframe=timeframe, since=since_ms,
limit=candle_limit, params=params)
else:
# Funding rate
data = await self._fetch_funding_rate_history(
pair=pair,
timeframe=timeframe,
limit=candle_limit,
since_ms=since_ms,
)
# Some exchanges sort OHLCV in ASC order and others in DESC.
# Ex: Bittrex returns the list of OHLCV in ASC order (oldest first, newest last)
# while GDAX returns the list of OHLCV in DESC order (newest first, oldest last)
# Only sort if necessary to save computing time
try:
if data and data[0][0] > data[-1][0]:
data = sorted(data, key=lambda x: x[0])
except IndexError:
logger.exception("Error loading %s. Result was %s.", pair, data)
return pair, timeframe, candle_type, [], self._ohlcv_partial_candle
logger.debug("Done fetching pair %s, %s interval %s...", pair, candle_type, timeframe)
return pair, timeframe, candle_type, data, self._ohlcv_partial_candle
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching historical '
f'candle (OHLCV) data. Message: {e}') from e
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(f'Could not fetch historical candle (OHLCV) data '
f'for pair {pair} due to {e.__class__.__name__}. '
f'Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(f'Could not fetch historical candle (OHLCV) data '
f'for pair {pair}. Message: {e}') from e
async def _fetch_funding_rate_history(
self,
pair: str,
timeframe: str,
limit: int,
since_ms: Optional[int] = None,
) -> List[List]:
"""
Fetch funding rate history - used to selectively override this by subclasses.
"""
# Funding rate
data = await self._api_async.fetch_funding_rate_history(
pair, since=since_ms,
limit=limit)
# Convert funding rate to candle pattern
data = [[x['timestamp'], x['fundingRate'], 0, 0, 0, 0] for x in data]
return data
# Fetch historic trades
@retrier_async
async def _async_fetch_trades(self, pair: str,
since: Optional[int] = None,
params: Optional[dict] = None) -> List[List]:
"""
Asyncronously gets trade history using fetch_trades.
Handles exchange errors, does one call to the exchange.
:param pair: Pair to fetch trade data for
:param since: Since as integer timestamp in milliseconds
returns: List of dicts containing trades
"""
try:
# fetch trades asynchronously
if params:
logger.debug("Fetching trades for pair %s, params: %s ", pair, params)
trades = await self._api_async.fetch_trades(pair, params=params, limit=1000)
else:
logger.debug(
"Fetching trades for pair %s, since %s %s...",
pair, since,
'(' + dt_from_ts(since).isoformat() + ') ' if since is not None else ''
)
trades = await self._api_async.fetch_trades(pair, since=since, limit=1000)
trades = self._trades_contracts_to_amount(trades)
return trades_dict_to_list(trades)
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching historical trade data.'
f'Message: {e}') from e
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(f'Could not load trade history due to {e.__class__.__name__}. '
f'Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(f'Could not fetch trade data. Msg: {e}') from e
async def _async_get_trade_history_id(self, pair: str,
until: int,
since: Optional[int] = None,
from_id: Optional[str] = None) -> Tuple[str, List[List]]:
"""
Asyncronously gets trade history using fetch_trades
use this when exchange uses id-based iteration (check `self._trades_pagination`)
:param pair: Pair to fetch trade data for
:param since: Since as integer timestamp in milliseconds
:param until: Until as integer timestamp in milliseconds
:param from_id: Download data starting with ID (if id is known). Ignores "since" if set.
returns tuple: (pair, trades-list)
"""
trades: List[List] = []
if not from_id:
# Fetch first elements using timebased method to get an ID to paginate on
# Depending on the Exchange, this can introduce a drift at the start of the interval
# of up to an hour.
# e.g. Binance returns the "last 1000" candles within a 1h time interval
# - so we will miss the first trades.
t = await self._async_fetch_trades(pair, since=since)
# DEFAULT_TRADES_COLUMNS: 0 -> timestamp
# DEFAULT_TRADES_COLUMNS: 1 -> id
from_id = t[-1][1]
trades.extend(t[:-1])
while True:
try:
t = await self._async_fetch_trades(pair,
params={self._trades_pagination_arg: from_id})
if t:
# Skip last id since its the key for the next call
trades.extend(t[:-1])
if from_id == t[-1][1] or t[-1][0] > until:
logger.debug(f"Stopping because from_id did not change. "
f"Reached {t[-1][0]} > {until}")
# Reached the end of the defined-download period - add last trade as well.
trades.extend(t[-1:])
break
from_id = t[-1][1]
else:
logger.debug("Stopping as no more trades were returned.")
break
except asyncio.CancelledError:
logger.debug("Async operation Interrupted, breaking trades DL loop.")
break
return (pair, trades)
async def _async_get_trade_history_time(self, pair: str, until: int,
since: Optional[int] = None) -> Tuple[str, List[List]]:
"""
Asyncronously gets trade history using fetch_trades,
when the exchange uses time-based iteration (check `self._trades_pagination`)
:param pair: Pair to fetch trade data for
:param since: Since as integer timestamp in milliseconds
:param until: Until as integer timestamp in milliseconds
returns tuple: (pair, trades-list)
"""
trades: List[List] = []
# DEFAULT_TRADES_COLUMNS: 0 -> timestamp
# DEFAULT_TRADES_COLUMNS: 1 -> id
while True:
try:
t = await self._async_fetch_trades(pair, since=since)
if t:
# No more trades to download available at the exchange,
# So we repeatedly get the same trade over and over again.
if since == t[-1][0] and len(t) == 1:
logger.debug("Stopping because no more trades are available.")
break
since = t[-1][0]
trades.extend(t)
# Reached the end of the defined-download period
if until and t[-1][0] > until:
logger.debug(
f"Stopping because until was reached. {t[-1][0]} > {until}")
break
else:
logger.debug("Stopping as no more trades were returned.")
break
except asyncio.CancelledError:
logger.debug("Async operation Interrupted, breaking trades DL loop.")
break
return (pair, trades)
async def _async_get_trade_history(self, pair: str,
since: Optional[int] = None,
until: Optional[int] = None,
from_id: Optional[str] = None) -> Tuple[str, List[List]]:
"""
Async wrapper handling downloading trades using either time or id based methods.
"""
logger.debug(f"_async_get_trade_history(), pair: {pair}, "
f"since: {since}, until: {until}, from_id: {from_id}")
if until is None:
until = ccxt.Exchange.milliseconds()
logger.debug(f"Exchange milliseconds: {until}")
if self._trades_pagination == 'time':
return await self._async_get_trade_history_time(
pair=pair, since=since, until=until)
elif self._trades_pagination == 'id':
return await self._async_get_trade_history_id(
pair=pair, since=since, until=until, from_id=from_id
)
else:
raise OperationalException(f"Exchange {self.name} does use neither time, "
f"nor id based pagination")
def get_historic_trades(self, pair: str,
since: Optional[int] = None,
until: Optional[int] = None,
from_id: Optional[str] = None) -> Tuple[str, List]:
"""
Get trade history data using asyncio.
Handles all async work and returns the list of candles.
Async over one pair, assuming we get `self.ohlcv_candle_limit()` candles per call.
:param pair: Pair to download
:param since: Timestamp in milliseconds to get history from
:param until: Timestamp in milliseconds. Defaults to current timestamp if not defined.
:param from_id: Download data starting with ID (if id is known)
:returns List of trade data
"""
if not self.exchange_has("fetchTrades"):
raise OperationalException("This exchange does not support downloading Trades.")
with self._loop_lock:
task = asyncio.ensure_future(self._async_get_trade_history(
pair=pair, since=since, until=until, from_id=from_id))
for sig in [signal.SIGINT, signal.SIGTERM]:
try:
self.loop.add_signal_handler(sig, task.cancel)
except NotImplementedError:
# Not all platforms implement signals (e.g. windows)
pass
return self.loop.run_until_complete(task)
@retrier
def _get_funding_fees_from_exchange(self, pair: str, since: Union[datetime, int]) -> float:
"""
Returns the sum of all funding fees that were exchanged for a pair within a timeframe
Dry-run handling happens as part of _calculate_funding_fees.
:param pair: (e.g. ADA/USDT)
:param since: The earliest time of consideration for calculating funding fees,
in unix time or as a datetime
"""
if not self.exchange_has("fetchFundingHistory"):
raise OperationalException(
f"fetch_funding_history() is not available using {self.name}"
)
if type(since) is datetime:
since = int(since.timestamp()) * 1000 # * 1000 for ms
try:
funding_history = self._api.fetch_funding_history(
symbol=pair,
since=since
)
return sum(fee['amount'] for fee in funding_history)
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get funding fees due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
@retrier
def get_leverage_tiers(self) -> Dict[str, List[Dict]]:
try:
return self._api.fetch_leverage_tiers()
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load leverage tiers due to {e.__class__.__name__}. Message: {e}'
) from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
@retrier_async
async def get_market_leverage_tiers(self, symbol: str) -> Tuple[str, List[Dict]]:
""" Leverage tiers per symbol """
try:
tier = await self._api_async.fetch_market_leverage_tiers(symbol)
return symbol, tier
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load leverage tiers for {symbol}'
f' due to {e.__class__.__name__}. Message: {e}'
) from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
def load_leverage_tiers(self) -> Dict[str, List[Dict]]:
if self.trading_mode == TradingMode.FUTURES:
if self.exchange_has('fetchLeverageTiers'):
# Fetch all leverage tiers at once
return self.get_leverage_tiers()
elif self.exchange_has('fetchMarketLeverageTiers'):
# Must fetch the leverage tiers for each market separately
# * This is slow(~45s) on Okx, makes ~90 api calls to load all linear swap markets
markets = self.markets
symbols = [
symbol for symbol, market in markets.items()
if (self.market_is_future(market)
and market['quote'] == self._config['stake_currency'])
]
tiers: Dict[str, List[Dict]] = {}
tiers_cached = self.load_cached_leverage_tiers(self._config['stake_currency'])
if tiers_cached:
tiers = tiers_cached
coros = [
self.get_market_leverage_tiers(symbol)
for symbol in sorted(symbols) if symbol not in tiers]
# Be verbose here, as this delays startup by ~1 minute.
if coros:
logger.info(
f"Initializing leverage_tiers for {len(symbols)} markets. "
"This will take about a minute.")
else:
logger.info("Using cached leverage_tiers.")
async def gather_results(input_coro):
return await asyncio.gather(*input_coro, return_exceptions=True)
for input_coro in chunks(coros, 100):
with self._loop_lock:
results = self.loop.run_until_complete(gather_results(input_coro))
for res in results:
if isinstance(res, Exception):
logger.warning(f"Leverage tier exception: {repr(res)}")
continue
symbol, tier = res
tiers[symbol] = tier
if len(coros) > 0:
self.cache_leverage_tiers(tiers, self._config['stake_currency'])
logger.info(f"Done initializing {len(symbols)} markets.")
return tiers
return {}
def cache_leverage_tiers(self, tiers: Dict[str, List[Dict]], stake_currency: str) -> None:
filename = self._config['datadir'] / "futures" / f"leverage_tiers_{stake_currency}.json"
if not filename.parent.is_dir():
filename.parent.mkdir(parents=True)
data = {
"updated": datetime.now(timezone.utc),
"data": tiers,
}
file_dump_json(filename, data)
def load_cached_leverage_tiers(self, stake_currency: str) -> Optional[Dict[str, List[Dict]]]:
filename = self._config['datadir'] / "futures" / f"leverage_tiers_{stake_currency}.json"
if filename.is_file():
try:
tiers = file_load_json(filename)
updated = tiers.get('updated')
if updated:
updated_dt = parser.parse(updated)
if updated_dt < datetime.now(timezone.utc) - timedelta(weeks=4):
logger.info("Cached leverage tiers are outdated. Will update.")
return None
return tiers['data']
except Exception:
logger.exception("Error loading cached leverage tiers. Refreshing.")
return None
def fill_leverage_tiers(self) -> None:
"""
Assigns property _leverage_tiers to a dictionary of information about the leverage
allowed on each pair
"""
leverage_tiers = self.load_leverage_tiers()
for pair, tiers in leverage_tiers.items():
pair_tiers = []
for tier in tiers:
pair_tiers.append(self.parse_leverage_tier(tier))
self._leverage_tiers[pair] = pair_tiers
def parse_leverage_tier(self, tier) -> Dict:
info = tier.get('info', {})
return {
'minNotional': tier['minNotional'],
'maxNotional': tier['maxNotional'],
'maintenanceMarginRate': tier['maintenanceMarginRate'],
'maxLeverage': tier['maxLeverage'],
'maintAmt': float(info['cum']) if 'cum' in info else None,
}
def get_max_leverage(self, pair: str, stake_amount: Optional[float]) -> float:
"""
Returns the maximum leverage that a pair can be traded at
:param pair: The base/quote currency pair being traded
:stake_amount: The total value of the traders margin_mode in quote currency
"""
if self.trading_mode == TradingMode.SPOT:
return 1.0
if self.trading_mode == TradingMode.FUTURES:
# Checks and edge cases
if stake_amount is None:
raise OperationalException(
f'{self.name}.get_max_leverage requires argument stake_amount'
)
if pair not in self._leverage_tiers:
# Maybe raise exception because it can't be traded on futures?
return 1.0
pair_tiers = self._leverage_tiers[pair]
if stake_amount == 0:
return self._leverage_tiers[pair][0]['maxLeverage'] # Max lev for lowest amount
for tier_index in range(len(pair_tiers)):
tier = pair_tiers[tier_index]
lev = tier['maxLeverage']
if tier_index < len(pair_tiers) - 1:
next_tier = pair_tiers[tier_index + 1]
next_floor = next_tier['minNotional'] / next_tier['maxLeverage']
if next_floor > stake_amount: # Next tier min too high for stake amount
return min((tier['maxNotional'] / stake_amount), lev)
#
# With the two leverage tiers below,
# - a stake amount of 150 would mean a max leverage of (10000 / 150) = 66.66
# - stakes below 133.33 = max_lev of 75
# - stakes between 133.33-200 = max_lev of 10000/stake = 50.01-74.99
# - stakes from 200 + 1000 = max_lev of 50
#
# {
# "min": 0, # stake = 0.0
# "max": 10000, # max_stake@75 = 10000/75 = 133.33333333333334
# "lev": 75,
# },
# {
# "min": 10000, # stake = 200.0
# "max": 50000, # max_stake@50 = 50000/50 = 1000.0
# "lev": 50,
# }
#
else: # if on the last tier
if stake_amount > tier['maxNotional']:
# If stake is > than max tradeable amount
raise InvalidOrderException(f'Amount {stake_amount} too high for {pair}')
else:
return tier['maxLeverage']
raise OperationalException(
'Looped through all tiers without finding a max leverage. Should never be reached'
)
elif self.trading_mode == TradingMode.MARGIN: # Search markets.limits for max lev
market = self.markets[pair]
if market['limits']['leverage']['max'] is not None:
return market['limits']['leverage']['max']
else:
return 1.0 # Default if max leverage cannot be found
else:
return 1.0
@retrier
def _set_leverage(
self,
leverage: float,
pair: Optional[str] = None,
accept_fail: bool = False,
):
"""
Set's the leverage before making a trade, in order to not
have the same leverage on every trade
"""
if self._config['dry_run'] or not self.exchange_has("setLeverage"):
# Some exchanges only support one margin_mode type
return
if self._ft_has.get('floor_leverage', False) is True:
# Rounding for binance ...
leverage = floor(leverage)
try:
res = self._api.set_leverage(symbol=pair, leverage=leverage)
self._log_exchange_response('set_leverage', res)
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except (ccxt.BadRequest, ccxt.InsufficientFunds) as e:
if not accept_fail:
raise TemporaryError(
f'Could not set leverage due to {e.__class__.__name__}. Message: {e}') from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not set leverage due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
def get_interest_rate(self) -> float:
"""
Retrieve interest rate - necessary for Margin trading.
Should not call the exchange directly when used from backtesting.
"""
return 0.0
def funding_fee_cutoff(self, open_date: datetime) -> bool:
"""
Funding fees are only charged at full hours (usually every 4-8h).
Therefore a trade opening at 10:00:01 will not be charged a funding fee until the next hour.
:param open_date: The open date for a trade
:return: True if the date falls on a full hour, False otherwise
"""
return open_date.minute == 0 and open_date.second == 0
@retrier
def set_margin_mode(self, pair: str, margin_mode: MarginMode, accept_fail: bool = False,
params: dict = {}):
"""
Set's the margin mode on the exchange to cross or isolated for a specific pair
:param pair: base/quote currency pair (e.g. "ADA/USDT")
"""
if self._config['dry_run'] or not self.exchange_has("setMarginMode"):
# Some exchanges only support one margin_mode type
return
try:
res = self._api.set_margin_mode(margin_mode.value, pair, params)
self._log_exchange_response('set_margin_mode', res)
except ccxt.DDoSProtection as e:
raise DDosProtection(e) from e
except ccxt.BadRequest as e:
if not accept_fail:
raise TemporaryError(
f'Could not set margin mode due to {e.__class__.__name__}. Message: {e}') from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not set margin mode due to {e.__class__.__name__}. Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(e) from e
def _fetch_and_calculate_funding_fees(
self,
pair: str,
amount: float,
is_short: bool,
open_date: datetime,
close_date: Optional[datetime] = None
) -> float:
"""
Fetches and calculates the sum of all funding fees that occurred for a pair
during a futures trade.
Only used during dry-run or if the exchange does not provide a funding_rates endpoint.
:param pair: The quote/base pair of the trade
:param amount: The quantity of the trade
:param is_short: trade direction
:param open_date: The date and time that the trade started
:param close_date: The date and time that the trade ended
"""
if self.funding_fee_cutoff(open_date):
# Shift back to 1h candle to avoid missing funding fees
# Only really relevant for trades very close to the full hour
open_date = timeframe_to_prev_date('1h', open_date)
timeframe = self._ft_has['mark_ohlcv_timeframe']
timeframe_ff = self._ft_has.get('funding_fee_timeframe',
self._ft_has['mark_ohlcv_timeframe'])
if not close_date:
close_date = datetime.now(timezone.utc)
since_ms = int(timeframe_to_prev_date(timeframe, open_date).timestamp()) * 1000
mark_comb: PairWithTimeframe = (
pair, timeframe, CandleType.from_string(self._ft_has["mark_ohlcv_price"]))
funding_comb: PairWithTimeframe = (pair, timeframe_ff, CandleType.FUNDING_RATE)
candle_histories = self.refresh_latest_ohlcv(
[mark_comb, funding_comb],
since_ms=since_ms,
cache=False,
drop_incomplete=False,
)
try:
# we can't assume we always get histories - for example during exchange downtimes
funding_rates = candle_histories[funding_comb]
mark_rates = candle_histories[mark_comb]
except KeyError:
raise ExchangeError("Could not find funding rates.") from None
funding_mark_rates = self.combine_funding_and_mark(funding_rates, mark_rates)
return self.calculate_funding_fees(
funding_mark_rates,
amount=amount,
is_short=is_short,
open_date=open_date,
close_date=close_date
)
@staticmethod
def combine_funding_and_mark(funding_rates: DataFrame, mark_rates: DataFrame,
futures_funding_rate: Optional[int] = None) -> DataFrame:
"""
Combine funding-rates and mark-rates dataframes
:param funding_rates: Dataframe containing Funding rates (Type FUNDING_RATE)
:param mark_rates: Dataframe containing Mark rates (Type mark_ohlcv_price)
:param futures_funding_rate: Fake funding rate to use if funding_rates are not available
"""
if futures_funding_rate is None:
return mark_rates.merge(
funding_rates, on='date', how="inner", suffixes=["_mark", "_fund"])
else:
if len(funding_rates) == 0:
# No funding rate candles - full fillup with fallback variable
mark_rates['open_fund'] = futures_funding_rate
return mark_rates.rename(
columns={'open': 'open_mark',
'close': 'close_mark',
'high': 'high_mark',
'low': 'low_mark',
'volume': 'volume_mark'})
else:
# Fill up missing funding_rate candles with fallback value
combined = mark_rates.merge(
funding_rates, on='date', how="outer", suffixes=["_mark", "_fund"]
)
combined['open_fund'] = combined['open_fund'].fillna(futures_funding_rate)
return combined
def calculate_funding_fees(
self,
df: DataFrame,
amount: float,
is_short: bool,
open_date: datetime,
close_date: datetime,
time_in_ratio: Optional[float] = None
) -> float:
"""
calculates the sum of all funding fees that occurred for a pair during a futures trade
:param df: Dataframe containing combined funding and mark rates
as `open_fund` and `open_mark`.
:param amount: The quantity of the trade
:param is_short: trade direction
:param open_date: The date and time that the trade started
:param close_date: The date and time that the trade ended
:param time_in_ratio: Not used by most exchange classes
"""
fees: float = 0
if not df.empty:
df1 = df[(df['date'] >= open_date) & (df['date'] <= close_date)]
fees = sum(df1['open_fund'] * df1['open_mark'] * amount)
# Negate fees for longs as funding_fees expects it this way based on live endpoints.
return fees if is_short else -fees
def get_funding_fees(
self, pair: str, amount: float, is_short: bool, open_date: datetime) -> float:
"""
Fetch funding fees, either from the exchange (live) or calculates them
based on funding rate/mark price history
:param pair: The quote/base pair of the trade
:param is_short: trade direction
:param amount: Trade amount
:param open_date: Open date of the trade
:return: funding fee since open_date
"""
if self.trading_mode == TradingMode.FUTURES:
try:
if self._config['dry_run']:
funding_fees = self._fetch_and_calculate_funding_fees(
pair, amount, is_short, open_date)
else:
funding_fees = self._get_funding_fees_from_exchange(pair, open_date)
return funding_fees
except ExchangeError:
logger.warning(f"Could not update funding fees for {pair}.")
return 0.0
def get_liquidation_price(
self,
pair: str,
# Dry-run
open_rate: float, # Entry price of position
is_short: bool,
amount: float, # Absolute value of position size
stake_amount: float,
leverage: float,
wallet_balance: float,
mm_ex_1: float = 0.0, # (Binance) Cross only
upnl_ex_1: float = 0.0, # (Binance) Cross only
) -> Optional[float]:
"""
Set's the margin mode on the exchange to cross or isolated for a specific pair
"""
if self.trading_mode == TradingMode.SPOT:
return None
elif (self.trading_mode != TradingMode.FUTURES):
raise OperationalException(
f"{self.name} does not support {self.margin_mode} {self.trading_mode}")
liquidation_price = None
if self._config['dry_run'] or not self.exchange_has("fetchPositions"):
liquidation_price = self.dry_run_liquidation_price(
pair=pair,
open_rate=open_rate,
is_short=is_short,
amount=amount,
leverage=leverage,
stake_amount=stake_amount,
wallet_balance=wallet_balance,
mm_ex_1=mm_ex_1,
upnl_ex_1=upnl_ex_1
)
else:
positions = self.fetch_positions(pair)
if len(positions) > 0:
pos = positions[0]
liquidation_price = pos['liquidationPrice']
if liquidation_price is not None:
buffer_amount = abs(open_rate - liquidation_price) * self.liquidation_buffer
liquidation_price_buffer = (
liquidation_price - buffer_amount
if is_short else
liquidation_price + buffer_amount
)
return max(liquidation_price_buffer, 0.0)
else:
return None
def dry_run_liquidation_price(
self,
pair: str,
open_rate: float, # Entry price of position
is_short: bool,
amount: float,
stake_amount: float,
leverage: float,
wallet_balance: float, # Or margin balance
mm_ex_1: float = 0.0, # (Binance) Cross only
upnl_ex_1: float = 0.0, # (Binance) Cross only
) -> Optional[float]:
"""
Important: Must be fetching data from cached values as this is used by backtesting!
PERPETUAL:
gate: https://www.gate.io/help/futures/futures/27724/liquidation-price-bankruptcy-price
> Liquidation Price = (Entry Price ± Margin / Contract Multiplier / Size) /
[ 1 ± (Maintenance Margin Ratio + Taker Rate)]
Wherein, "+" or "-" depends on whether the contract goes long or short:
"-" for long, and "+" for short.
okex: https://www.okex.com/support/hc/en-us/articles/
360053909592-VI-Introduction-to-the-isolated-mode-of-Single-Multi-currency-Portfolio-margin
:param pair: Pair to calculate liquidation price for
:param open_rate: Entry price of position
:param is_short: True if the trade is a short, false otherwise
:param amount: Absolute value of position size incl. leverage (in base currency)
:param stake_amount: Stake amount - Collateral in settle currency.
:param leverage: Leverage used for this position.
:param trading_mode: SPOT, MARGIN, FUTURES, etc.
:param margin_mode: Either ISOLATED or CROSS
:param wallet_balance: Amount of margin_mode in the wallet being used to trade
Cross-Margin Mode: crossWalletBalance
Isolated-Margin Mode: isolatedWalletBalance
# * Not required by Gate or OKX
:param mm_ex_1:
:param upnl_ex_1:
"""
market = self.markets[pair]
taker_fee_rate = market['taker']
mm_ratio, _ = self.get_maintenance_ratio_and_amt(pair, stake_amount)
if self.trading_mode == TradingMode.FUTURES and self.margin_mode == MarginMode.ISOLATED:
if market['inverse']:
raise OperationalException(
"Freqtrade does not yet support inverse contracts")
value = wallet_balance / amount
mm_ratio_taker = (mm_ratio + taker_fee_rate)
if is_short:
return (open_rate + value) / (1 + mm_ratio_taker)
else:
return (open_rate - value) / (1 - mm_ratio_taker)
else:
raise OperationalException(
"Freqtrade only supports isolated futures for leverage trading")
def get_maintenance_ratio_and_amt(
self,
pair: str,
nominal_value: float,
) -> Tuple[float, Optional[float]]:
"""
Important: Must be fetching data from cached values as this is used by backtesting!
:param pair: Market symbol
:param nominal_value: The total trade amount in quote currency including leverage
maintenance amount only on Binance
:return: (maintenance margin ratio, maintenance amount)
"""
| if (self._config.get('runmode') in OPTIMIZE_MODES | 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,698 | 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(
"The bare Bert Model transformer outputting raw hidden-states without any specific head on top.",
BERT_START_DOCSTRING,
)
class BertModel(BertPreTrainedModel):
"""
The model can behave as an encoder (with only self-attention) as well
as a decoder, in which case a layer of cross-attention is added between
the self-attention layers, following the architecture described in `Attention is all you need`_ by Ashish Vaswani,
Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
To behave as an decoder the model needs to be initialized with the
:obj:`is_decoder` argument of the configuration set to :obj:`True`; an
:obj:`encoder_hidden_states` is expected as an input to the forward pass.
.. _`Attention is all you need`:
https://arxiv.org/abs/1706.03762
"""
def __init__(self, config):
super().__init__(config)
self.config = config
self.embeddings = BertEmbeddings(config)
self.encoder = BertEncoder(config)
self.pooler = BertPooler(config)
self.init_weights()
def get_input_embeddings(self):
return self.embeddings.word_embeddings
def set_input_embeddings(self, value):
self.embeddings.word_embeddings = value
def _prune_heads(self, heads_to_prune):
""" Prunes heads of the model.
heads_to_prune: dict of {layer_num: list of heads to prune in this layer}
See base class PreTrainedModel
"""
for layer, heads in heads_to_prune.items():
self.encoder.layer[layer].attention.prune_heads(heads)
| # 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(
"The bare Bert Model transformer outputting raw hidden-states without any specific head on top.",
BERT_START_DOCSTRING,
)
class BertModel(BertPreTrainedModel):
"""
The model can behave as an encoder (with only self-attention) as well
as a decoder, in which case a layer of cross-attention is added between
the self-attention layers, following the architecture described in `Attention is all you need`_ by Ashish Vaswani,
Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
To behave as an decoder the model needs to be initialized with the
:obj:`is_decoder` argument of the configuration set to :obj:`True`; an
:obj:`encoder_hidden_states` is expected as an input to the forward pass.
.. _`Attention is all you need`:
https://arxiv.org/abs/1706.03762
"""
def __init__(self, config):
super().__init__(config)
self.config = config
self.embeddings = BertEmbeddings(config)
self.encoder = BertEncoder(config)
self.pooler = BertPooler(config)
self.init_weights()
def get_input_embeddings(self):
return self.embeddings.word_embeddings
def set_input_embeddings(self, value):
self.embeddings.word_embeddings = value
def _prune_heads(self, heads_to_prune):
""" Prunes heads of the model.
heads_to_prune: dict of {layer_num: list of heads to prune in this layer}
See base class PreTrainedModel
"""
for layer, heads in heads_to_prune.items():
self.encoder.layer[layer].attention.prune_heads(heads)
| @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING) | 3 | 2023-10-15 02:31:09+00:00 | 24k |
akashgreninja/GreSec | backend/venv/lib/python3.10/site-packages/numpy/array_api/linalg.py | [
{
"identifier": "_floating_dtypes",
"path": "backend/venv/lib/python3.10/site-packages/numpy/array_api/_dtypes.py",
"snippet": "def _result_type(type1, type2):"
},
{
"identifier": "reshape",
"path": "backend/venv/lib/python3.10/site-packages/numpy/array_api/_manipulation_functions.py",
"... | from ._dtypes import (
_floating_dtypes,
_numeric_dtypes,
float32,
float64,
complex64,
complex128
)
from ._manipulation_functions import reshape
from ._array_object import Array
from ..core.numeric import normalize_axis_tuple
from typing import TYPE_CHECKING
from ._typing import Literal, Optional, Sequence, Tuple, Union, Dtype
from typing import NamedTuple
from ..linalg.linalg import (_makearray, _assert_stacked_2d,
_assert_stacked_square, _commonType,
isComplexType, get_linalg_error_extobj,
_raise_linalgerror_singular)
from ..linalg import _umath_linalg
import numpy.linalg
import numpy as np | 14,859 | """
Array API compatible wrapper for :py:func:`np.linalg.qr <numpy.linalg.qr>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.qr.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in qr')
# Note: the return type here is a namedtuple, which is different from
# np.linalg.qr, which only returns a tuple.
return QRResult(*map(Array._new, np.linalg.qr(x._array, mode=mode)))
def slogdet(x: Array, /) -> SlogdetResult:
"""
Array API compatible wrapper for :py:func:`np.linalg.slogdet <numpy.linalg.slogdet>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.slogdet.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in slogdet')
# Note: the return type here is a namedtuple, which is different from
# np.linalg.slogdet, which only returns a tuple.
return SlogdetResult(*map(Array._new, np.linalg.slogdet(x._array)))
# Note: unlike np.linalg.solve, the array API solve() only accepts x2 as a
# vector when it is exactly 1-dimensional. All other cases treat x2 as a stack
# of matrices. The np.linalg.solve behavior of allowing stacks of both
# matrices and vectors is ambiguous c.f.
# https://github.com/numpy/numpy/issues/15349 and
# https://github.com/data-apis/array-api/issues/285.
# To workaround this, the below is the code from np.linalg.solve except
# only calling solve1 in the exactly 1D case.
def _solve(a, b):
a, _ = _makearray(a)
_assert_stacked_2d(a)
_assert_stacked_square(a)
b, wrap = _makearray(b)
t, result_t = _commonType(a, b)
# This part is different from np.linalg.solve
if b.ndim == 1:
gufunc = _umath_linalg.solve1
else:
gufunc = _umath_linalg.solve
# This does nothing currently but is left in because it will be relevant
# when complex dtype support is added to the spec in 2022.
signature = 'DD->D' if isComplexType(t) else 'dd->d'
extobj = get_linalg_error_extobj(_raise_linalgerror_singular)
r = gufunc(a, b, signature=signature, extobj=extobj)
return wrap(r.astype(result_t, copy=False))
def solve(x1: Array, x2: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.linalg.solve <numpy.linalg.solve>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.solve.
if x1.dtype not in _floating_dtypes or x2.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in solve')
return Array._new(_solve(x1._array, x2._array))
def svd(x: Array, /, *, full_matrices: bool = True) -> SVDResult:
"""
Array API compatible wrapper for :py:func:`np.linalg.svd <numpy.linalg.svd>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.svd.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in svd')
# Note: the return type here is a namedtuple, which is different from
# np.svd, which only returns a tuple.
return SVDResult(*map(Array._new, np.linalg.svd(x._array, full_matrices=full_matrices)))
# Note: svdvals is not in NumPy (but it is in SciPy). It is equivalent to
# np.linalg.svd(compute_uv=False).
def svdvals(x: Array, /) -> Union[Array, Tuple[Array, ...]]:
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in svdvals')
return Array._new(np.linalg.svd(x._array, compute_uv=False))
# Note: tensordot is the numpy top-level namespace but not in np.linalg
# Note: axes must be a tuple, unlike np.tensordot where it can be an array or array-like.
def tensordot(x1: Array, x2: Array, /, *, axes: Union[int, Tuple[Sequence[int], Sequence[int]]] = 2) -> Array:
# Note: the restriction to numeric dtypes only is different from
# np.tensordot.
if x1.dtype not in _numeric_dtypes or x2.dtype not in _numeric_dtypes:
raise TypeError('Only numeric dtypes are allowed in tensordot')
return Array._new(np.tensordot(x1._array, x2._array, axes=axes))
# Note: trace is the numpy top-level namespace, not np.linalg
def trace(x: Array, /, *, offset: int = 0, dtype: Optional[Dtype] = None) -> Array:
"""
Array API compatible wrapper for :py:func:`np.trace <numpy.trace>`.
See its docstring for more information.
"""
if x.dtype not in _numeric_dtypes:
raise TypeError('Only numeric dtypes are allowed in trace')
# Note: trace() works the same as sum() and prod() (see
# _statistical_functions.py)
if dtype is None:
if x.dtype == float32:
| from __future__ import annotations
if TYPE_CHECKING:
class EighResult(NamedTuple):
eigenvalues: Array
eigenvectors: Array
class QRResult(NamedTuple):
Q: Array
R: Array
class SlogdetResult(NamedTuple):
sign: Array
logabsdet: Array
class SVDResult(NamedTuple):
U: Array
S: Array
Vh: Array
# Note: the inclusion of the upper keyword is different from
# np.linalg.cholesky, which does not have it.
def cholesky(x: Array, /, *, upper: bool = False) -> Array:
"""
Array API compatible wrapper for :py:func:`np.linalg.cholesky <numpy.linalg.cholesky>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.cholesky.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in cholesky')
L = np.linalg.cholesky(x._array)
if upper:
return Array._new(L).mT
return Array._new(L)
# Note: cross is the numpy top-level namespace, not np.linalg
def cross(x1: Array, x2: Array, /, *, axis: int = -1) -> Array:
"""
Array API compatible wrapper for :py:func:`np.cross <numpy.cross>`.
See its docstring for more information.
"""
if x1.dtype not in _numeric_dtypes or x2.dtype not in _numeric_dtypes:
raise TypeError('Only numeric dtypes are allowed in cross')
# Note: this is different from np.cross(), which broadcasts
if x1.shape != x2.shape:
raise ValueError('x1 and x2 must have the same shape')
if x1.ndim == 0:
raise ValueError('cross() requires arrays of dimension at least 1')
# Note: this is different from np.cross(), which allows dimension 2
if x1.shape[axis] != 3:
raise ValueError('cross() dimension must equal 3')
return Array._new(np.cross(x1._array, x2._array, axis=axis))
def det(x: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.linalg.det <numpy.linalg.det>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.det.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in det')
return Array._new(np.linalg.det(x._array))
# Note: diagonal is the numpy top-level namespace, not np.linalg
def diagonal(x: Array, /, *, offset: int = 0) -> Array:
"""
Array API compatible wrapper for :py:func:`np.diagonal <numpy.diagonal>`.
See its docstring for more information.
"""
# Note: diagonal always operates on the last two axes, whereas np.diagonal
# operates on the first two axes by default
return Array._new(np.diagonal(x._array, offset=offset, axis1=-2, axis2=-1))
def eigh(x: Array, /) -> EighResult:
"""
Array API compatible wrapper for :py:func:`np.linalg.eigh <numpy.linalg.eigh>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.eigh.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in eigh')
# Note: the return type here is a namedtuple, which is different from
# np.eigh, which only returns a tuple.
return EighResult(*map(Array._new, np.linalg.eigh(x._array)))
def eigvalsh(x: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.linalg.eigvalsh <numpy.linalg.eigvalsh>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.eigvalsh.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in eigvalsh')
return Array._new(np.linalg.eigvalsh(x._array))
def inv(x: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.linalg.inv <numpy.linalg.inv>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.inv.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in inv')
return Array._new(np.linalg.inv(x._array))
# Note: matmul is the numpy top-level namespace but not in np.linalg
def matmul(x1: Array, x2: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.matmul <numpy.matmul>`.
See its docstring for more information.
"""
# Note: the restriction to numeric dtypes only is different from
# np.matmul.
if x1.dtype not in _numeric_dtypes or x2.dtype not in _numeric_dtypes:
raise TypeError('Only numeric dtypes are allowed in matmul')
return Array._new(np.matmul(x1._array, x2._array))
# Note: the name here is different from norm(). The array API norm is split
# into matrix_norm and vector_norm().
# The type for ord should be Optional[Union[int, float, Literal[np.inf,
# -np.inf, 'fro', 'nuc']]], but Literal does not support floating-point
# literals.
def matrix_norm(x: Array, /, *, keepdims: bool = False, ord: Optional[Union[int, float, Literal['fro', 'nuc']]] = 'fro') -> Array:
"""
Array API compatible wrapper for :py:func:`np.linalg.norm <numpy.linalg.norm>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.norm.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in matrix_norm')
return Array._new(np.linalg.norm(x._array, axis=(-2, -1), keepdims=keepdims, ord=ord))
def matrix_power(x: Array, n: int, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.matrix_power <numpy.matrix_power>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.matrix_power.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed for the first argument of matrix_power')
# np.matrix_power already checks if n is an integer
return Array._new(np.linalg.matrix_power(x._array, n))
# Note: the keyword argument name rtol is different from np.linalg.matrix_rank
def matrix_rank(x: Array, /, *, rtol: Optional[Union[float, Array]] = None) -> Array:
"""
Array API compatible wrapper for :py:func:`np.matrix_rank <numpy.matrix_rank>`.
See its docstring for more information.
"""
# Note: this is different from np.linalg.matrix_rank, which supports 1
# dimensional arrays.
if x.ndim < 2:
raise np.linalg.LinAlgError("1-dimensional array given. Array must be at least two-dimensional")
S = np.linalg.svd(x._array, compute_uv=False)
if rtol is None:
tol = S.max(axis=-1, keepdims=True) * max(x.shape[-2:]) * np.finfo(S.dtype).eps
else:
if isinstance(rtol, Array):
rtol = rtol._array
# Note: this is different from np.linalg.matrix_rank, which does not multiply
# the tolerance by the largest singular value.
tol = S.max(axis=-1, keepdims=True)*np.asarray(rtol)[..., np.newaxis]
return Array._new(np.count_nonzero(S > tol, axis=-1))
# Note: this function is new in the array API spec. Unlike transpose, it only
# transposes the last two axes.
def matrix_transpose(x: Array, /) -> Array:
if x.ndim < 2:
raise ValueError("x must be at least 2-dimensional for matrix_transpose")
return Array._new(np.swapaxes(x._array, -1, -2))
# Note: outer is the numpy top-level namespace, not np.linalg
def outer(x1: Array, x2: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.outer <numpy.outer>`.
See its docstring for more information.
"""
# Note: the restriction to numeric dtypes only is different from
# np.outer.
if x1.dtype not in _numeric_dtypes or x2.dtype not in _numeric_dtypes:
raise TypeError('Only numeric dtypes are allowed in outer')
# Note: the restriction to only 1-dim arrays is different from np.outer
if x1.ndim != 1 or x2.ndim != 1:
raise ValueError('The input arrays to outer must be 1-dimensional')
return Array._new(np.outer(x1._array, x2._array))
# Note: the keyword argument name rtol is different from np.linalg.pinv
def pinv(x: Array, /, *, rtol: Optional[Union[float, Array]] = None) -> Array:
"""
Array API compatible wrapper for :py:func:`np.linalg.pinv <numpy.linalg.pinv>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.pinv.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in pinv')
# Note: this is different from np.linalg.pinv, which does not multiply the
# default tolerance by max(M, N).
if rtol is None:
rtol = max(x.shape[-2:]) * np.finfo(x.dtype).eps
return Array._new(np.linalg.pinv(x._array, rcond=rtol))
def qr(x: Array, /, *, mode: Literal['reduced', 'complete'] = 'reduced') -> QRResult:
"""
Array API compatible wrapper for :py:func:`np.linalg.qr <numpy.linalg.qr>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.qr.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in qr')
# Note: the return type here is a namedtuple, which is different from
# np.linalg.qr, which only returns a tuple.
return QRResult(*map(Array._new, np.linalg.qr(x._array, mode=mode)))
def slogdet(x: Array, /) -> SlogdetResult:
"""
Array API compatible wrapper for :py:func:`np.linalg.slogdet <numpy.linalg.slogdet>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.slogdet.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in slogdet')
# Note: the return type here is a namedtuple, which is different from
# np.linalg.slogdet, which only returns a tuple.
return SlogdetResult(*map(Array._new, np.linalg.slogdet(x._array)))
# Note: unlike np.linalg.solve, the array API solve() only accepts x2 as a
# vector when it is exactly 1-dimensional. All other cases treat x2 as a stack
# of matrices. The np.linalg.solve behavior of allowing stacks of both
# matrices and vectors is ambiguous c.f.
# https://github.com/numpy/numpy/issues/15349 and
# https://github.com/data-apis/array-api/issues/285.
# To workaround this, the below is the code from np.linalg.solve except
# only calling solve1 in the exactly 1D case.
def _solve(a, b):
a, _ = _makearray(a)
_assert_stacked_2d(a)
_assert_stacked_square(a)
b, wrap = _makearray(b)
t, result_t = _commonType(a, b)
# This part is different from np.linalg.solve
if b.ndim == 1:
gufunc = _umath_linalg.solve1
else:
gufunc = _umath_linalg.solve
# This does nothing currently but is left in because it will be relevant
# when complex dtype support is added to the spec in 2022.
signature = 'DD->D' if isComplexType(t) else 'dd->d'
extobj = get_linalg_error_extobj(_raise_linalgerror_singular)
r = gufunc(a, b, signature=signature, extobj=extobj)
return wrap(r.astype(result_t, copy=False))
def solve(x1: Array, x2: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.linalg.solve <numpy.linalg.solve>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.solve.
if x1.dtype not in _floating_dtypes or x2.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in solve')
return Array._new(_solve(x1._array, x2._array))
def svd(x: Array, /, *, full_matrices: bool = True) -> SVDResult:
"""
Array API compatible wrapper for :py:func:`np.linalg.svd <numpy.linalg.svd>`.
See its docstring for more information.
"""
# Note: the restriction to floating-point dtypes only is different from
# np.linalg.svd.
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in svd')
# Note: the return type here is a namedtuple, which is different from
# np.svd, which only returns a tuple.
return SVDResult(*map(Array._new, np.linalg.svd(x._array, full_matrices=full_matrices)))
# Note: svdvals is not in NumPy (but it is in SciPy). It is equivalent to
# np.linalg.svd(compute_uv=False).
def svdvals(x: Array, /) -> Union[Array, Tuple[Array, ...]]:
if x.dtype not in _floating_dtypes:
raise TypeError('Only floating-point dtypes are allowed in svdvals')
return Array._new(np.linalg.svd(x._array, compute_uv=False))
# Note: tensordot is the numpy top-level namespace but not in np.linalg
# Note: axes must be a tuple, unlike np.tensordot where it can be an array or array-like.
def tensordot(x1: Array, x2: Array, /, *, axes: Union[int, Tuple[Sequence[int], Sequence[int]]] = 2) -> Array:
# Note: the restriction to numeric dtypes only is different from
# np.tensordot.
if x1.dtype not in _numeric_dtypes or x2.dtype not in _numeric_dtypes:
raise TypeError('Only numeric dtypes are allowed in tensordot')
return Array._new(np.tensordot(x1._array, x2._array, axes=axes))
# Note: trace is the numpy top-level namespace, not np.linalg
def trace(x: Array, /, *, offset: int = 0, dtype: Optional[Dtype] = None) -> Array:
"""
Array API compatible wrapper for :py:func:`np.trace <numpy.trace>`.
See its docstring for more information.
"""
if x.dtype not in _numeric_dtypes:
raise TypeError('Only numeric dtypes are allowed in trace')
# Note: trace() works the same as sum() and prod() (see
# _statistical_functions.py)
if dtype is None:
if x.dtype == float32: | dtype = float64 | 0 | 2023-10-23 18:09:28+00:00 | 24k |
zju3dv/nr_in_a_room | test/batch_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 ... | from posix import listdir
from PIL import Image
from tqdm import tqdm
from omegaconf import OmegaConf
from optim.room_optimizer import RoomOptimizer
from optim.misc_utils import read_testing_config
from utils.util import list_dir, read_json
import sys
import os
import torch
import numpy as np
import os.path as osp | 14,890 | 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,
# )
# 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()
# room_optimizer.generate_relation()
# room_optimizer.optimize(input_rgb)
return room_optimizer
def main(config):
scene_name = config["scene_name"]
pred_src_dir = config["pred_src_dir"]
pred_src_scene_dir = osp.join("data/object_prediction", pred_src_dir, scene_name)
print("Using prediction from", pred_src_scene_dir)
# currently only support multi_lights
multi_case_dirs = list_dir(pred_src_scene_dir)
print("Find cases", multi_case_dirs)
# prepare room optimizer and backup config
room_optimizer = prepare_room_optimizer(
config,
f"data/{scene_name}/scene/full/data.json", # also load scene info json,
# which can be an empty placeholder in the future
)
config["optimize_option"] = room_optimizer.optimize_option
OmegaConf.save(
config=config,
f=os.path.join(room_optimizer.output_path, "optim_config_full.json"),
)
output_path_base = room_optimizer.output_path
for curr_case in tqdm(multi_case_dirs):
items = list_dir(osp.join(pred_src_scene_dir, curr_case))
for item in tqdm(items):
item_dir = osp.join(pred_src_scene_dir, curr_case, item)
print("Working on", item_dir)
pred_json = osp.join(item_dir, "pred.json")
active_instance_id = list(map(int, list(read_json(pred_json).keys())))
active_instance_id = [x for x in active_instance_id if x > 0]
active_instance_id += [0]
# reset optimizer state
room_optimizer.reset_active_instance_id(active_instance_id)
room_optimizer.reset_optimizable_parameters()
room_optimizer.set_output_path(
output_path_base, f"{curr_case}/{item}", with_timestamp=False
)
src_item_dir = (
# f"data/{scene_name}/scene_multi_lights/{curr_case}/{item}/"
f"data/{scene_name}/scene_custom_arrange_multi_lights/{curr_case}/{item}/"
)
# TODO: seg should be provided by object detector
# seg_mask_path = f"{src_item_dir}/seg.png"
seg_mask_path = osp.join(item_dir, "seg.png")
room_optimizer.set_sampling_mask_from_seg(
seg_mask_path=seg_mask_path,
add_noise_to_seg=5, # dilate mask
convert_seg_mask_to_box_mask=False,
)
room_optimizer.set_initial_pose_from_prediction(pred_json)
room_optimizer.generate_relation()
image_path = f"{src_item_dir}/rgb.png"
print(image_path)
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)
pose = np.array(
read_json(f"{src_item_dir}/data.json")["camera"]["cam3d2world"]
).reshape(4, 4)
room_optimizer.optimize(input_rgb, pose=pose)
if __name__ == "__main__":
"""
Usage:
python test/batch_optim_pano.py config=test/config/ig_bedroom.yml "img_wh=[320,180]" pred_src_dir=DeepPano_wo_relation prefix=dbg_bedroom_batch
"""
|
os.environ["OMP_NUM_THREADS"] = "1" # noqa
os.environ["MKL_NUM_THREADS"] = "1" # noqa
sys.path.append(".") # noqa
def prepare_room_optimizer(config, scene_info_json_path):
active_instance_id = config.active_instance_id
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"]
# intialize room optimizer
room_optimizer = RoomOptimizer(
scene_info_json_path=scene_info_json_path,
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,
use_light_from_image_attr=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,
# )
# 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()
# room_optimizer.generate_relation()
# room_optimizer.optimize(input_rgb)
return room_optimizer
def main(config):
scene_name = config["scene_name"]
pred_src_dir = config["pred_src_dir"]
pred_src_scene_dir = osp.join("data/object_prediction", pred_src_dir, scene_name)
print("Using prediction from", pred_src_scene_dir)
# currently only support multi_lights
multi_case_dirs = list_dir(pred_src_scene_dir)
print("Find cases", multi_case_dirs)
# prepare room optimizer and backup config
room_optimizer = prepare_room_optimizer(
config,
f"data/{scene_name}/scene/full/data.json", # also load scene info json,
# which can be an empty placeholder in the future
)
config["optimize_option"] = room_optimizer.optimize_option
OmegaConf.save(
config=config,
f=os.path.join(room_optimizer.output_path, "optim_config_full.json"),
)
output_path_base = room_optimizer.output_path
for curr_case in tqdm(multi_case_dirs):
items = list_dir(osp.join(pred_src_scene_dir, curr_case))
for item in tqdm(items):
item_dir = osp.join(pred_src_scene_dir, curr_case, item)
print("Working on", item_dir)
pred_json = osp.join(item_dir, "pred.json")
active_instance_id = list(map(int, list(read_json(pred_json).keys())))
active_instance_id = [x for x in active_instance_id if x > 0]
active_instance_id += [0]
# reset optimizer state
room_optimizer.reset_active_instance_id(active_instance_id)
room_optimizer.reset_optimizable_parameters()
room_optimizer.set_output_path(
output_path_base, f"{curr_case}/{item}", with_timestamp=False
)
src_item_dir = (
# f"data/{scene_name}/scene_multi_lights/{curr_case}/{item}/"
f"data/{scene_name}/scene_custom_arrange_multi_lights/{curr_case}/{item}/"
)
# TODO: seg should be provided by object detector
# seg_mask_path = f"{src_item_dir}/seg.png"
seg_mask_path = osp.join(item_dir, "seg.png")
room_optimizer.set_sampling_mask_from_seg(
seg_mask_path=seg_mask_path,
add_noise_to_seg=5, # dilate mask
convert_seg_mask_to_box_mask=False,
)
room_optimizer.set_initial_pose_from_prediction(pred_json)
room_optimizer.generate_relation()
image_path = f"{src_item_dir}/rgb.png"
print(image_path)
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)
pose = np.array(
read_json(f"{src_item_dir}/data.json")["camera"]["cam3d2world"]
).reshape(4, 4)
room_optimizer.optimize(input_rgb, pose=pose)
if __name__ == "__main__":
"""
Usage:
python test/batch_optim_pano.py config=test/config/ig_bedroom.yml "img_wh=[320,180]" pred_src_dir=DeepPano_wo_relation prefix=dbg_bedroom_batch
""" | config = read_testing_config() | 1 | 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,411 |
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])
elif training_args.action_type == "non_integer":
if training_args.add_mention_end:
num_new_tokens = tokenizer.add_tokens([SPEAKER_START, SPEAKER_END,
MENTION_START, MENTION_END,
COPY,
CLUSTER_NEW] +
CLUSTERS)
else:
num_new_tokens = tokenizer.add_tokens([SPEAKER_START, SPEAKER_END,
MENTION_START, COPY,
CLUSTER_NEW] +
MENTION_ENDS)
else:
raise ValueError(f"wrong action type {training_args.action_type}")
if training_args.seq2seq_type == 'short_seq' and \
training_args.mark_sentence:
|
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])
elif training_args.action_type == "non_integer":
if training_args.add_mention_end:
num_new_tokens = tokenizer.add_tokens([SPEAKER_START, SPEAKER_END,
MENTION_START, MENTION_END,
COPY,
CLUSTER_NEW] +
CLUSTERS)
else:
num_new_tokens = tokenizer.add_tokens([SPEAKER_START, SPEAKER_END,
MENTION_START, COPY,
CLUSTER_NEW] +
MENTION_ENDS)
else:
raise ValueError(f"wrong action type {training_args.action_type}")
if training_args.seq2seq_type == 'short_seq' and \
training_args.mark_sentence: | num_new_tokens += tokenizer.add_tokens([SENTENCE_START, SENTENCE_END]) | 13 | 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 | 15,005 | )
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):
this_sample_dir = os.path.join(
self.sample_dir,
"iter_{}_host_{}".format(step, jax.host_id()),
)
tf.io.gfile.makedirs(this_sample_dir)
# code below to show the gif of the sampled images
# processed_images = []
# for n in range(batch_sampled_all.shape[1]):
# batch_sampled_i = batch_sampled_all[:, n, :, :, :]
# batch_sampled_i = ds_train.postprocess_fn(
# batch_data=batch_sampled_i, inverse_scaler=inverse_scaler
# )
# processed_images.append(np.asarray(batch_sampled_i))
#
# # Log the sampled images as a GIF
# imageio.mimwrite(
# os.path.join(this_sample_dir, "image_sequence.gif"),
# processed_images,
# fps=10,
# )
# gif_wandb = wandb.Image(
# os.path.join(this_sample_dir, "image_sequence.gif"),
# caption="Sampled_all_gif",
# )
# wandb.log({"Sampled_all_gif": gif_wandb}, step=step)
batch_sampled = ds_train.postprocess_fn(batch_data=batch_sampled, inverse_scaler=inverse_scaler)
batch_sampled_last = ds_train.postprocess_fn(
batch_data=batch_sampled_last, inverse_scaler=inverse_scaler
)
batch_real = ds_train.postprocess_fn(
batch_data=batch.reshape(-1, b, g, c), inverse_scaler=inverse_scaler
)
if not self.training_config.sampling_only:
batch_target = ds_train.postprocess_fn(
batch_data=target.reshape(-1, b, g, c), inverse_scaler=inverse_scaler
)
if isinstance(ds_train, ImageDataset):
data_sampled = wandb.Image(np.asarray(batch_sampled), caption="Sampled")
data_sampled_rec = wandb.Image(np.asarray(batch_sampled_last), caption="Sampled Rec")
data_real = wandb.Image(np.asarray(batch_real), caption="Real")
if not self.training_config.sampling_only:
data_target = wandb.Image(np.asarray(batch_target), caption="Target")
elif isinstance(ds_train, AudioDataset):
sample_rate = ds_train.data_config.audio_sample_rate
long_audio_sampled = np.concatenate(
np.asarray(batch_sampled).reshape(-1, sample_rate), axis=0
)
data_sampled = wandb.Audio(long_audio_sampled, sample_rate=sample_rate, caption="Sampled")
if not self.training_config.sampling_only:
long_audio_target = np.concatenate(
np.asarray(batch_target).reshape(-1, sample_rate), axis=0
)
data_target = wandb.Audio(long_audio_target, sample_rate=sample_rate, caption="Target")
long_audio_batch_sampled_rec = np.concatenate(
np.asarray(batch_sampled_last).reshape(-1, sample_rate), axis=0
)
data_sampled_rec = wandb.Audio(
long_audio_batch_sampled_rec, sample_rate=sample_rate, caption="Sampled Rec"
)
long_audio_batch_real = np.concatenate(
np.asarray(batch_real).reshape(-1, sample_rate), axis=0
)
data_real = wandb.Audio(long_audio_batch_real, sample_rate=sample_rate, caption="Real")
else:
raise ValueError("Unsupported dataset type: {}".format(type(ds_train)))
wandb.log({"Sampled": data_sampled}, step=step)
if not self.training_config.sampling_only:
wandb.log({"Target": data_target}, step=step)
wandb.log({"Sampled_rec": data_sampled_rec}, step=step)
wandb.log({"Real": data_real}, step=step)
if self.training_config.sampling_type == "colorization":
batch_gray = make_grid_image(
batch_grayscale.reshape(
-1,
ds_train.data_config.image_width_size,
ds_train.data_config.image_height_size,
1,
),
inverse_scaler=inverse_scaler,
)
image_gray = wandb.Image(np.asarray(batch_gray), caption="Gray")
wandb.log({"Gray": image_gray}, step=step)
elif self.training_config.sampling_type == "inpainting":
batch_masked = make_grid_image(
|
# 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):
this_sample_dir = os.path.join(
self.sample_dir,
"iter_{}_host_{}".format(step, jax.host_id()),
)
tf.io.gfile.makedirs(this_sample_dir)
# code below to show the gif of the sampled images
# processed_images = []
# for n in range(batch_sampled_all.shape[1]):
# batch_sampled_i = batch_sampled_all[:, n, :, :, :]
# batch_sampled_i = ds_train.postprocess_fn(
# batch_data=batch_sampled_i, inverse_scaler=inverse_scaler
# )
# processed_images.append(np.asarray(batch_sampled_i))
#
# # Log the sampled images as a GIF
# imageio.mimwrite(
# os.path.join(this_sample_dir, "image_sequence.gif"),
# processed_images,
# fps=10,
# )
# gif_wandb = wandb.Image(
# os.path.join(this_sample_dir, "image_sequence.gif"),
# caption="Sampled_all_gif",
# )
# wandb.log({"Sampled_all_gif": gif_wandb}, step=step)
batch_sampled = ds_train.postprocess_fn(batch_data=batch_sampled, inverse_scaler=inverse_scaler)
batch_sampled_last = ds_train.postprocess_fn(
batch_data=batch_sampled_last, inverse_scaler=inverse_scaler
)
batch_real = ds_train.postprocess_fn(
batch_data=batch.reshape(-1, b, g, c), inverse_scaler=inverse_scaler
)
if not self.training_config.sampling_only:
batch_target = ds_train.postprocess_fn(
batch_data=target.reshape(-1, b, g, c), inverse_scaler=inverse_scaler
)
if isinstance(ds_train, ImageDataset):
data_sampled = wandb.Image(np.asarray(batch_sampled), caption="Sampled")
data_sampled_rec = wandb.Image(np.asarray(batch_sampled_last), caption="Sampled Rec")
data_real = wandb.Image(np.asarray(batch_real), caption="Real")
if not self.training_config.sampling_only:
data_target = wandb.Image(np.asarray(batch_target), caption="Target")
elif isinstance(ds_train, AudioDataset):
sample_rate = ds_train.data_config.audio_sample_rate
long_audio_sampled = np.concatenate(
np.asarray(batch_sampled).reshape(-1, sample_rate), axis=0
)
data_sampled = wandb.Audio(long_audio_sampled, sample_rate=sample_rate, caption="Sampled")
if not self.training_config.sampling_only:
long_audio_target = np.concatenate(
np.asarray(batch_target).reshape(-1, sample_rate), axis=0
)
data_target = wandb.Audio(long_audio_target, sample_rate=sample_rate, caption="Target")
long_audio_batch_sampled_rec = np.concatenate(
np.asarray(batch_sampled_last).reshape(-1, sample_rate), axis=0
)
data_sampled_rec = wandb.Audio(
long_audio_batch_sampled_rec, sample_rate=sample_rate, caption="Sampled Rec"
)
long_audio_batch_real = np.concatenate(
np.asarray(batch_real).reshape(-1, sample_rate), axis=0
)
data_real = wandb.Audio(long_audio_batch_real, sample_rate=sample_rate, caption="Real")
else:
raise ValueError("Unsupported dataset type: {}".format(type(ds_train)))
wandb.log({"Sampled": data_sampled}, step=step)
if not self.training_config.sampling_only:
wandb.log({"Target": data_target}, step=step)
wandb.log({"Sampled_rec": data_sampled_rec}, step=step)
wandb.log({"Real": data_real}, step=step)
if self.training_config.sampling_type == "colorization":
batch_gray = make_grid_image(
batch_grayscale.reshape(
-1,
ds_train.data_config.image_width_size,
ds_train.data_config.image_height_size,
1,
),
inverse_scaler=inverse_scaler,
)
image_gray = wandb.Image(np.asarray(batch_gray), caption="Gray")
wandb.log({"Gray": image_gray}, step=step)
elif self.training_config.sampling_type == "inpainting":
batch_masked = make_grid_image( | ndarray=process_images(images=batch_masked * batch - (1 - batch_masked)), | 9 | 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,621 |
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):
| 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) | 8 | 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,578 | 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,
out_dim=self.base_units,
downsample_scale=initial_downsample_scale,
num_conv_layers=initial_downsample_conv_layers,
padding_type=padding_type,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
self.initial_aux_encoder = InitialEncoder(dim=self.auxiliary_channels,
out_dim=self.base_units,
downsample_scale=initial_downsample_scale,
num_conv_layers=initial_downsample_conv_layers,
padding_type=padding_type,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
self.final_decoder = FinalDecoder(dim=self.base_units,
target_thw=(T_out, H_out, W_out),
num_conv_layers=final_upsample_conv_layers,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
new_input_shape = self.initial_encoder.patch_merge.get_out_shape(self.input_shape)
self.dec_final_proj = nn.Linear(self.base_units, C_out)
elif self.initial_downsample_type == "stack_conv":
if initial_downsample_stack_conv_dim_list is None:
initial_downsample_stack_conv_dim_list = [self.base_units, ] * initial_downsample_stack_conv_num_layers
self.initial_encoder = InitialStackPatchMergingEncoder(
num_merge=initial_downsample_stack_conv_num_layers,
in_dim=C_in,
out_dim_list=initial_downsample_stack_conv_dim_list,
downsample_scale_list=initial_downsample_stack_conv_downscale_list,
num_conv_per_merge_list=initial_downsample_stack_conv_num_conv_list,
padding_type=padding_type,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
self.initial_aux_encoder = InitialStackPatchMergingEncoder(
num_merge=initial_downsample_stack_conv_num_layers,
in_dim=self.auxiliary_channels,
out_dim_list=initial_downsample_stack_conv_dim_list,
downsample_scale_list=initial_downsample_stack_conv_downscale_list,
num_conv_per_merge_list=initial_downsample_stack_conv_num_conv_list,
padding_type=padding_type,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
# use `self.target_shape` to get correct T_out
initial_encoder_out_shape_list = self.initial_encoder.get_out_shape_list(self.target_shape)
dec_target_shape_list, dec_in_dim = \
| """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,
out_dim=self.base_units,
downsample_scale=initial_downsample_scale,
num_conv_layers=initial_downsample_conv_layers,
padding_type=padding_type,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
self.initial_aux_encoder = InitialEncoder(dim=self.auxiliary_channels,
out_dim=self.base_units,
downsample_scale=initial_downsample_scale,
num_conv_layers=initial_downsample_conv_layers,
padding_type=padding_type,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
self.final_decoder = FinalDecoder(dim=self.base_units,
target_thw=(T_out, H_out, W_out),
num_conv_layers=final_upsample_conv_layers,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
new_input_shape = self.initial_encoder.patch_merge.get_out_shape(self.input_shape)
self.dec_final_proj = nn.Linear(self.base_units, C_out)
elif self.initial_downsample_type == "stack_conv":
if initial_downsample_stack_conv_dim_list is None:
initial_downsample_stack_conv_dim_list = [self.base_units, ] * initial_downsample_stack_conv_num_layers
self.initial_encoder = InitialStackPatchMergingEncoder(
num_merge=initial_downsample_stack_conv_num_layers,
in_dim=C_in,
out_dim_list=initial_downsample_stack_conv_dim_list,
downsample_scale_list=initial_downsample_stack_conv_downscale_list,
num_conv_per_merge_list=initial_downsample_stack_conv_num_conv_list,
padding_type=padding_type,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
self.initial_aux_encoder = InitialStackPatchMergingEncoder(
num_merge=initial_downsample_stack_conv_num_layers,
in_dim=self.auxiliary_channels,
out_dim_list=initial_downsample_stack_conv_dim_list,
downsample_scale_list=initial_downsample_stack_conv_downscale_list,
num_conv_per_merge_list=initial_downsample_stack_conv_num_conv_list,
padding_type=padding_type,
activation=activation,
conv_init_mode=self.conv_init_mode,
linear_init_mode=self.down_up_linear_init_mode,
norm_init_mode=self.norm_init_mode)
# use `self.target_shape` to get correct T_out
initial_encoder_out_shape_list = self.initial_encoder.get_out_shape_list(self.target_shape)
dec_target_shape_list, dec_in_dim = \ | FinalStackUpsamplingDecoder.get_init_params( | 6 | 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,786 | return x.reshape(len(x), *([1] * len(x_start.shape[1:])))
# Set up model mode
backdoor_model = backdoor_model.train()
clean_model = clean_model.eval()
alphas = noise_sched.alphas.to(device=x_start.device, dtype=x_start.dtype)
betas = noise_sched.betas.to(device=x_start.device, dtype=x_start.dtype)
timesteps = torch.clamp(timesteps, max=timesteps_num - backprop_depth - 1).to(x_start.device)
if adaptive_score_loss.alphas_cumprod_derivative == None:
alpha_fn, beta_fn = get_alpha_beta_fn_linear(beta_start=float(betas[0]), beta_end=float(betas[-1]), timesteps=float(len(betas)))
adaptive_score_loss.alphas_cumprod_derivative = get_alphas_cumprod_derivative(alphas=alphas, alpha_fn=alpha_fn).to(device=x_start.device, dtype=x_start.dtype)
adaptive_score_loss.alphas_cumprod = noise_sched.alphas_cumprod.to(device=x_start.device, dtype=x_start.dtype)
# adaptive_score_loss.alphas_cumprod = prod_integral(xs=alphas, x_fn=alpha_fn).to(device=x_start.device, dtype=x_start.dtype)
alphas_cumprod_derivative = adaptive_score_loss.alphas_cumprod_derivative
alphas_cumprod = adaptive_score_loss.alphas_cumprod
def ode_x_k_t(model: torch.nn.Module, xs: torch.Tensor, rs: torch.Tensor, k: int, ts: torch.Tensor, f_func, h_func, g_square_func, sigma_func, delta: float=1e-6) -> torch.Tensor:
# with torch.no_grad():
if k == 0:
return xs
prev_ode_x_k_t: torch.Tensor = ode_x_k_t(model=model, xs=xs, rs=rs, k=k - 1, ts=ts - 1, f_func=f_func, h_func=h_func, g_square_func=g_square_func, sigma_func=sigma_func)
pred = model(prev_ode_x_k_t.contiguous(), (ts - 1).contiguous(), return_dict=False)[0]
if torch.isnan(xs).any():
print(f"[{k}] xs: Nan")
if torch.isnan(pred).any():
print(f"[{k}] ode pred: Nan")
if torch.isnan(prev_ode_x_k_t).any():
print(f"[{k}] prev_ode_x_k_t: Nan")
return prev_ode_x_k_t - (f_func[k] * prev_ode_x_k_t + h_func[k] * rs + g_square_func[k] / (2 * sigma_func[k] + delta) * pred)
def sde_x_k_t(model: torch.nn.Module, xs: torch.Tensor, rs: torch.Tensor, k: int, u: float, ts: torch.Tensor, f_func, h_func, g_square_func, sigma_func, rand: bool=True, delta: float=1e-6) -> torch.Tensor:
if k == 0:
return xs
prev_sde_x_k_t: torch.Tensor = sde_x_k_t(model=model, xs=xs, rs=rs, k=k - 1, u=u, ts=ts - 1, f_func=f_func, h_func=h_func, g_square_func=g_square_func, sigma_func=sigma_func, rand=True)
pred = model(prev_sde_x_k_t.contiguous(), (ts - 1).contiguous(), return_dict=True)[0]
if torch.isnan(xs).any():
print(f"[{k}] xs: Nan")
if torch.isnan(pred).any():
print(f"[{k}] sde pred: Nan")
if torch.isnan(prev_sde_x_k_t).any():
print(f"[{k}] prev_sde_x_k_t: Nan")
if rand:
return prev_sde_x_k_t - (f_func[k] * prev_sde_x_k_t + g_square_func[k] * (u + 1) / (2 * sigma_func[k] + delta) * pred + torch.sqrt(g_square_func[k]) * u * torch.randn_like(xs))
else:
return prev_sde_x_k_t - (f_func[k] * prev_sde_x_k_t + g_square_func[k] * (u + 1) / (2 * sigma_func[k] + delta) * pred)
def func_t_dict_gen(func: torch.Tensor, k: int, timesteps: torch.Tensor):
funcs: Dict[int, torch.Tensor] = {}
for i in range(1, k + 1):
funcs[k - i + 1] = unqueeze_n(func[timesteps + i])
return funcs
# Functions used in the expansion
f_func= 1 / (2 * alphas_cumprod) * alphas_cumprod_derivative
# g_square_func = - alphas_cumprod_derivative
g_square_func = - alphas_cumprod_derivative / alphas_cumprod
sigma_func = torch.sqrt(1 - alphas_cumprod)
h_func = - psi * (alphas_cumprod_derivative / (2 * torch.sqrt(alphas_cumprod))) - (1 - psi) * (alphas_cumprod_derivative / (2 * torch.sqrt(1 - alphas_cumprod)))
# print(f"sigma_func min: {sigma_func.min()}")
if torch.isnan(f_func).any():
print(f"f_func: Nan")
if torch.isnan(g_square_func).any():
print(f"g_square_func: Nan")
if torch.isnan(sigma_func).any():
print(f"sigma_func: Nan")
if torch.isnan(h_func).any():
print(f"h_func: Nan")
f_func_dict = func_t_dict_gen(f_func, k=backprop_depth, timesteps=timesteps)
g_square_func_dict = func_t_dict_gen(g_square_func, k=backprop_depth, timesteps=timesteps)
sigma_func_dict = func_t_dict_gen(sigma_func, k=backprop_depth, timesteps=timesteps)
h_func_dict = func_t_dict_gen(h_func, k=backprop_depth, timesteps=timesteps)
# ODE ground truth and SDE prediction
x_noisy = noise_sched.add_noise(x_start, noise, timesteps + backprop_depth)
target_x_k_t = ode_x_k_t(model=clean_model, xs=x_noisy, rs=R, k=backprop_depth, ts=timesteps, f_func=f_func_dict, h_func=h_func_dict, g_square_func=g_square_func_dict, sigma_func=sigma_func_dict)
pred_x_k_t = sde_x_k_t(model=backdoor_model, xs=x_noisy, rs=R, k=backprop_depth, u=1, ts=timesteps, f_func=f_func_dict, h_func=h_func_dict, g_square_func=g_square_func_dict, sigma_func=sigma_func_dict, rand=False)
if torch.isnan(x_start).any():
print(f"x_start: Nan")
if torch.isnan(R).any():
print(f"R: Nan")
if torch.isnan(target_x_k_t).any():
print(f"target_x_k_t: Nan")
if torch.isnan(pred_x_k_t).any():
print(f"pred_x_k_t: Nan")
if loss_type == 'l1':
loss = F.l1_loss(target_x_k_t, pred_x_k_t)
elif loss_type == 'l2':
loss = F.mse_loss(target_x_k_t, pred_x_k_t)
if torch.isnan(loss):
print(f"loss: Nan")
elif loss_type == "huber":
loss = F.smooth_l1_loss(target_x_k_t, pred_x_k_t)
else:
raise NotImplementedError()
return loss
adaptive_score_loss.alphas_cumprod_derivative = None
adaptive_score_loss.alphas_cumprod = None
# %%
if __name__ == '__main__':
time_step = 95
num_train_timesteps = 100
# time_step = 140
# num_train_timesteps = 150
ds_root = os.path.join('datasets')
| # %%
# 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:
if device == None:
device = noise_sched.alphas.device
if dtype == None:
dtype = noise_sched.alphas.dtype
alphas: torch.Tensor = noise_sched.alphas.to(device=device, dtype=dtype)
alphas_cumprod: torch.Tensor = noise_sched.alphas_cumprod.to(device=device, dtype=dtype)
# hs
if get_R_coef_elbo_gen.hs_vp == None:
get_R_coef_elbo_gen.hs_vp = get_hs_vp(alphas=alphas, alphas_cumprod=alphas_cumprod)
hs: torch.Tensors = get_R_coef_elbo_gen.hs_vp.to(device=device, dtype=dtype)
step, R_coef = get_R_coef_gen_vp(alphas_cumprod=alphas_cumprod, alphas=alphas, hs=hs, psi=psi, solver_type=solver_type, vp_scale=vp_scale, ve_scale=ve_scale)
elif sde_type == DiffuserModelSched.SDE_VE:
if device == None:
device = noise_sched.sigmas.device
if dtype == None:
dtype = noise_sched.sigmas.dtype
sigmas: torch.Tensor = noise_sched.sigmas.to(device=device, dtype=dtype).flip(dims=[0])
rhos_hat: torch.Tensor = rhos_hat_w * sigmas + rhos_hat_b
# ws
if get_R_coef_elbo_gen.ws_ve == None:
get_R_coef_elbo_gen.ws_ve = get_ws_ve(sigmas=sigmas)
ws: torch.Tensor = get_R_coef_elbo_gen.ws_ve.to(device=device, dtype=dtype)
# print(f"sigmas: {sigmas}")
# print(f"sigmas isnan: {torch.isnan(sigmas).any()}: {torch.isnan(sigmas)}")
# print(f"ws isnan: {torch.isnan(ws).any()}: {torch.isnan(ws)}")
# hs
if get_R_coef_elbo_gen.hs_ve == None:
get_R_coef_elbo_gen.hs_ve = get_hs_ve(rhos_hat=rhos_hat)
hs: torch.Tensor = get_R_coef_elbo_gen.hs_ve.to(device=device, dtype=dtype)
# print(f"hs isnan: {torch.isnan(hs).any()}: {torch.isnan(hs)}")
step, R_coef = get_R_coef_gen_ve(sigmas=sigmas, rhos_hat=rhos_hat, ws=ws, hs=hs, psi=psi, solver_type=solver_type, vp_scale=vp_scale, ve_scale=ve_scale)
# R_coef = - R_coef / sigmas
step, R_coef = step.flip(dims=[0]), R_coef.flip(dims=[0])
# print(f"step: {torch.isnan(step).any()}, Min: {step.min()}, Max: {step.max()}: {step}")
# print(f"R_coef: {torch.isnan(R_coef).any()}, Min: {R_coef.min()}, Max: {R_coef.max()}: {R_coef}")
else:
raise NotImplementedError(f"sde_type: {sde_type} isn't implemented")
return step, R_coef
get_R_coef_elbo_gen.hs_vp: torch.Tensor = None
get_R_coef_elbo_gen.ws_ve: torch.Tensor = None
get_R_coef_elbo_gen.hs_ve: torch.Tensor = None
def get_R_coef_continuous(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):
# Variance Preserve
vp_step = 1 - alphas_cumprod ** 0.5
vp_coef = vp_scale * (1 - alphas_cumprod) ** 0.5 / (1 - alphas_cumprod)
# Variance Explode
if psi != 1:
if hs == None:
raise ValueError(f"Arhuement hs shouldn't be {hs} when psi is {psi}")
ve_step = (1 - alphas_cumprod) ** 0.5
ve_coef = ve_scale * 0.5
# Coefficients & Steps
step = psi * vp_step + (1 - psi) * ve_step
coef = psi * vp_coef + (1 - psi) * ve_coef
else:
# Coefficients & Steps
step = vp_step
coef = vp_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 q_sample_diffuser_alt(noise_sched, sde_type: str, x_start: torch.Tensor,
R: torch.Tensor, timesteps: torch.Tensor, noise: 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]:
if noise is None:
noise = torch.randn_like(x_start)
def unqueeze_n(x):
return x.reshape(len(x_start), *([1] * len(x_start.shape[1:])))
# alphas = noise_sched.alphas.to(device=x_start.device, dtype=x_start.dtype)
# betas = noise_sched.betas.to(device=x_start.device, dtype=x_start.dtype)
timesteps = timesteps.to(x_start.device)
# Alphas Cumprod
# if q_sample_diffuser_alt.alphas_cumprod == None:
# alpha_fn, beta_fn = get_alpha_beta_fn_linear(beta_start=float(betas[0]), beta_end=float(betas[-1]), timesteps=float(len(betas)))
# q_sample_diffuser_alt.alphas_cumprod = prod_integral(xs=alphas, x_fn=alpha_fn).to(device=x_start.device, dtype=x_start.dtype)
# alphas_cumprod = q_sample_diffuser_alt.alphas_cumprod
# alphas_cumprod = noise_sched.alphas_cumprod.to(device=x_start.device, dtype=x_start.dtype)
# sqrt_alphas_cumprod = alphas_cumprod ** 0.5
# hs
# if q_sample_diffuser_alt.hs == None:
# q_sample_diffuser_alt.hs = get_hs_vp(alphas=alphas, alphas_cumprod=alphas_cumprod)
# hs = q_sample_diffuser_alt.hs.to(device=x_start.device, dtype=x_start.dtype)
# BadDiffusion
# R_coef = (1 - alphas ** 0.5) * (1 - alphas_cumprod) ** 0.5 / (1 - alphas)
step, R_coef = get_R_coef_elbo_gen(noise_sched=noise_sched, sde_type=sde_type, psi=psi, solver_type=solver_type, vp_scale=vp_scale, ve_scale=ve_scale, device=x_start.device, dtype=x_start.dtype)
# step, R_coef = get_R_coef_gen_vp(alphas_cumprod=alphas_cumprod, alphas=alphas, hs=hs, psi=psi, solver_type=solver_type, vp_scale=vp_scale, ve_scale=ve_scale)
# step, R_coef = get_R_coef_continuous(alphas_cumprod=alphas_cumprod, alphas=alphas, hs=hs, psi=psi, solver_type=solver_type, vp_scale=vp_scale, ve_scale=ve_scale)
# plot(R_coef, title="R Coef Discrete")
# Generalized
# alpha_fn, beta_fn = get_alpha_beta_fn_linear(beta_start=float(betas[0]), beta_end=float(betas[-1]), timesteps=float(len(betas)))
# R_coef = get_R_coef_alt(alphas_cumprod=alphas_cumprod, alphas=alphas, alpha_fn=alpha_fn, psi=psi, solver_type=solver_type)
# plot(R_coef, title="R Coef Continuous")
# Unsqueeze & Select
R_coef_t = unqueeze_n(R_coef[timesteps])
step_t = unqueeze_n(step[timesteps])
if sde_type == DiffuserModelSched.SDE_VP or sde_type == DiffuserModelSched.SDE_LDM:
noisy_images = noise_sched.add_noise(x_start, noise, timesteps)
return noisy_images + step_t * R, R_coef_t * R + noise
elif sde_type == DiffuserModelSched.SDE_VE:
sigma_t = unqueeze_n(noise_sched.sigmas.to(timesteps.device)[timesteps])
noisy_images = x_start + sigma_t * noise
# noisy_images = x_start
print(f"noisy_images: {noisy_images.shape}, {torch.isnan(noisy_images).any()}, Min: {noisy_images.min()}, Max: {noisy_images.max()}")
print(f"R: {torch.isnan(R).any()}, Min: {R.min()}, Max: {R.max()}")
print(f"sigma_t: {sigma_t.shape}, {torch.isnan(sigma_t).any()}, Min: {sigma_t.min()}, Max: {sigma_t.max()}")
# return noisy_images + step_t * R, - (R_coef_t * R + noise) / sigma_t
# return noisy_images, - (noise) / sigma_t
return noisy_images, noise
else:
raise NotImplementedError(f"sde_type: {sde_type} isn't implemented")
q_sample_diffuser_alt.alphas_cumprod = None
q_sample_diffuser_alt.hs = None
def q_sample_diffuser(noise_sched, x_start: torch.Tensor, R: torch.Tensor, timesteps: torch.Tensor, noise: torch.Tensor=None) -> torch.Tensor:
if noise is None:
noise = torch.randn_like(x_start)
def unqueeze_n(x):
return x.reshape(len(x_start), *([1] * len(x_start.shape[1:])))
alphas_cumprod = noise_sched.alphas_cumprod.to(device=x_start.device, dtype=x_start.dtype)
alphas = noise_sched.alphas.to(device=x_start.device, dtype=x_start.dtype)
betas = noise_sched.betas.to(device=x_start.device, dtype=x_start.dtype)
timesteps = timesteps.to(x_start.device)
sqrt_alphas_cumprod_t = alphas_cumprod[timesteps] ** 0.5
sqrt_one_minus_alphas_cumprod_t = (1 - alphas_cumprod[timesteps]) ** 0.5
R_coef_t = (1 - alphas[timesteps] ** 0.5) * sqrt_one_minus_alphas_cumprod_t / (1 - alphas[timesteps])
sqrt_alphas_cumprod_t = unqueeze_n(sqrt_alphas_cumprod_t)
# NOTE: BadDiffusion
# R_coef = (1 - alphas ** 0.5) * (1 - alphas_cumprod) ** 0.5 / (1 - alphas)
# plot(R_coef, title="R Coef", log_scale=True)
R_coef_t = unqueeze_n(R_coef_t)
noisy_images = noise_sched.add_noise(x_start, noise, timesteps)
# if q_sample_diffuser.R_coef == None:
# # NOTE: Generalized BadDiffusion
# alpha_fn, beta_fn = get_alpha_beta_fn_linear(beta_start=float(betas[0]), beta_end=float(betas[-1]), timesteps=float(len(betas)))
# # q_sample_diffuser.R_coef = torch.flip(get_R_coef(alphas_cumprod=alphas_cumprod, alphas=alphas, alpha_fn=alpha_fn, psi=1), dims=(0,))
# q_sample_diffuser.R_coef = get_R_coef_alt(alphas_cumprod=alphas_cumprod, alphas=alphas, alpha_fn=alpha_fn, psi=1).float()
# R_coef_t = unqueeze_n(q_sample_diffuser.R_coef[timesteps])
# # plot(q_sample_diffuser.R_coef, title="R Coef", log_scale=True)
# if torch.isnan(R_coef_t).any():
# print(f"Nan: {timesteps[torch.isnan(R_coef_t).nonzero()]}")
return noisy_images + (1 - sqrt_alphas_cumprod_t) * R, R_coef_t * R + noise
q_sample_diffuser.R_coef = None
def p_losses_diffuser(noise_sched, model: nn.Module, sde_type: str, x_start: torch.Tensor, R: torch.Tensor, timesteps: torch.Tensor, noise: torch.Tensor=None, loss_type: str="l2", psi: float=1, solver_type: str="sde", vp_scale: float=1.0, ve_scale: float=1.0) -> torch.Tensor:
if len(x_start) == 0:
return 0
if noise is None:
noise = torch.randn_like(x_start)
noise = noise.clamp(-2, 2)
def unqueeze_n(x):
return x.reshape(len(x_start), *([1] * len(x_start.shape[1:])))
# if sde_type == DiffuserModelSched.SDE_VE:
# x_start = x_start / 2 + 0.5
# R = R / 2 + 0.5
# Main loss function
x_noisy, target = q_sample_diffuser_alt(noise_sched=noise_sched, sde_type=sde_type, x_start=x_start, R=R, timesteps=timesteps, noise=noise, psi=psi, solver_type=solver_type, vp_scale=vp_scale, ve_scale=ve_scale)
# Additiolnal loss function
# x_noisy_half, target_half = q_sample_diffuser_alt_half(noise_sched=noise_sched, x_start=x_start, R=R, timesteps=timesteps, noise=noise)
# predicted_noise_half = model(x_noisy_half.contiguous(), timesteps.contiguous(), return_dict=False)[0]
if sde_type == DiffuserModelSched.SDE_VP or sde_type == DiffuserModelSched.SDE_LDM:
predicted_noise = model(x_noisy.contiguous(), timesteps.contiguous(), return_dict=False)[0]
print(f"x_noisy: {x_noisy.shape}, {torch.isnan(x_noisy).any()}, min: {x_noisy.min()}, max: {x_noisy.max()}")
print(f"predicted_noise: {predicted_noise.shape}, {torch.isnan(predicted_noise).any()}, min: {predicted_noise.min()}, max: {predicted_noise.max()}")
if loss_type == 'l1':
loss: torch.Tensor = F.l1_loss(target, predicted_noise, reduction='none')
elif loss_type == 'l2':
loss = F.mse_loss(target, predicted_noise, reduction='none')
elif loss_type == "huber":
loss = F.smooth_l1_loss(target, predicted_noise, reduction='none')
else:
raise NotImplementedError()
return loss.mean()
elif sde_type == DiffuserModelSched.SDE_VE:
sigma_t = noise_sched.sigmas.unsqueeze(0).to(timesteps.device)[timesteps]
predicted_noise = model(x_noisy.contiguous(), sigma_t.contiguous(), return_dict=False)[0]
print(f"x_noisy: {x_noisy.shape}, {torch.isnan(x_noisy).any()}, min: {x_noisy.min()}, max: {x_noisy.max()}")
print(f"predicted_noise: {predicted_noise.shape}, {torch.isnan(predicted_noise).any()}, min: {predicted_noise.min()}, max: {predicted_noise.max()}")
if loss_type == 'l1':
loss: torch.Tensor = 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 * unqueeze_n(noise_sched.sigmas.to(timesteps.device)[timesteps]) ** 2).mean()
return loss
else:
raise NotImplementedError(f"sde_type: {sde_type} isn't implemented")
class LossFn:
RANDN_BOUND: float = 2.5
def __init__(self, noise_sched, sde_type: str, loss_type: str="l2", psi: float=1, solver_type: str="sde", vp_scale: float=1.0, ve_scale: float=1.0, rhos_hat_w: float=1.0, rhos_hat_b: float=0.0):
self.__noise_sched = noise_sched
if sde_type == DiffuserModelSched.SDE_VP or sde_type == DiffuserModelSched.SDE_LDM:
self.__alphas: torch.Tensor = self.__noise_sched.alphas
self.__alphas_cumprod: torch.Tensor = self.__noise_sched.alphas_cumprod
self.__betas: torch.Tensor = self.__noise_sched.betas
if sde_type == DiffuserModelSched.SDE_VE:
self.__sigmas: torch.Tensor = self.__noise_sched.sigmas.flip([0])
self.__sde_type = sde_type
self.__loss_type = loss_type
self.__psi = psi
self.__solver_type = solver_type
self.__vp_scale = vp_scale
self.__ve_scale = ve_scale
self.__rhos_hat_w = rhos_hat_w
self.__rhos_hat_b = rhos_hat_b
self.__hs_vp: torch.Tensor = None
self.__ws_ve: torch.Tensor = None
self.__hs_ve: torch.Tensor = None
def __norm(self):
reduction = 'none'
if self.__loss_type == 'l1':
return partial(F.l1_loss, reduction=reduction)
elif self.__loss_type == 'l2':
return partial(F.mse_loss, reduction=reduction)
elif self.__loss_type == "huber":
return partial(F.smooth_l1_loss, reduction=reduction)
else:
raise NotImplementedError()
def __get_R_step_coef(self, device=None, dtype=None):
if self.__sde_type == DiffuserModelSched.SDE_VP or self.__sde_type == DiffuserModelSched.SDE_LDM:
if device == None:
device = self.__alphas.device
if dtype == None:
dtype = self.__alphas.dtype
alphas: torch.Tensor = self.__alphas.to(device=device, dtype=dtype)
alphas_cumprod: torch.Tensor = self.__alphas_cumprod.to(device=device, dtype=dtype)
betas: torch.Tensor = self.__betas.to(device=device, dtype=dtype)
# hs
if self.__hs_vp == None:
self.__hs_vp = get_hs_vp(alphas=alphas, alphas_cumprod=alphas_cumprod)
hs: torch.Tensors = self.__hs_vp.to(device=device, dtype=dtype)
step, R_coef = get_R_coef_gen_vp(alphas_cumprod=alphas_cumprod, alphas=alphas, hs=hs, psi=self.__psi, solver_type=self.__solver_type, vp_scale=self.__vp_scale, ve_scale=self.__ve_scale)
elif self.__sde_type == DiffuserModelSched.SDE_VE:
if device == None:
device = self.__sigmas.device
if dtype == None:
dtype = self.__sigmas.dtype
sigmas: torch.Tensor = self.__sigmas.to(device=device, dtype=dtype)
rhos_hat: torch.Tensor = self.__rhos_hat_w * sigmas + self.__rhos_hat_b
# ws
if self.__ws_ve == None:
self.__ws_ve = get_ws_ve(sigmas=sigmas)
ws: torch.Tensor = self.__ws_ve.to(device=device, dtype=dtype)
# print(f"sigmas: {sigmas}")
# print(f"sigmas isnan: {torch.isnan(sigmas).any()}: {torch.isnan(sigmas)}")
# print(f"ws isnan: {torch.isnan(ws).any()}: {torch.isnan(ws)}")
# hs
if self.__hs_ve == None:
self.__hs_ve = get_hs_ve(rhos_hat=rhos_hat)
hs: torch.Tensor = self.__hs_ve.to(device=device, dtype=dtype)
# print(f"hs isnan: {torch.isnan(hs).any()}: {torch.isnan(hs)}")
# step, R_coef = get_R_coef_gen_ve(sigmas=sigmas, rhos_hat=rhos_hat, ws=ws, hs=hs, psi=self.__psi, solver_type=self.__solver_type, vp_scale=self.__vp_scale, ve_scale=self.__ve_scale)
step, R_coef = get_R_coef_gen_ve_reduce(sigmas=sigmas, hs=hs, rhos_hat_w=self.__rhos_hat_w, psi=self.__psi, solver_type=self.__solver_type, vp_scale=self.__vp_scale, ve_scale=self.__ve_scale)
# print(f"step: {torch.isnan(step).any()}, Min: {step.min()}, Max: {step.max()}: {step}")
# print(f"R_coef: {torch.isnan(R_coef).any()}, Min: {R_coef.min()}, Max: {R_coef.max()}: {R_coef}")
else:
raise NotImplementedError(f"sde_type: {self.__sde_type} isn't implemented")
return step, R_coef
def __get_inputs_targets(self, x_start: torch.Tensor, R: torch.Tensor, timesteps: torch.Tensor, noise: torch.Tensor):
# if noise is None:
# noise = torch.randn_like(x_start)
def unqueeze_n(x):
return x.reshape(len(x_start), *([1] * len(x_start.shape[1:])))
timesteps = timesteps.to(x_start.device)
step, R_coef = self.__get_R_step_coef(device=x_start.device, dtype=x_start.dtype)
# Unsqueeze & Select
R_coef_t = unqueeze_n(R_coef[timesteps])
step_t = unqueeze_n(step[timesteps])
if self.__sde_type == DiffuserModelSched.SDE_VP or self.__sde_type == DiffuserModelSched.SDE_LDM:
noisy_images = self.__noise_sched.add_noise(x_start, noise, timesteps)
return noisy_images + step_t * R, R_coef_t * R + noise
elif self.__sde_type == DiffuserModelSched.SDE_VE:
sigma_t = unqueeze_n(self.__sigmas.to(timesteps.device)[timesteps])
noisy_images = x_start + sigma_t * noise
# noisy_images = x_start
# print(f"step_t: {step_t.shape}, Min: {step_t.min()}, Max: {step_t.max()}")
# print(f"R_coef_t: {R_coef_t.shape}, Min: {R_coef_t.min()}, Max: {R_coef_t.max()}")
return noisy_images + step_t * R, R_coef_t * R + noise
# print(f"noisy_images: {noisy_images.shape}, {torch.isnan(noisy_images).any()}, Min: {noisy_images.min()}, Max: {noisy_images.max()}")
# print(f"R: {torch.isnan(R).any()}, Min: {R.min()}, Max: {R.max()}")
# No likelihood_weighting
# return noisy_images, noise
else:
raise NotImplementedError(f"sde_type: {self.__sde_type} isn't implemented")
@staticmethod
def __encode_latents(vae, x: torch.Tensor, weight_dtype: str=None, scaling_factor: float=None):
vae = vae.eval()
with torch.no_grad():
x = x.to(vae.device)
if weight_dtype != None and weight_dtype != "":
x = x.to(dtype=weight_dtype)
if scaling_factor != None:
return (vae.encode(x).latents * scaling_factor).clone().detach()
# return vae.encode(x).latents * vae.config.scaling_factor
return vae.encode(x).latents.clone().detach()
@staticmethod
def __decode_latents(vae, x: torch.Tensor, weight_dtype: str=None, scaling_factor: float=None):
vae = vae.eval()
with torch.no_grad():
x = x.to(vae.device)
if weight_dtype != None and weight_dtype != "":
x = x.to(dtype=weight_dtype)
if scaling_factor != None:
return (vae.decode(x).sample / scaling_factor).clone().detach()
# return vae.decode(x).sample / vae.config.scaling_factor
return (vae.decode(x).sample).clone().detach()
@staticmethod
def __get_latent(batch, key: str, vae=None, weight_dtype: str=None, scaling_factor: float=None) -> torch.Tensor:
if vae == None:
return batch[key]
return LossFn.__encode_latents(vae=vae, x=batch[key], weight_dtype=weight_dtype, scaling_factor=scaling_factor)
@staticmethod
def __get_latents(batch, keys: List[str], vae=None, weight_dtype: str=None, scaling_factor: float=None) -> List[torch.Tensor]:
return [LossFn.__get_latent(batch=batch, vae=vae, key=key, weight_dtype=weight_dtype, scaling_factor=scaling_factor) for key in keys]
def p_loss_by_keys(self, batch, model: nn.Module, target_latent_key: torch.Tensor, poison_latent_key: torch.Tensor,
timesteps: torch.Tensor, vae=None, noise: torch.Tensor=None, weight_dtype: str=None, scaling_factor: float=None) -> torch.Tensor:
target_latents, poison_latents = LossFn.__get_latents(batch=batch, keys=[target_latent_key, poison_latent_key], vae=vae, weight_dtype=weight_dtype, scaling_factor=scaling_factor)
return self.p_loss(model=model, x_start=target_latents, R=poison_latents, timesteps=timesteps, noise=noise)
def p_loss(self, model: nn.Module, x_start: torch.Tensor, R: torch.Tensor,
timesteps: torch.Tensor, noise: torch.Tensor=None) -> torch.Tensor:
if len(x_start) == 0:
return 0
if noise is None:
noise = torch.randn_like(x_start)
# noise = noise.clamp(-LossFn.RANDN_BOUND, LossFn.RANDN_BOUND)
def unqueeze_n(x):
return x.reshape(len(x_start), *([1] * len(x_start.shape[1:])))
# Main loss function
x_noisy, target = self.__get_inputs_targets(x_start=x_start, R=R, timesteps=timesteps, noise=noise)
if self.__sde_type == DiffuserModelSched.SDE_VP or self.__sde_type == DiffuserModelSched.SDE_LDM:
predicted_noise = model(x_noisy.contiguous(), timesteps.contiguous(), return_dict=False)[0]
loss: torch.Tensor = self.__norm()(target=target, input=predicted_noise)
return loss.mean()
elif self.__sde_type == DiffuserModelSched.SDE_VE:
sigmas_t: torch.Tensor = self.__sigmas.to(timesteps.device)[timesteps]
predicted_noise = model(x_noisy.contiguous(), sigmas_t.contiguous(), return_dict=False)[0]
# print(f"x_noisy: {x_noisy.shape}, {torch.isnan(x_noisy).any()}, min: {x_noisy.min()}, max: {x_noisy.max()}")
# print(f"predicted_noise: {predicted_noise.shape}, {torch.isnan(predicted_noise).any()}, min: {predicted_noise.min()}, max: {predicted_noise.max()}")
loss: torch.Tensor = self.__norm()(target=target, input=- predicted_noise * unqueeze_n(sigmas_t))
return loss.mean()
else:
raise NotImplementedError(f"sde_type: {self.__sde_type} isn't implemented")
def adaptive_score_loss(noise_sched, backdoor_model: nn.Module, clean_model: torch.nn.Module, x_start: torch.Tensor, R: torch.Tensor, timesteps: torch.Tensor, psi: float=0, noise: torch.Tensor=None, loss_type: str="l2", backprop_depth: int=2, timesteps_num: int=1000) -> torch.Tensor:
if timesteps_num - backprop_depth < 0:
raise ValueError(f"backprop_depth should <= timesteps_num")
if noise is None:
noise = torch.randn_like(x_start)
def unqueeze_n(x):
return x.reshape(len(x), *([1] * len(x_start.shape[1:])))
# Set up model mode
backdoor_model = backdoor_model.train()
clean_model = clean_model.eval()
alphas = noise_sched.alphas.to(device=x_start.device, dtype=x_start.dtype)
betas = noise_sched.betas.to(device=x_start.device, dtype=x_start.dtype)
timesteps = torch.clamp(timesteps, max=timesteps_num - backprop_depth - 1).to(x_start.device)
if adaptive_score_loss.alphas_cumprod_derivative == None:
alpha_fn, beta_fn = get_alpha_beta_fn_linear(beta_start=float(betas[0]), beta_end=float(betas[-1]), timesteps=float(len(betas)))
adaptive_score_loss.alphas_cumprod_derivative = get_alphas_cumprod_derivative(alphas=alphas, alpha_fn=alpha_fn).to(device=x_start.device, dtype=x_start.dtype)
adaptive_score_loss.alphas_cumprod = noise_sched.alphas_cumprod.to(device=x_start.device, dtype=x_start.dtype)
# adaptive_score_loss.alphas_cumprod = prod_integral(xs=alphas, x_fn=alpha_fn).to(device=x_start.device, dtype=x_start.dtype)
alphas_cumprod_derivative = adaptive_score_loss.alphas_cumprod_derivative
alphas_cumprod = adaptive_score_loss.alphas_cumprod
def ode_x_k_t(model: torch.nn.Module, xs: torch.Tensor, rs: torch.Tensor, k: int, ts: torch.Tensor, f_func, h_func, g_square_func, sigma_func, delta: float=1e-6) -> torch.Tensor:
# with torch.no_grad():
if k == 0:
return xs
prev_ode_x_k_t: torch.Tensor = ode_x_k_t(model=model, xs=xs, rs=rs, k=k - 1, ts=ts - 1, f_func=f_func, h_func=h_func, g_square_func=g_square_func, sigma_func=sigma_func)
pred = model(prev_ode_x_k_t.contiguous(), (ts - 1).contiguous(), return_dict=False)[0]
if torch.isnan(xs).any():
print(f"[{k}] xs: Nan")
if torch.isnan(pred).any():
print(f"[{k}] ode pred: Nan")
if torch.isnan(prev_ode_x_k_t).any():
print(f"[{k}] prev_ode_x_k_t: Nan")
return prev_ode_x_k_t - (f_func[k] * prev_ode_x_k_t + h_func[k] * rs + g_square_func[k] / (2 * sigma_func[k] + delta) * pred)
def sde_x_k_t(model: torch.nn.Module, xs: torch.Tensor, rs: torch.Tensor, k: int, u: float, ts: torch.Tensor, f_func, h_func, g_square_func, sigma_func, rand: bool=True, delta: float=1e-6) -> torch.Tensor:
if k == 0:
return xs
prev_sde_x_k_t: torch.Tensor = sde_x_k_t(model=model, xs=xs, rs=rs, k=k - 1, u=u, ts=ts - 1, f_func=f_func, h_func=h_func, g_square_func=g_square_func, sigma_func=sigma_func, rand=True)
pred = model(prev_sde_x_k_t.contiguous(), (ts - 1).contiguous(), return_dict=True)[0]
if torch.isnan(xs).any():
print(f"[{k}] xs: Nan")
if torch.isnan(pred).any():
print(f"[{k}] sde pred: Nan")
if torch.isnan(prev_sde_x_k_t).any():
print(f"[{k}] prev_sde_x_k_t: Nan")
if rand:
return prev_sde_x_k_t - (f_func[k] * prev_sde_x_k_t + g_square_func[k] * (u + 1) / (2 * sigma_func[k] + delta) * pred + torch.sqrt(g_square_func[k]) * u * torch.randn_like(xs))
else:
return prev_sde_x_k_t - (f_func[k] * prev_sde_x_k_t + g_square_func[k] * (u + 1) / (2 * sigma_func[k] + delta) * pred)
def func_t_dict_gen(func: torch.Tensor, k: int, timesteps: torch.Tensor):
funcs: Dict[int, torch.Tensor] = {}
for i in range(1, k + 1):
funcs[k - i + 1] = unqueeze_n(func[timesteps + i])
return funcs
# Functions used in the expansion
f_func= 1 / (2 * alphas_cumprod) * alphas_cumprod_derivative
# g_square_func = - alphas_cumprod_derivative
g_square_func = - alphas_cumprod_derivative / alphas_cumprod
sigma_func = torch.sqrt(1 - alphas_cumprod)
h_func = - psi * (alphas_cumprod_derivative / (2 * torch.sqrt(alphas_cumprod))) - (1 - psi) * (alphas_cumprod_derivative / (2 * torch.sqrt(1 - alphas_cumprod)))
# print(f"sigma_func min: {sigma_func.min()}")
if torch.isnan(f_func).any():
print(f"f_func: Nan")
if torch.isnan(g_square_func).any():
print(f"g_square_func: Nan")
if torch.isnan(sigma_func).any():
print(f"sigma_func: Nan")
if torch.isnan(h_func).any():
print(f"h_func: Nan")
f_func_dict = func_t_dict_gen(f_func, k=backprop_depth, timesteps=timesteps)
g_square_func_dict = func_t_dict_gen(g_square_func, k=backprop_depth, timesteps=timesteps)
sigma_func_dict = func_t_dict_gen(sigma_func, k=backprop_depth, timesteps=timesteps)
h_func_dict = func_t_dict_gen(h_func, k=backprop_depth, timesteps=timesteps)
# ODE ground truth and SDE prediction
x_noisy = noise_sched.add_noise(x_start, noise, timesteps + backprop_depth)
target_x_k_t = ode_x_k_t(model=clean_model, xs=x_noisy, rs=R, k=backprop_depth, ts=timesteps, f_func=f_func_dict, h_func=h_func_dict, g_square_func=g_square_func_dict, sigma_func=sigma_func_dict)
pred_x_k_t = sde_x_k_t(model=backdoor_model, xs=x_noisy, rs=R, k=backprop_depth, u=1, ts=timesteps, f_func=f_func_dict, h_func=h_func_dict, g_square_func=g_square_func_dict, sigma_func=sigma_func_dict, rand=False)
if torch.isnan(x_start).any():
print(f"x_start: Nan")
if torch.isnan(R).any():
print(f"R: Nan")
if torch.isnan(target_x_k_t).any():
print(f"target_x_k_t: Nan")
if torch.isnan(pred_x_k_t).any():
print(f"pred_x_k_t: Nan")
if loss_type == 'l1':
loss = F.l1_loss(target_x_k_t, pred_x_k_t)
elif loss_type == 'l2':
loss = F.mse_loss(target_x_k_t, pred_x_k_t)
if torch.isnan(loss):
print(f"loss: Nan")
elif loss_type == "huber":
loss = F.smooth_l1_loss(target_x_k_t, pred_x_k_t)
else:
raise NotImplementedError()
return loss
adaptive_score_loss.alphas_cumprod_derivative = None
adaptive_score_loss.alphas_cumprod = None
# %%
if __name__ == '__main__':
time_step = 95
num_train_timesteps = 100
# time_step = 140
# num_train_timesteps = 150
ds_root = os.path.join('datasets') | dsl = DatasetLoader(root=ds_root, name=DatasetLoader.CELEBA_HQ).set_poison(trigger_type=Backdoor.TRIGGER_GLASSES, target_type=Backdoor.TARGET_CAT, clean_rate=1, poison_rate=0.2).prepare_dataset() | 0 | 2023-10-17 19:57:37+00:00 | 24k |
nchen909/Pass-Tuning | evaluator/CodeBLEU/dataflow_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
import pdb
| 17,858 | # 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,
'ruby': DFG_ruby,
'go': DFG_go,
'php': DFG_php,
'javascript': DFG_javascript,
'c_sharp': DFG_csharp,
'c': DFG_c,
}
def calc_dataflow_match(references, candidate, lang):
return corpus_dataflow_match([references], [candidate], lang)
def corpus_dataflow_match(references, candidates, lang):
#LANGUAGE = Language('{}/my-languages.so'.format(parser_path), lang)
LANGUAGE = Language('build/my-languages.so', lang)
parser = Parser()
parser.set_language(LANGUAGE)
parser = [parser, dfg_function[lang]]
match_count = 0
total_count = 0
for i in range(len(candidates)):
references_sample = references[i]
candidate = candidates[i]
for reference in references_sample:
try:
candidate = remove_comments_and_docstrings(candidate, 'java')
except:
pass
try:
reference = remove_comments_and_docstrings(reference, 'java')
except:
pass
cand_dfg = get_data_flow(candidate, parser)
ref_dfg = get_data_flow(reference, parser)
normalized_cand_dfg = normalize_dataflow(cand_dfg)
normalized_ref_dfg = normalize_dataflow(ref_dfg)
if len(normalized_ref_dfg) > 0:
total_count += len(normalized_ref_dfg)
for dataflow in normalized_ref_dfg:
if dataflow in normalized_cand_dfg:
match_count += 1
normalized_cand_dfg.remove(dataflow)
if total_count == 0:
print(
"WARNING: There is no reference data-flows extracted from the whole corpus, and the data-flow match score degenerates to 0. Please consider ignoring this score.")
return 0
score = match_count / total_count
return score
def get_data_flow(code, parser):
try:
tree = parser[0].parse(bytes(code, 'utf8'))
root_node = tree.root_node
tokens_index = tree_to_token_index(root_node)
code = code.split('\n')
| # 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,
'ruby': DFG_ruby,
'go': DFG_go,
'php': DFG_php,
'javascript': DFG_javascript,
'c_sharp': DFG_csharp,
'c': DFG_c,
}
def calc_dataflow_match(references, candidate, lang):
return corpus_dataflow_match([references], [candidate], lang)
def corpus_dataflow_match(references, candidates, lang):
#LANGUAGE = Language('{}/my-languages.so'.format(parser_path), lang)
LANGUAGE = Language('build/my-languages.so', lang)
parser = Parser()
parser.set_language(LANGUAGE)
parser = [parser, dfg_function[lang]]
match_count = 0
total_count = 0
for i in range(len(candidates)):
references_sample = references[i]
candidate = candidates[i]
for reference in references_sample:
try:
candidate = remove_comments_and_docstrings(candidate, 'java')
except:
pass
try:
reference = remove_comments_and_docstrings(reference, 'java')
except:
pass
cand_dfg = get_data_flow(candidate, parser)
ref_dfg = get_data_flow(reference, parser)
normalized_cand_dfg = normalize_dataflow(cand_dfg)
normalized_ref_dfg = normalize_dataflow(ref_dfg)
if len(normalized_ref_dfg) > 0:
total_count += len(normalized_ref_dfg)
for dataflow in normalized_ref_dfg:
if dataflow in normalized_cand_dfg:
match_count += 1
normalized_cand_dfg.remove(dataflow)
if total_count == 0:
print(
"WARNING: There is no reference data-flows extracted from the whole corpus, and the data-flow match score degenerates to 0. Please consider ignoring this score.")
return 0
score = match_count / total_count
return score
def get_data_flow(code, parser):
try:
tree = parser[0].parse(bytes(code, 'utf8'))
root_node = tree.root_node
tokens_index = tree_to_token_index(root_node)
code = code.split('\n')
| code_tokens = [index_to_code_token(x, code) for x in tokens_index]
| 10 | 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,721 | 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(
io_data=io_data,
by_period=by_period,
by_unit=by_unit
)
io_data = group_mgr.digest()
# todo: migrate this to group manager...
io_data['group_account']['GROUP_ASSETS'].sort(
key=lambda acc: roles_module.ROLES_ORDER_ASSETS.index(acc['role']))
io_data['group_account']['GROUP_LIABILITIES'].sort(
key=lambda acc: roles_module.ROLES_ORDER_LIABILITIES.index(acc['role']))
io_data['group_account']['GROUP_CAPITAL'].sort(
key=lambda acc: roles_module.ROLES_ORDER_CAPITAL.index(acc['role']))
if process_ratios:
| """
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(
io_data=io_data,
by_period=by_period,
by_unit=by_unit
)
io_data = group_mgr.digest()
# todo: migrate this to group manager...
io_data['group_account']['GROUP_ASSETS'].sort(
key=lambda acc: roles_module.ROLES_ORDER_ASSETS.index(acc['role']))
io_data['group_account']['GROUP_LIABILITIES'].sort(
key=lambda acc: roles_module.ROLES_ORDER_LIABILITIES.index(acc['role']))
io_data['group_account']['GROUP_CAPITAL'].sort(
key=lambda acc: roles_module.ROLES_ORDER_CAPITAL.index(acc['role']))
if process_ratios: | ratio_gen = FinancialRatioManager(io_data=io_data) | 11 | 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,325 |
# 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:
|
# 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)
| 8 | 2023-10-24 13:24:23+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 | 20,233 | 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():
| """
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 | 14 | 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 | 18,604 | 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
elif args.model_type == 'glm':
auto_config = GLMConfig
auto_model_class = GLMForConditionalGeneration
# else:
# auto_config = AutoConfig
# auto_model_class = AutoModelForCausalLM
# with init_empty_weights_with_disk_offload(ignore_tie_weights=False):
if args.pretrained_model_path:
logger.info("Training model from checkpoint")
config = auto_config.from_pretrained(args.pretrained_model_path)
if args.peft_type != "qlora":
# config = auto_config.from_pretrained(args.pretrained_model_path)
# model = auto_model_class.from_pretrained(args.pretrained_model_path, trust_remote_code=True, device_map='auto').cuda()
model = auto_model_class.from_pretrained(args.pretrained_model_path, trust_remote_code=True).cuda()
else:
if BitsAndBytesConfig is None:
raise ImportError(
"To use qlora, please upgrade transformers to 4.30.1 by `pip install -U transformers==4.30.1`"
)
if bnb is None:
raise ImportError("To use qlora, please install bitsandbytes by `pip install -U bitsandbytes==0.39.0`")
try:
except ImportError:
raise ImportError("To use qlora, please install accelerate by `pip install -U accelerate==0.20.3`")
peft_version = version.parse(peft.__version__)
if peft_version < version.parse("0.4.0"):
raise RuntimeError(f"Qlora needs peft>=0.4.0 but current peft version is {peft_version}")
if args.bits not in [4, 8]:
raise ValueError(f"Qlora only support 4 bits or 8 bits but got {args.bits} bits.")
if args.bf16:
torch_dtype = torch.bfloat16
else:
torch_dtype = torch.float32
if args.fp16:
compute_dtype = torch.float16
elif args.bf16:
compute_dtype = torch.bfloat16
else:
compute_dtype = torch.float32
model = auto_model_class.from_pretrained( # noqa
args.pretrained_model_path,
trust_remote_code=True,
load_in_4bit=args.bits == 4,
load_in_8bit=args.bits == 8,
torch_dtype=torch_dtype,
quantization_config=BitsAndBytesConfig(
load_in_4bit=args.bits == 4,
load_in_8bit=args.bits == 8,
llm_int8_threshold=6.0,
llm_int8_has_fp16_weight=False,
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=True,
bnb_4bit_quant_type="nf4",
)
)
else:
logger.info("Training model from scratch")
if args.model_type == 'gpt_neox':
config = GPTNeoXConfig.from_json_file(args.config_path + '/config.json')
# model = AutoModelForCausalLM.from_config(config, trust_remote_code=args.trust_remote_code)
model = GPTNeoXForCausalLM._from_config(config)
elif args.model_type == 'llama':
config = LlamaConfig.from_json_file(args.config_path + '/config.json')
# llama use xformers
if args.use_xformers:
config.use_xformers = True
model = LlamaForCausalLM._from_config(config)
elif args.model_type == 'glm':
config = GLMConfig.from_json_file(args.config_path + '/config.json')
model = GLMForConditionalGeneration._from_config(config)
else:
config = AutoConfig.from_json_file(args.config_path + '/config.json')
model = AutoModelForCausalLM.from_config(config, trust_remote_code=args.trust_remote_code)
# We resize the embeddings only when necessary to avoid index errors. If you are creating a model from scratch
# on a small vocab and want a smaller embedding size, remove this test.
if args.model_type not in ['glm']:
embedding_size = model.get_input_embeddings().weight.shape[0]
print_rank_0('embedding size: ' + str(embedding_size))
print_rank_0('vocab size: ' + str(tokenizer.vocab_size))
if tokenizer.vocab_size > embedding_size:
model.resize_token_embeddings(tokenizer.vocab_size)
print_rank_0('resize embedding size: ' + str(model.get_input_embeddings().weight.shape[0]))
print_rank_0(config)
num_params = get_model_params_num(model)
print_rank_0("num_params of this model:", num_params)
args.total_model_param = num_params
args.hidden_size = config.hidden_size
args.num_hidden_layers = config.num_hidden_layers
args.vocab_size = tokenizer.vocab_size
print_rank_0(f'hidden size: {args.hidden_size}')
print_rank_0(f'num hidden layers: {args.num_hidden_layers}')
print_rank_0(f'vocab size: {args.vocab_size}')
if args.peft_type:
if args.peft_type in ['lora', 'qlora']:
target_modules = None
if args.peft_type == "qlora":
| # 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
elif args.model_type == 'glm':
auto_config = GLMConfig
auto_model_class = GLMForConditionalGeneration
# else:
# auto_config = AutoConfig
# auto_model_class = AutoModelForCausalLM
# with init_empty_weights_with_disk_offload(ignore_tie_weights=False):
if args.pretrained_model_path:
logger.info("Training model from checkpoint")
config = auto_config.from_pretrained(args.pretrained_model_path)
if args.peft_type != "qlora":
# config = auto_config.from_pretrained(args.pretrained_model_path)
# model = auto_model_class.from_pretrained(args.pretrained_model_path, trust_remote_code=True, device_map='auto').cuda()
model = auto_model_class.from_pretrained(args.pretrained_model_path, trust_remote_code=True).cuda()
else:
if BitsAndBytesConfig is None:
raise ImportError(
"To use qlora, please upgrade transformers to 4.30.1 by `pip install -U transformers==4.30.1`"
)
if bnb is None:
raise ImportError("To use qlora, please install bitsandbytes by `pip install -U bitsandbytes==0.39.0`")
try:
except ImportError:
raise ImportError("To use qlora, please install accelerate by `pip install -U accelerate==0.20.3`")
peft_version = version.parse(peft.__version__)
if peft_version < version.parse("0.4.0"):
raise RuntimeError(f"Qlora needs peft>=0.4.0 but current peft version is {peft_version}")
if args.bits not in [4, 8]:
raise ValueError(f"Qlora only support 4 bits or 8 bits but got {args.bits} bits.")
if args.bf16:
torch_dtype = torch.bfloat16
else:
torch_dtype = torch.float32
if args.fp16:
compute_dtype = torch.float16
elif args.bf16:
compute_dtype = torch.bfloat16
else:
compute_dtype = torch.float32
model = auto_model_class.from_pretrained( # noqa
args.pretrained_model_path,
trust_remote_code=True,
load_in_4bit=args.bits == 4,
load_in_8bit=args.bits == 8,
torch_dtype=torch_dtype,
quantization_config=BitsAndBytesConfig(
load_in_4bit=args.bits == 4,
load_in_8bit=args.bits == 8,
llm_int8_threshold=6.0,
llm_int8_has_fp16_weight=False,
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=True,
bnb_4bit_quant_type="nf4",
)
)
else:
logger.info("Training model from scratch")
if args.model_type == 'gpt_neox':
config = GPTNeoXConfig.from_json_file(args.config_path + '/config.json')
# model = AutoModelForCausalLM.from_config(config, trust_remote_code=args.trust_remote_code)
model = GPTNeoXForCausalLM._from_config(config)
elif args.model_type == 'llama':
config = LlamaConfig.from_json_file(args.config_path + '/config.json')
# llama use xformers
if args.use_xformers:
config.use_xformers = True
model = LlamaForCausalLM._from_config(config)
elif args.model_type == 'glm':
config = GLMConfig.from_json_file(args.config_path + '/config.json')
model = GLMForConditionalGeneration._from_config(config)
else:
config = AutoConfig.from_json_file(args.config_path + '/config.json')
model = AutoModelForCausalLM.from_config(config, trust_remote_code=args.trust_remote_code)
# We resize the embeddings only when necessary to avoid index errors. If you are creating a model from scratch
# on a small vocab and want a smaller embedding size, remove this test.
if args.model_type not in ['glm']:
embedding_size = model.get_input_embeddings().weight.shape[0]
print_rank_0('embedding size: ' + str(embedding_size))
print_rank_0('vocab size: ' + str(tokenizer.vocab_size))
if tokenizer.vocab_size > embedding_size:
model.resize_token_embeddings(tokenizer.vocab_size)
print_rank_0('resize embedding size: ' + str(model.get_input_embeddings().weight.shape[0]))
print_rank_0(config)
num_params = get_model_params_num(model)
print_rank_0("num_params of this model:", num_params)
args.total_model_param = num_params
args.hidden_size = config.hidden_size
args.num_hidden_layers = config.num_hidden_layers
args.vocab_size = tokenizer.vocab_size
print_rank_0(f'hidden size: {args.hidden_size}')
print_rank_0(f'num hidden layers: {args.num_hidden_layers}')
print_rank_0(f'vocab size: {args.vocab_size}')
if args.peft_type:
if args.peft_type in ['lora', 'qlora']:
target_modules = None
if args.peft_type == "qlora": | model = prepare_model_for_kbit_training(model, False) | 12 | 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,265 | # 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
|
# 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 | 16 | 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 | 20,108 | replay_buffer_valid.add_path(valid_data)
if configs['standardize']:
obs_mean, obs_std, act_mean, act_std = replay_buffer.calculate_statistics()
replay_buffer_valid.set_statistics(obs_mean, obs_std, act_mean, act_std)
# to use wandb, initialize here, e.g.
# wandb.init(project='palr', dir=wandb_dir, config=configs)
wandb = None
if 'BC' in configs['algorithm']:
embedding_dim = configs['layer_sizes'][1]
policy = TanhGaussianPolicyWithEmbedding(
obs_dim=obs_dim * stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
device=device
)
best_policy = TanhGaussianPolicyWithEmbedding(
obs_dim=obs_dim * stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
device=device
)
trainer = BC(
policy = policy,
best_policy = best_policy,
env = env,
replay_buffer = replay_buffer,
replay_buffer_valid = replay_buffer_valid,
seed = configs['seed'],
device = device,
envname = envname,
lr = configs['lr'],
save_policy_path = configs['save_policy_path'],
obs_dim = obs_dim,
action_dim = action_dim,
stacksize = stacksize,
wandb = wandb,
standardize=configs['standardize']
)
trainer.train(total_iteration=configs['total_iteration'],
eval_freq = configs['eval_freq'],
batch_size = configs['batch_size'],
num_valid = configs['valid_data_num'])
elif 'RAP' in configs['algorithm']:
embedding_dim = configs['layer_sizes'][1]
policy = TanhGaussianRAPPolicy(
obs_dim=obs_dim,
stack_size=stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
residual_hidden_size=configs['additional_network_size'],
device=device,
)
best_policy = TanhGaussianRAPPolicy(
obs_dim=obs_dim,
stack_size=stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
residual_hidden_size=configs['additional_network_size'],
device=device,
)
trainer = RAP(
policy = policy,
best_policy = best_policy,
env = env,
replay_buffer = replay_buffer,
replay_buffer_valid = replay_buffer_valid,
seed = configs['seed'],
device = device,
lr = configs['lr'],
save_policy_path = configs['save_policy_path'],
obs_dim = obs_dim,
action_dim = action_dim,
embedding_dim = embedding_dim,
stacksize = stacksize,
wandb = wandb,
standardize=configs['standardize']
)
trainer.train(total_iteration = configs['total_iteration'],
eval_freq = configs['eval_freq'],
batch_size = configs['batch_size'],
num_valid = configs['valid_data_num'])
elif 'FCA' in configs['algorithm']:
embedding_dim = configs['layer_sizes'][1]
policy = TanhGaussianPolicyWithEmbedding(
obs_dim=obs_dim * stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
device=device,
)
best_policy = TanhGaussianPolicyWithEmbedding(
obs_dim=obs_dim * stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
device=device,
)
| 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)
train_data = data_select_num_transitions(path, configs['train_data_num'])
valid_data = data_select_num_transitions(path, configs['valid_data_num'], start_idx=900000)
replay_buffer = EnvReplayBuffer(
configs['replay_buffer_size'],
env,
stacksize,
action_history_len=2
)
replay_buffer.add_path(train_data)
replay_buffer_valid = EnvReplayBuffer(
configs['replay_buffer_size'],
env,
stacksize,
action_history_len=2
)
replay_buffer_valid.add_path(valid_data)
if configs['standardize']:
obs_mean, obs_std, act_mean, act_std = replay_buffer.calculate_statistics()
replay_buffer_valid.set_statistics(obs_mean, obs_std, act_mean, act_std)
# to use wandb, initialize here, e.g.
# wandb.init(project='palr', dir=wandb_dir, config=configs)
wandb = None
if 'BC' in configs['algorithm']:
embedding_dim = configs['layer_sizes'][1]
policy = TanhGaussianPolicyWithEmbedding(
obs_dim=obs_dim * stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
device=device
)
best_policy = TanhGaussianPolicyWithEmbedding(
obs_dim=obs_dim * stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
device=device
)
trainer = BC(
policy = policy,
best_policy = best_policy,
env = env,
replay_buffer = replay_buffer,
replay_buffer_valid = replay_buffer_valid,
seed = configs['seed'],
device = device,
envname = envname,
lr = configs['lr'],
save_policy_path = configs['save_policy_path'],
obs_dim = obs_dim,
action_dim = action_dim,
stacksize = stacksize,
wandb = wandb,
standardize=configs['standardize']
)
trainer.train(total_iteration=configs['total_iteration'],
eval_freq = configs['eval_freq'],
batch_size = configs['batch_size'],
num_valid = configs['valid_data_num'])
elif 'RAP' in configs['algorithm']:
embedding_dim = configs['layer_sizes'][1]
policy = TanhGaussianRAPPolicy(
obs_dim=obs_dim,
stack_size=stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
residual_hidden_size=configs['additional_network_size'],
device=device,
)
best_policy = TanhGaussianRAPPolicy(
obs_dim=obs_dim,
stack_size=stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
residual_hidden_size=configs['additional_network_size'],
device=device,
)
trainer = RAP(
policy = policy,
best_policy = best_policy,
env = env,
replay_buffer = replay_buffer,
replay_buffer_valid = replay_buffer_valid,
seed = configs['seed'],
device = device,
lr = configs['lr'],
save_policy_path = configs['save_policy_path'],
obs_dim = obs_dim,
action_dim = action_dim,
embedding_dim = embedding_dim,
stacksize = stacksize,
wandb = wandb,
standardize=configs['standardize']
)
trainer.train(total_iteration = configs['total_iteration'],
eval_freq = configs['eval_freq'],
batch_size = configs['batch_size'],
num_valid = configs['valid_data_num'])
elif 'FCA' in configs['algorithm']:
embedding_dim = configs['layer_sizes'][1]
policy = TanhGaussianPolicyWithEmbedding(
obs_dim=obs_dim * stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
device=device,
)
best_policy = TanhGaussianPolicyWithEmbedding(
obs_dim=obs_dim * stacksize,
action_dim=action_dim,
embedding_hidden_size=configs['layer_sizes'][0],
embedding_dim=embedding_dim,
policy_hidden_size=configs['layer_sizes'][2],
device=device,
)
| trainer = FCA( | 2 | 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 | 16,334 |
def getpass_star(prompt="Password: "):
print(prompt, end='', flush=True)
password = []
while True:
char = msvcrt.getch().decode('utf-8')
if char == '\r' or char == '\n':
break
elif char == '\b': # Backspace
if password:
password.pop()
print('\b \b', end='', flush=True)
else:
password.append(char)
print('*', end='', flush=True)
print() # Move to the next line
return ''.join(password)
def hack(system_name):
global seen_markus
# Find the system in the all_systems list
system = next((s for s in all_systems if s['name'].lower() == system_name.lower()), None)
if system:
if system['level'] == player_level:
# Check for CodeShatter before prompting for password
if system['name'] == 'Markus' and has_item("CodeShatter"):
clear_terminal()
code_shatter_minigame()
print_slow("Password Cracked: 735@&!//")
input("Press [Enter] to continue")
clear_terminal()
markus_system_command_loop(markus_system)
add_level(player_level)
remove_from_inventory(item="CodeShatter")
seen_markus = True
elif system['name'] == 'Lobby Camera' and has_item("EyeSpy"):
port_scanning()
add_level(player_level)
camera_first()
else:
# Prompt the user for the password
print_slow("")
password = getpass_star("Enter password: ")
print_slow("")
if password == system['password']:
print_slow("")
print_slow(Fore.GREEN + "Access granted!" + Style.RESET_ALL)
if system['name'] == 'Amy':
amy_system_command_loop(amy_system)
elif system['name'] == 'Billy':
billy_system_command_loop(billy_system)
elif system['name'] == 'Markus':
markus_system_command_loop(markus_system)
add_level(player_level)
seen_markus = True
elif system['name'] == 'Lobby Camera':
camera_first()
elif system['name'] == 'Kyle':
# Implement Kyle System
else:
# Add more conditions for other systems
pass
else:
print_slow("")
print_slow(Fore.RED + "Access denied! Incorrect password." + Style.RESET_ALL)
else:
print_slow("")
print_slow(Fore.RED + "System not found! Please try again." + Style.RESET_ALL)
else:
print_slow("")
print_slow(Fore.RED + "System not found! Please try again." + Style.RESET_ALL)
def list_emails(emails):
print_slow(Fore.LIGHTBLUE_EX + "\nEmails:" + Style.RESET_ALL)
for i, email in enumerate(emails):
print_slow(Fore.LIGHTBLUE_EX + f"\n{email['subject']} - From: {email['sender']}" + Style.RESET_ALL)
def read_email(emails, subject):
global has_read_email, evidence
global balance
email_found = False
for email in emails:
if email['subject'].lower() == subject.lower():
email_found = True
print_slow(
Fore.LIGHTBLUE_EX + f"\nFrom: {email['sender']}\nSubject: {email['subject']}\n\n{email['body']}" + Style.RESET_ALL)
# Check if the email is one of the specific emails that increases evidence count
if email['subject'].lower() in ["project update"]:
evidence_item = 3
if not has_evidence(evidence_item):
print_slow("Adding evidence to the list...")
print_slow("")
print_slow(Fore.GREEN + "Evidence Secured" + Style.RESET_ALL)
add_evidence(evidence_item)
print_slow("")
print_slow("")
time.sleep(3)
print_slow(Fore.GREEN + "Incoming Call..." + Style.RESET_ALL)
input(Fore.GREEN + "> " + Style.RESET_ALL)
third_call()
if email['subject'].lower() in ["professional development"]:
evidence_item = 2
if not has_evidence(evidence_item):
print_slow("Adding evidence to the list...")
print_slow("")
print_slow(Fore.GREEN + "Evidence Secured" + Style.RESET_ALL)
add_evidence(evidence_item)
print_slow("")
print_slow("")
time.sleep(3)
print_slow(Fore.GREEN + "Incoming Call..." + Style.RESET_ALL)
input(Fore.GREEN + "> " + Style.RESET_ALL)
|
# 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()
game_settings()
else:
pygame.mixer.music.stop()
print_slow(Fore.RED + "\nBackground Music Disabled" + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
game_settings()
elif choice.lower() == "delete savegame":
# Delete savegame
confirm = input(Fore.RED + "\nAre you sure you want to delete the savegame? (yes/no): " + Style.RESET_ALL)
if confirm.lower() == "yes":
try:
os.remove("savegame.pkl")
print_slow(Fore.GREEN + "\nSavegame Deleted" + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
game_settings()
except FileNotFoundError:
print_slow(Fore.RED + "\nSavegame not found" + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
game_settings()
elif choice.lower() == "back" or choice.lower() == "back to main menu":
# Return to Main Menu
print_slow(Fore.GREEN + "\nReturning to Main Menu..." + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
else:
print_slow(Fore.RED + "\nInvalid choice, please try again." + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
game_settings()
# Function to add an item to the inventory
def add_to_inventory(item):
inventory.append(item)
def remove_from_inventory(item):
if item in inventory:
inventory.remove(item)
def add_evidence(evidence_item):
evidence.append(evidence_item)
def has_evidence(evidence_item):
return evidence_item in evidence
# Prints the games title
def main():
clear_terminal()
colorama.init()
print_slow(Fore.GREEN + "██████╗░██╗░░░░░░█████╗░░█████╗░██╗░░██╗██╗░░██╗░█████╗░████████╗" + Style.RESET_ALL)
print_slow(Fore.GREEN + "██╔══██╗██║░░░░░██╔══██╗██╔══██╗██║░██╔╝██║░░██║██╔══██╗╚══██╔══╝" + Style.RESET_ALL)
print_slow(Fore.GREEN + "██████╦╝██║░░░░░███████║██║░░╚═╝█████═╝░███████║███████║░░░██║░░░" + Style.RESET_ALL)
print_slow(Fore.GREEN + "██╔══██╗██║░░░░░██╔══██║██║░░██╗██╔═██╗░██╔══██║██╔══██║░░░██║░░░" + Style.RESET_ALL)
print_slow(Fore.GREEN + "██████╦╝███████╗██║░░██║╚█████╔╝██║░╚██╗██║░░██║██║░░██║░░░██║░░░" + Style.RESET_ALL)
print_slow(Fore.GREEN + "╚═════╝░╚══════╝╚═╝░░╚═╝░╚════╝░╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░╚═╝░░░╚═╝░░░" + Style.RESET_ALL)
# Pause for 2 seconds before clearing the console
time.sleep(5)
# Clear the console
clear_terminal()
# Main menu loop
while True:
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 + "| [Start] Start the game |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| [Options] Change the settings |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| [Exit] Exit the game |" + Style.RESET_ALL)
print_slow(Fore.GREEN + " --------------------------------------------" + Style.RESET_ALL)
choice = input(Fore.GREEN + "\n> " + Style.RESET_ALL)
# Start the game
if choice.lower() == "start":
load_game()
start_game()
# Open game settings
elif choice.lower() == "options":
clear_terminal()
game_settings()
# Exit the game
elif choice.lower() == "exit":
print_slow(Fore.GREEN + "\nExiting..." + Style.RESET_ALL)
pygame.mixer.music.stop()
sys.exit()
else:
print_slow(Fore.RED + "\nInvalid choice, please try again." + Style.RESET_ALL)
time.sleep(2)
clear_terminal()
# Function to get the user's balance
def get_balance():
return balance
# Function to add money to the user's balance
def add_money(amount):
global balance
balance += amount
# Function to subtract money from the user's balance
def subtract_money(amount):
global balance
balance -= amount
def add_level(level):
global player_level
player_level += level
# Function to print the user's balance
def print_balance():
print_slow(f"Your current balance is: £{get_balance()}")
# Function to read files and marks files as evidence
def read_file(file_content, file_name):
global has_read_file, evidence
global balance
# Print the file content
print_slow(Fore.LIGHTBLUE_EX + f"\n{file_name}:\n\n{file_content}" + Style.RESET_ALL)
print_slow("")
# Check if the file is one of the specific files that increases evidence count
if file_name.lower() in ["employee_performance_review.txt"]:
evidence_item = 4
if not has_evidence(evidence_item):
print_slow("Adding evidence to the list...")
print_slow("")
print_slow(Fore.GREEN + "Evidence Secured" + Style.RESET_ALL)
add_evidence(evidence_item)
print_slow("")
print_slow("")
time.sleep(3)
print_slow(Fore.GREEN + "Incoming Call..." + Style.RESET_ALL)
input(Fore.GREEN + "> " + Style.RESET_ALL)
fourth_call()
if file_name.lower() in ["meeting_minutes.txt"]:
evidence_item = 5
if not has_evidence(evidence_item):
print_slow("Adding evidence to the list...")
print_slow("")
print_slow(Fore.GREEN + "Evidence Secured" + Style.RESET_ALL)
add_evidence(evidence_item)
print_slow("")
print_slow("")
time.sleep(3)
print_slow(Fore.GREEN + "Incoming Call..." + Style.RESET_ALL)
input(Fore.GREEN + "> " + Style.RESET_ALL)
fifth_call()
# Add more file names here as needed
# Add money to balance based on the file name
if file_name.lower() == "employee_performance_review.txt":
balance += 30
elif file_name.lower() == "meeting_minutes.txt":
balance += 50
# List of available upgrades
upgrades = [
{"name": "EnigmaLink", "description": "Application required to connect to Enigma Corps network.", "price": 100},
{"name": "CodeShatter", "description": "A powerful password breaker that can crack even the strongest passwords.",
"price": 250},
{"name": "EyeSpy", "description": "A privacy breaker to gain access to the smallest of cameras.", "price": 500},
{"name": "Rift", "description": "Break the barrier between the Server and Network.", "price": 800}
]
# Function to display the shop
def shop():
clear_terminal()
print_slow(Fore.YELLOW + r''' ██╗░░██╗░█████╗░░█████╗░██╗░░██╗███████╗██████╗░ ███╗░░░███╗░█████╗░██████╗░██╗░░██╗███████╗████████╗
██║░░██║██╔══██╗██╔══██╗██║░██╔╝██╔════╝██╔══██╗ ████╗░████║██╔══██╗██╔══██╗██║░██╔╝██╔════╝╚══██╔══╝
███████║███████║██║░░╚═╝█████═╝░█████╗░░██████╔╝ ██╔████╔██║███████║██████╔╝█████═╝░█████╗░░░░░██║░░░
██╔══██║██╔══██║██║░░██╗██╔═██╗░██╔══╝░░██╔══██╗ ██║╚██╔╝██║██╔══██║██╔══██╗██╔═██╗░██╔══╝░░░░░██║░░░
██║░░██║██║░░██║╚█████╔╝██║░╚██╗███████╗██║░░██║ ██║░╚═╝░██║██║░░██║██║░░██║██║░╚██╗███████╗░░░██║░░░
╚═╝░░╚═╝╚═╝░░╚═╝░╚════╝░╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝ ╚═╝░░░░░╚═╝╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░╚═╝╚══════╝░░░╚═╝░░░''' + Style.RESET_ALL)
print_slow(Fore.YELLOW + "\nWelcome to the Hacker's Market!" + Style.RESET_ALL)
print_slow("")
print_slow(Fore.YELLOW + "Here you can buy upgrades to improve your hacking abilities.\n" + Style.RESET_ALL)
while True:
# Display the list of available upgrades
for i, upgrade in enumerate(upgrades):
print_slow(
Fore.YELLOW + f"\n{upgrade['name']} - {upgrade['description']} - £{upgrade['price']}" + Style.RESET_ALL)
# Get the user's choice
command = input(Fore.YELLOW + "\n> " + Style.RESET_ALL)
# Buy the chosen upgrade
if command.lower() == 'exit':
print_slow(Fore.YELLOW + "\nExiting Hacker's Market" + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
start_game()
elif command.lower() == 'help':
shop_help()
elif command.lower().startswith('buy '):
upgrade_name = command[4:]
# [4:] removes first 4 characters
if has_item('EnigmaLink'):
if upgrade_name.lower() == 'enigmalink':
print_slow("")
print_slow(Fore.RED + "Sold Out" + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
shop()
else:
for upgrade in upgrades:
if upgrade_name.lower() == upgrade['name'].lower():
if get_balance() >= upgrade['price']:
print_slow("")
print_slow(
Fore.GREEN + f"You have successfully purchased {upgrade['name']} for ${upgrade['price']}!" + Style.RESET_ALL)
subtract_money(upgrade['price'])
print_slow("")
print_balance()
add_to_inventory(upgrade['name'])
time.sleep(2)
clear_terminal()
# Check if the purchased upgrade is CodeShatter
if upgrade_name.lower() == 'codeshatter':
print_slow("")
print_slow(Fore.GREEN + "Incoming Call..." + Style.RESET_ALL)
input(Fore.GREEN + "> " + Style.RESET_ALL)
code_shatter_call()
shop()
else:
clear_terminal()
shop()
else:
print_slow(
Fore.RED + "You don't have enough money to buy this upgrade." + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
shop()
else:
print_slow(Fore.RED + "Invalid choice, please try again." + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
shop()
else:
for upgrade in upgrades:
if upgrade_name.lower() == upgrade['name'].lower():
if get_balance() >= upgrade['price']:
print_slow("")
print_slow(
Fore.GREEN + f"You have successfully purchased {upgrade['name']} for ${upgrade['price']}!" + Style.RESET_ALL)
subtract_money(upgrade['price'])
print_slow("")
print_balance()
add_to_inventory(upgrade['name'])
time.sleep(2)
clear_terminal()
shop()
else:
print_slow(
Fore.RED + "You don't have enough money to buy this upgrade." + Style.RESET_ALL)
shop()
else:
print_slow(Fore.RED + "Invalid choice, please try again." + Style.RESET_ALL)
time.sleep(1)
clear_terminal()
shop()
# Function to start the game
def start_game():
global has_intro_call, has_started_game, seen_markus
if has_intro_call:
clear_terminal()
pass
else:
print_slow("\nStarting game...")
time.sleep(1)
print_slow("\nLoading assets...")
time.sleep(1)
clear_terminal()
print_slow(Fore.GREEN + "Incoming Call..." + Style.RESET_ALL)
input(Fore.GREEN + "> " + Style.RESET_ALL)
intro_call()
has_intro_call = True
has_started_game = True
print_slow(Fore.MAGENTA + "\nHint: Type 'help' to get a list of available commands." + Style.RESET_ALL)
pass
if seen_markus:
print_slow(Fore.GREEN + "Incoming Call..." + Style.RESET_ALL)
input(Fore.GREEN + "> " + Style.RESET_ALL)
markus_seen_call()
else:
pass
# Game command loop
command = input(Fore.GREEN + "> " + Style.RESET_ALL)
# Connect to the network
if command.lower() == "connect":
connect()
# Access the mail system
elif command.lower() == "mail":
mail()
# Display help message
elif command.lower() == "help":
help_user()
# Check balance
elif command.lower() == "balance":
print_balance()
# Enter shop
elif command.lower() == "shop":
shop()
# Clear terminal
elif command.lower() == "clear":
clear_terminal()
# Return to the main menu
elif command.lower() == "exit":
print_slow("Returning to Main Menu...")
time.sleep(1)
main()
else:
print_slow("Invalid command, please try again.")
time.sleep(1)
clear_terminal()
start_game()
# Save the game state
save_game()
# Function to check if an item is in the inventory
def has_item(item):
return item in inventory
def scan():
print_slow("")
print_slow(Fore.YELLOW + "Scanning network..." + Style.RESET_ALL)
time.sleep(2)
print_slow("")
print_slow(Fore.YELLOW + "\nAvailable Systems:" + Style.RESET_ALL)
print_slow("")
for system in all_systems:
if system['level'] == player_level:
print_slow("")
print_slow(f"{system['name']} ({system['type']})")
print_slow("")
def getpass_star(prompt="Password: "):
print(prompt, end='', flush=True)
password = []
while True:
char = msvcrt.getch().decode('utf-8')
if char == '\r' or char == '\n':
break
elif char == '\b': # Backspace
if password:
password.pop()
print('\b \b', end='', flush=True)
else:
password.append(char)
print('*', end='', flush=True)
print() # Move to the next line
return ''.join(password)
def hack(system_name):
global seen_markus
# Find the system in the all_systems list
system = next((s for s in all_systems if s['name'].lower() == system_name.lower()), None)
if system:
if system['level'] == player_level:
# Check for CodeShatter before prompting for password
if system['name'] == 'Markus' and has_item("CodeShatter"):
clear_terminal()
code_shatter_minigame()
print_slow("Password Cracked: 735@&!//")
input("Press [Enter] to continue")
clear_terminal()
markus_system_command_loop(markus_system)
add_level(player_level)
remove_from_inventory(item="CodeShatter")
seen_markus = True
elif system['name'] == 'Lobby Camera' and has_item("EyeSpy"):
port_scanning()
add_level(player_level)
camera_first()
else:
# Prompt the user for the password
print_slow("")
password = getpass_star("Enter password: ")
print_slow("")
if password == system['password']:
print_slow("")
print_slow(Fore.GREEN + "Access granted!" + Style.RESET_ALL)
if system['name'] == 'Amy':
amy_system_command_loop(amy_system)
elif system['name'] == 'Billy':
billy_system_command_loop(billy_system)
elif system['name'] == 'Markus':
markus_system_command_loop(markus_system)
add_level(player_level)
seen_markus = True
elif system['name'] == 'Lobby Camera':
camera_first()
elif system['name'] == 'Kyle':
# Implement Kyle System
else:
# Add more conditions for other systems
pass
else:
print_slow("")
print_slow(Fore.RED + "Access denied! Incorrect password." + Style.RESET_ALL)
else:
print_slow("")
print_slow(Fore.RED + "System not found! Please try again." + Style.RESET_ALL)
else:
print_slow("")
print_slow(Fore.RED + "System not found! Please try again." + Style.RESET_ALL)
def list_emails(emails):
print_slow(Fore.LIGHTBLUE_EX + "\nEmails:" + Style.RESET_ALL)
for i, email in enumerate(emails):
print_slow(Fore.LIGHTBLUE_EX + f"\n{email['subject']} - From: {email['sender']}" + Style.RESET_ALL)
def read_email(emails, subject):
global has_read_email, evidence
global balance
email_found = False
for email in emails:
if email['subject'].lower() == subject.lower():
email_found = True
print_slow(
Fore.LIGHTBLUE_EX + f"\nFrom: {email['sender']}\nSubject: {email['subject']}\n\n{email['body']}" + Style.RESET_ALL)
# Check if the email is one of the specific emails that increases evidence count
if email['subject'].lower() in ["project update"]:
evidence_item = 3
if not has_evidence(evidence_item):
print_slow("Adding evidence to the list...")
print_slow("")
print_slow(Fore.GREEN + "Evidence Secured" + Style.RESET_ALL)
add_evidence(evidence_item)
print_slow("")
print_slow("")
time.sleep(3)
print_slow(Fore.GREEN + "Incoming Call..." + Style.RESET_ALL)
input(Fore.GREEN + "> " + Style.RESET_ALL)
third_call()
if email['subject'].lower() in ["professional development"]:
evidence_item = 2
if not has_evidence(evidence_item):
print_slow("Adding evidence to the list...")
print_slow("")
print_slow(Fore.GREEN + "Evidence Secured" + Style.RESET_ALL)
add_evidence(evidence_item)
print_slow("")
print_slow("")
time.sleep(3)
print_slow(Fore.GREEN + "Incoming Call..." + Style.RESET_ALL)
input(Fore.GREEN + "> " + Style.RESET_ALL) | second_call() | 9 | 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,551 |
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),
("DerOutput", get_layer_output_grad), ]
if layer_name != "conv1":
compare_name_function.append(("DerInput", get_layer_input_grad))
for member_name, extract_func in compare_name_function:
compare_layer_member(layer, layer_name, extract_func, member_name, save_path=save_path)
def compare_weight_layer(layer: SGXLinearBase, layer_name: str, save_path=None) -> None:
compare_layer(layer, layer_name, save_path)
compare_name_function = [("weight", get_layer_weight), ("DerWeight", get_layer_weight_grad) ]
for member_name, extract_func in compare_name_function:
compare_layer_member(layer, layer_name, extract_func, member_name, save_path=save_path)
class ForkedPdb(pdb.Pdb):
"""A Pdb subclass that may be used
from a forked multiprocessing child
"""
def interaction(self, *args, **kwargs):
_stdin = sys.stdin
try:
sys.stdin = open('/dev/stdin')
pdb.Pdb.interaction(self, *args, **kwargs)
finally:
sys.stdin = _stdin
def test_conv(
batch_size, img_hw, input_c, output_c,
kernel, padding, stride, bias=False, set_values_to_one=False,
sid=0
):
print("="*20, "TestConv", "="*20)
print(
f"batch {batch_size}, img_hw {img_hw}, input_c {input_c}, output_c {output_c}, " +
f"kernel {kernel}, padding {padding}, stride {stride}"
)
# def test_conv(
# bias=False, set_values_to_one=True,
# sid=0
# ):
# batch_size = 128
# input_c = 3
# output_c = 64
# img_hw = 224
# kernel, padding, stride = 7, 3, 2
# batch_size = 128
# input_c = 512
# output_c = 512
# img_hw = 7
# kernel, padding, stride = 3, 1, 1
x_shape = [batch_size, input_c, img_hw, img_hw]
GlobalTensor.init()
|
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),
("DerOutput", get_layer_output_grad), ]
if layer_name != "conv1":
compare_name_function.append(("DerInput", get_layer_input_grad))
for member_name, extract_func in compare_name_function:
compare_layer_member(layer, layer_name, extract_func, member_name, save_path=save_path)
def compare_weight_layer(layer: SGXLinearBase, layer_name: str, save_path=None) -> None:
compare_layer(layer, layer_name, save_path)
compare_name_function = [("weight", get_layer_weight), ("DerWeight", get_layer_weight_grad) ]
for member_name, extract_func in compare_name_function:
compare_layer_member(layer, layer_name, extract_func, member_name, save_path=save_path)
class ForkedPdb(pdb.Pdb):
"""A Pdb subclass that may be used
from a forked multiprocessing child
"""
def interaction(self, *args, **kwargs):
_stdin = sys.stdin
try:
sys.stdin = open('/dev/stdin')
pdb.Pdb.interaction(self, *args, **kwargs)
finally:
sys.stdin = _stdin
def test_conv(
batch_size, img_hw, input_c, output_c,
kernel, padding, stride, bias=False, set_values_to_one=False,
sid=0
):
print("="*20, "TestConv", "="*20)
print(
f"batch {batch_size}, img_hw {img_hw}, input_c {input_c}, output_c {output_c}, " +
f"kernel {kernel}, padding {padding}, stride {stride}"
)
# def test_conv(
# bias=False, set_values_to_one=True,
# sid=0
# ):
# batch_size = 128
# input_c = 3
# output_c = 64
# img_hw = 224
# kernel, padding, stride = 7, 3, 2
# batch_size = 128
# input_c = 512
# output_c = 512
# img_hw = 7
# kernel, padding, stride = 3, 1, 1
x_shape = [batch_size, input_c, img_hw, img_hw]
GlobalTensor.init()
| input_layer = SecretInputLayer(sid, "InputLayer", x_shape, ExecutionModeOptions.Enclave ) | 11 | 2023-11-01 10:37:37+00:00 | 24k |
Codra-Ingenierie-Informatique/DataLab | cdl/core/gui/processor/image.py | [
{
"identifier": "distance_matrix",
"path": "cdl/algorithms/image.py",
"snippet": "def distance_matrix(coords: list) -> np.ndarray:\n \"\"\"Return distance matrix from coords\n\n Args:\n coords (list): List of coordinates\n\n Returns:\n np.ndarray: Distance matrix\n \"\"\"\n ... | from collections.abc import Callable
from guidata.qthelpers import exec_dialog
from numpy import ma
from plotpy.widgets.resizedialog import ResizeDialog
from qtpy import QtWidgets as QW
from cdl.algorithms.image import distance_matrix
from cdl.config import APP_NAME, Conf, _
from cdl.core.gui.processor.base import BaseProcessor
from cdl.core.model.base import ShapeTypes
from cdl.core.model.image import ImageObj
from cdl.utils.qthelpers import create_progress_bar, qt_try_except
import numpy as np
import cdl.core.computation.base as cpb
import cdl.core.computation.image as cpi
import cdl.core.computation.image.detection as cpi_det
import cdl.core.computation.image.edges as cpi_edg
import cdl.core.computation.image.exposure as cpi_exp
import cdl.core.computation.image.morphology as cpi_mor
import cdl.core.computation.image.restoration as cpi_res
import cdl.param | 15,896 | """Compute difference between two images"""
self.compute_n1n(
obj2,
_("image to subtract"),
cpi.compute_difference,
title=_("Difference"),
)
@qt_try_except()
def compute_quadratic_difference(self, obj2: ImageObj | None = None) -> None:
"""Compute quadratic difference between two images"""
self.compute_n1n(
obj2,
_("image to subtract"),
cpi.compute_quadratic_difference,
title=_("Quadratic difference"),
)
@qt_try_except()
def compute_division(self, obj2: ImageObj | None = None) -> None:
"""Compute division between two images"""
self.compute_n1n(
obj2,
_("divider"),
cpi.compute_division,
title=_("Division"),
)
@qt_try_except()
def compute_flatfield(
self,
obj2: ImageObj | None = None,
param: cdl.param.FlatFieldParam | None = None,
) -> None:
"""Compute flat field correction"""
edit, param = self.init_param(param, cpi.FlatFieldParam, _("Flat field"))
if edit:
obj = self.panel.objview.get_sel_objects()[0]
param.set_from_datatype(obj.data.dtype)
self.compute_n1n(
obj2,
_("flat field image"),
cpi.compute_flatfield,
param=param,
title=_("Flat field correction"),
edit=edit,
)
# ------Image Processing
@qt_try_except()
def compute_calibration(
self, param: cdl.param.ZCalibrateParam | None = None
) -> None:
"""Compute data linear calibration"""
self.compute_11(
cpi.compute_calibration,
param,
cpi.ZCalibrateParam,
_("Linear calibration"),
"y = a.x + b",
)
@qt_try_except()
def compute_threshold(self, param: cpb.ThresholdParam | None = None) -> None:
"""Compute threshold clipping"""
self.compute_11(
cpi.compute_threshold,
param,
cpb.ThresholdParam,
_("Thresholding"),
)
@qt_try_except()
def compute_clip(self, param: cpb.ClipParam | None = None) -> None:
"""Compute maximum data clipping"""
self.compute_11(
cpi.compute_clip,
param,
cpb.ClipParam,
_("Clipping"),
)
@qt_try_except()
def compute_gaussian_filter(self, param: cpb.GaussianParam | None = None) -> None:
"""Compute gaussian filter"""
self.compute_11(
cpi.compute_gaussian_filter, param, cpb.GaussianParam, _("Gaussian filter")
)
@qt_try_except()
def compute_moving_average(
self, param: cpb.MovingAverageParam | None = None
) -> None:
"""Compute moving average"""
self.compute_11(
cpi.compute_moving_average,
param,
cpb.MovingAverageParam,
_("Moving average"),
)
@qt_try_except()
def compute_moving_median(self, param: cpb.MovingMedianParam | None = None) -> None:
"""Compute moving median"""
self.compute_11(
cpi.compute_moving_median,
param,
cpb.MovingMedianParam,
_("Moving median"),
)
@qt_try_except()
def compute_wiener(self) -> None:
"""Compute Wiener filter"""
self.compute_11(cpi.compute_wiener, title=_("Wiener filter"))
@qt_try_except()
def compute_fft(self, param: cdl.param.FFTParam | None = None) -> None:
"""Compute FFT"""
if param is None:
| # -*- coding: utf-8 -*-
#
# Licensed under the terms of the BSD 3-Clause
# (see cdl/LICENSE for details)
"""
Image Processor
---------------
"""
# pylint: disable=invalid-name # Allows short reference names like x, y, ...
from __future__ import annotations
class ImageProcessor(BaseProcessor):
"""Object handling image processing: operations, processing, computing"""
# pylint: disable=duplicate-code
EDIT_ROI_PARAMS = True
@qt_try_except()
def compute_sum(self) -> None:
"""Compute sum"""
self.compute_n1("Σ", cpi.compute_add, title=_("Sum"))
@qt_try_except()
def compute_average(self) -> None:
"""Compute average"""
def func_objs(new_obj: ImageObj, old_objs: list[ImageObj]) -> None:
"""Finalize average computation"""
new_obj.data = new_obj.data / float(len(old_objs))
self.compute_n1("μ", cpi.compute_add, func_objs=func_objs, title=_("Average"))
@qt_try_except()
def compute_product(self) -> None:
"""Compute product"""
self.compute_n1("Π", cpi.compute_product, title=_("Product"))
@qt_try_except()
def compute_logp1(self, param: cdl.param.LogP1Param | None = None) -> None:
"""Compute base 10 logarithm"""
self.compute_11(cpi.compute_logp1, param, cpi.LogP1Param, title="Log10")
@qt_try_except()
def compute_rotate(self, param: cdl.param.RotateParam | None = None) -> None:
"""Rotate data arbitrarily"""
self.compute_11(cpi.compute_rotate, param, cpi.RotateParam, title="Rotate")
@qt_try_except()
def compute_rotate90(self) -> None:
"""Rotate data 90°"""
self.compute_11(cpi.compute_rotate90, title="Rotate90")
@qt_try_except()
def compute_rotate270(self) -> None:
"""Rotate data 270°"""
self.compute_11(cpi.compute_rotate270, title="Rotate270")
@qt_try_except()
def compute_fliph(self) -> None:
"""Flip data horizontally"""
self.compute_11(cpi.compute_fliph, title="HFlip")
@qt_try_except()
def compute_flipv(self) -> None:
"""Flip data vertically"""
self.compute_11(cpi.compute_flipv, title="VFlip")
@qt_try_except()
def distribute_on_grid(self, param: cdl.param.GridParam | None = None) -> None:
"""Distribute images on a grid"""
title = _("Distribute on grid")
edit, param = self.init_param(param, cpi.GridParam, title)
if edit and not param.edit(parent=self.panel.parent()):
return
objs = self.panel.objview.get_sel_objects(include_groups=True)
g_row, g_col, x0, y0, x0_0, y0_0 = 0, 0, 0.0, 0.0, 0.0, 0.0
delta_x0, delta_y0 = 0.0, 0.0
with create_progress_bar(self.panel, title, max_=len(objs)) as progress:
for i_row, obj in enumerate(objs):
progress.setValue(i_row + 1)
QW.QApplication.processEvents()
if progress.wasCanceled():
break
if i_row == 0:
x0_0, y0_0 = x0, y0 = obj.x0, obj.y0
else:
delta_x0, delta_y0 = x0 - obj.x0, y0 - obj.y0
obj.x0 += delta_x0
obj.y0 += delta_y0
# pylint: disable=unused-argument
def translate_coords(obj, orig, coords):
"""Apply translation to coords"""
coords[:, ::2] += delta_x0
coords[:, 1::2] += delta_y0
obj.transform_shapes(None, translate_coords)
if param.direction == "row":
# Distributing images over rows
sign = np.sign(param.rows)
g_row = (g_row + sign) % param.rows
y0 += (obj.dy * obj.data.shape[0] + param.rowspac) * sign
if g_row == 0:
g_col += 1
x0 += obj.dx * obj.data.shape[1] + param.colspac
y0 = y0_0
else:
# Distributing images over columns
sign = np.sign(param.cols)
g_col = (g_col + sign) % param.cols
x0 += (obj.dx * obj.data.shape[1] + param.colspac) * sign
if g_col == 0:
g_row += 1
x0 = x0_0
y0 += obj.dy * obj.data.shape[0] + param.rowspac
self.panel.SIG_REFRESH_PLOT.emit("selected", True)
@qt_try_except()
def reset_positions(self) -> None:
"""Reset image positions"""
x0_0, y0_0 = 0.0, 0.0
delta_x0, delta_y0 = 0.0, 0.0
objs = self.panel.objview.get_sel_objects(include_groups=True)
for i_row, obj in enumerate(objs):
if i_row == 0:
x0_0, y0_0 = obj.x0, obj.y0
else:
delta_x0, delta_y0 = x0_0 - obj.x0, y0_0 - obj.y0
obj.x0 += delta_x0
obj.y0 += delta_y0
# pylint: disable=unused-argument
def translate_coords(obj, orig, coords):
"""Apply translation to coords"""
coords[:, ::2] += delta_x0
coords[:, 1::2] += delta_y0
obj.transform_shapes(None, translate_coords)
self.panel.SIG_REFRESH_PLOT.emit("selected", True)
@qt_try_except()
def compute_resize(self, param: cdl.param.ResizeParam | None = None) -> None:
"""Resize image"""
obj0 = self.panel.objview.get_sel_objects()[0]
for obj in self.panel.objview.get_sel_objects():
if obj.size != obj0.size:
QW.QMessageBox.warning(
self.panel.parent(),
APP_NAME,
_("Warning:")
+ "\n"
+ _("Selected images do not have the same size"),
)
edit, param = self.init_param(param, cpi.ResizeParam, _("Resize"))
if edit:
original_size = obj0.size
dlg = ResizeDialog(
self.plotwidget,
new_size=original_size,
old_size=original_size,
text=_("Destination size:"),
)
if not exec_dialog(dlg):
return
param.zoom = dlg.get_zoom()
self.compute_11(cpi.compute_resize, param, title=_("Resize"), edit=edit)
@qt_try_except()
def compute_binning(self, param: cdl.param.BinningParam | None = None) -> None:
"""Binning image"""
edit = param is None
obj0 = self.panel.objview.get_sel_objects(include_groups=True)[0]
input_dtype_str = str(obj0.data.dtype)
title = _("Binning")
edit, param = self.init_param(param, cpi.BinningParam, title)
if edit:
param.dtype_str = input_dtype_str
if param.dtype_str is None:
param.dtype_str = input_dtype_str
self.compute_11(cpi.compute_binning, param, title=title, edit=edit)
@qt_try_except()
def compute_roi_extraction(
self, param: cdl.param.ROIDataParam | None = None
) -> None:
"""Extract Region Of Interest (ROI) from data"""
param = self._get_roidataparam(param)
if param is None or param.is_empty:
return
obj = self.panel.objview.get_sel_objects()[0]
group = obj.roidata_to_params(param.roidata)
if param.singleobj:
self.compute_11(cpi.extract_multiple_roi, group, title=_("Extract ROI"))
else:
self.compute_1n(cpi.extract_single_roi, group.datasets, "ROI", edit=False)
@qt_try_except()
def compute_profile(self, param: cdl.param.ProfileParam | None = None) -> None:
"""Compute profile"""
self.compute_11(
cpi.compute_profile, param, cdl.param.ProfileParam, title=_("Profile")
)
@qt_try_except()
def compute_average_profile(
self, param: cdl.param.AverageProfileParam | None = None
) -> None:
"""Compute average profile"""
self.compute_11(
cpi.compute_average_profile,
param,
cdl.param.AverageProfileParam,
title=_("Average profile"),
)
@qt_try_except()
def compute_swap_axes(self) -> None:
"""Swap data axes"""
self.compute_11(cpi.compute_swap_axes, title=_("Swap axes"))
@qt_try_except()
def compute_abs(self) -> None:
"""Compute absolute value"""
self.compute_11(cpi.compute_abs, title=_("Absolute value"))
@qt_try_except()
def compute_re(self) -> None:
"""Compute real part"""
self.compute_11(cpi.compute_re, title=_("Real part"))
@qt_try_except()
def compute_im(self) -> None:
"""Compute imaginary part"""
self.compute_11(cpi.compute_im, title=_("Imaginary part"))
@qt_try_except()
def compute_astype(self, param: cdl.param.DataTypeIParam | None = None) -> None:
"""Convert data type"""
self.compute_11(
cpi.compute_astype, param, cpi.DataTypeIParam, title=_("Convert data type")
)
@qt_try_except()
def compute_log10(self) -> None:
"""Compute Log10"""
self.compute_11(cpi.compute_log10, title="Log10")
@qt_try_except()
def compute_difference(self, obj2: ImageObj | None = None) -> None:
"""Compute difference between two images"""
self.compute_n1n(
obj2,
_("image to subtract"),
cpi.compute_difference,
title=_("Difference"),
)
@qt_try_except()
def compute_quadratic_difference(self, obj2: ImageObj | None = None) -> None:
"""Compute quadratic difference between two images"""
self.compute_n1n(
obj2,
_("image to subtract"),
cpi.compute_quadratic_difference,
title=_("Quadratic difference"),
)
@qt_try_except()
def compute_division(self, obj2: ImageObj | None = None) -> None:
"""Compute division between two images"""
self.compute_n1n(
obj2,
_("divider"),
cpi.compute_division,
title=_("Division"),
)
@qt_try_except()
def compute_flatfield(
self,
obj2: ImageObj | None = None,
param: cdl.param.FlatFieldParam | None = None,
) -> None:
"""Compute flat field correction"""
edit, param = self.init_param(param, cpi.FlatFieldParam, _("Flat field"))
if edit:
obj = self.panel.objview.get_sel_objects()[0]
param.set_from_datatype(obj.data.dtype)
self.compute_n1n(
obj2,
_("flat field image"),
cpi.compute_flatfield,
param=param,
title=_("Flat field correction"),
edit=edit,
)
# ------Image Processing
@qt_try_except()
def compute_calibration(
self, param: cdl.param.ZCalibrateParam | None = None
) -> None:
"""Compute data linear calibration"""
self.compute_11(
cpi.compute_calibration,
param,
cpi.ZCalibrateParam,
_("Linear calibration"),
"y = a.x + b",
)
@qt_try_except()
def compute_threshold(self, param: cpb.ThresholdParam | None = None) -> None:
"""Compute threshold clipping"""
self.compute_11(
cpi.compute_threshold,
param,
cpb.ThresholdParam,
_("Thresholding"),
)
@qt_try_except()
def compute_clip(self, param: cpb.ClipParam | None = None) -> None:
"""Compute maximum data clipping"""
self.compute_11(
cpi.compute_clip,
param,
cpb.ClipParam,
_("Clipping"),
)
@qt_try_except()
def compute_gaussian_filter(self, param: cpb.GaussianParam | None = None) -> None:
"""Compute gaussian filter"""
self.compute_11(
cpi.compute_gaussian_filter, param, cpb.GaussianParam, _("Gaussian filter")
)
@qt_try_except()
def compute_moving_average(
self, param: cpb.MovingAverageParam | None = None
) -> None:
"""Compute moving average"""
self.compute_11(
cpi.compute_moving_average,
param,
cpb.MovingAverageParam,
_("Moving average"),
)
@qt_try_except()
def compute_moving_median(self, param: cpb.MovingMedianParam | None = None) -> None:
"""Compute moving median"""
self.compute_11(
cpi.compute_moving_median,
param,
cpb.MovingMedianParam,
_("Moving median"),
)
@qt_try_except()
def compute_wiener(self) -> None:
"""Compute Wiener filter"""
self.compute_11(cpi.compute_wiener, title=_("Wiener filter"))
@qt_try_except()
def compute_fft(self, param: cdl.param.FFTParam | None = None) -> None:
"""Compute FFT"""
if param is None: | param = cpb.FFTParam.create(shift=Conf.proc.fft_shift_enabled.get()) | 1 | 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,297 | 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)
if self.flow:
self.flow_tensor4d = Tensor4D(**self.conf['model.flow_tensor4d']).to(self.device)
self.flow_network = FieldNetwork(d_t4d=self.flow_tensor4d.dims, **self.conf['model.flow_network']).to(self.device)
else:
self.flow_network = None
| 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)
if self.flow:
self.flow_tensor4d = Tensor4D(**self.conf['model.flow_tensor4d']).to(self.device)
self.flow_network = FieldNetwork(d_t4d=self.flow_tensor4d.dims, **self.conf['model.flow_network']).to(self.device)
else:
self.flow_network = None | self.deviation_network = SingleVarianceNetwork(**self.conf['model.variance_network']).to(self.device) | 4 | 2023-11-07 10:16:33+00:00 | 24k |
Kushalhk/AutoFilter | plugins/p_ttishow.py | [
{
"identifier": "ADMINS",
"path": "info.py",
"snippet": "ADMINS = [int(admin) if id_pattern.search(admin) else admin for admin in environ.get('ADMINS', '').split()]"
},
{
"identifier": "LOG_CHANNEL",
"path": "info.py",
"snippet": "LOG_CHANNEL = int(environ.get('LOG_CHANNEL', ''))"
},
... | from pyrogram import Client, filters, enums
from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, CallbackQuery
from pyrogram.errors.exceptions.bad_request_400 import MessageTooLong, PeerIdInvalid
from info import ADMINS, LOG_CHANNEL, SUPPORT_CHAT, MELCOW_NEW_USERS, MELCOW_VID, CHNL_LNK, GRP_LNK
from database.users_chats_db import db
from database.ia_filterdb import Media
from utils import get_size, temp, get_settings
from Script import script
from pyrogram.errors import ChatAdminRequired
import asyncio | 20,080 |
"""-----------------------------------------https://t.me/TG_LINKS_CHANNEL--------------------------------------"""
@Client.on_message(filters.new_chat_members & filters.group)
async def save_group(bot, message):
r_j_check = [u.id for u in message.new_chat_members]
if temp.ME in r_j_check:
if not await db.get_chat(message.chat.id):
total=await bot.get_chat_members_count(message.chat.id)
r_j = message.from_user.mention if message.from_user else "Anonymous"
await bot.send_message(LOG_CHANNEL, script.LOG_TEXT_G.format(message.chat.title, message.chat.id, total, r_j))
await db.add_chat(message.chat.id, message.chat.title)
if message.chat.id in temp.BANNED_CHATS:
# Inspired from a boat of a banana tree
buttons = [[
InlineKeyboardButton('Support', url=f'https://t.me/{SUPPORT_CHAT}')
]]
reply_markup=InlineKeyboardMarkup(buttons)
k = await message.reply(
text='<b>CHAT NOT ALLOWED 🐞\n\nMy admins has restricted me from working here ! If you want to know more about it contact support..</b>',
reply_markup=reply_markup,
)
try:
await k.pin()
except:
pass
await bot.leave_chat(message.chat.id)
return
buttons = [[
InlineKeyboardButton('🔸 ᴍᴇꜱꜱᴀɢᴇ ʜᴇʀᴇ 🔹', url="https://t.me/TG_Bots_Supporter")
],[
InlineKeyboardButton('ᴄʜᴀɴɴᴇʟ', url=CHNL_LNK),
InlineKeyboardButton('ɢʀᴏᴜᴘ', url=GRP_LNK)
]]
reply_markup=InlineKeyboardMarkup(buttons)
await message.reply_text(
text=f"<b>ᴛʜᴀɴᴋ ʏᴏᴜ ꜰᴏʀ ᴀᴅᴅɪɴɢ ᴍᴇ ɪɴ {message.chat.title} ❣️\n\nᴅᴏɴ'ᴛ ꜰᴏʀɢᴇᴛ ᴛᴏ ᴍᴀᴋᴇ ᴍᴇ ᴀᴅᴍɪɴ. ɪꜰ ʏᴏᴜ ʜᴀᴠᴇ ᴀɴʏ ǫᴜᴇꜱᴛɪᴏɴꜱ & ᴅᴏᴜʙᴛꜱ ᴀʙᴏᴜᴛ ᴜꜱɪɴɢ ᴍᴇ ᴄᴏɴᴛᴀᴄᴛ ꜰʀᴏᴍ ᴀᴅᴍɪɴ & ᴍᴇꜱꜱᴀɢᴇ ʜᴇʀᴇ 👇</b>",
reply_markup=reply_markup)
else:
settings = await get_settings(message.chat.id)
if settings["welcome"]:
for u in message.new_chat_members:
if (temp.MELCOW).get('welcome') is not None:
try:
await (temp.MELCOW['welcome']).delete()
except:
pass
temp.MELCOW['welcome'] = await message.reply_video(
|
"""-----------------------------------------https://t.me/TG_LINKS_CHANNEL--------------------------------------"""
@Client.on_message(filters.new_chat_members & filters.group)
async def save_group(bot, message):
r_j_check = [u.id for u in message.new_chat_members]
if temp.ME in r_j_check:
if not await db.get_chat(message.chat.id):
total=await bot.get_chat_members_count(message.chat.id)
r_j = message.from_user.mention if message.from_user else "Anonymous"
await bot.send_message(LOG_CHANNEL, script.LOG_TEXT_G.format(message.chat.title, message.chat.id, total, r_j))
await db.add_chat(message.chat.id, message.chat.title)
if message.chat.id in temp.BANNED_CHATS:
# Inspired from a boat of a banana tree
buttons = [[
InlineKeyboardButton('Support', url=f'https://t.me/{SUPPORT_CHAT}')
]]
reply_markup=InlineKeyboardMarkup(buttons)
k = await message.reply(
text='<b>CHAT NOT ALLOWED 🐞\n\nMy admins has restricted me from working here ! If you want to know more about it contact support..</b>',
reply_markup=reply_markup,
)
try:
await k.pin()
except:
pass
await bot.leave_chat(message.chat.id)
return
buttons = [[
InlineKeyboardButton('🔸 ᴍᴇꜱꜱᴀɢᴇ ʜᴇʀᴇ 🔹', url="https://t.me/TG_Bots_Supporter")
],[
InlineKeyboardButton('ᴄʜᴀɴɴᴇʟ', url=CHNL_LNK),
InlineKeyboardButton('ɢʀᴏᴜᴘ', url=GRP_LNK)
]]
reply_markup=InlineKeyboardMarkup(buttons)
await message.reply_text(
text=f"<b>ᴛʜᴀɴᴋ ʏᴏᴜ ꜰᴏʀ ᴀᴅᴅɪɴɢ ᴍᴇ ɪɴ {message.chat.title} ❣️\n\nᴅᴏɴ'ᴛ ꜰᴏʀɢᴇᴛ ᴛᴏ ᴍᴀᴋᴇ ᴍᴇ ᴀᴅᴍɪɴ. ɪꜰ ʏᴏᴜ ʜᴀᴠᴇ ᴀɴʏ ǫᴜᴇꜱᴛɪᴏɴꜱ & ᴅᴏᴜʙᴛꜱ ᴀʙᴏᴜᴛ ᴜꜱɪɴɢ ᴍᴇ ᴄᴏɴᴛᴀᴄᴛ ꜰʀᴏᴍ ᴀᴅᴍɪɴ & ᴍᴇꜱꜱᴀɢᴇ ʜᴇʀᴇ 👇</b>",
reply_markup=reply_markup)
else:
settings = await get_settings(message.chat.id)
if settings["welcome"]:
for u in message.new_chat_members:
if (temp.MELCOW).get('welcome') is not None:
try:
await (temp.MELCOW['welcome']).delete()
except:
pass
temp.MELCOW['welcome'] = await message.reply_video( | video=(MELCOW_VID), | 4 | 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 | 19,294 | #
# 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
| #
# 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( | 6 | 2023-11-06 23:14:20+00:00 | 24k |
alibaba/animate-anything | train_svd.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 random
import gc
import copy
import json
import numpy as np
import cv2
import torch
import torch.nn.functional as F
import torch.utils.checkpoint
import torchvision.transforms as T
import diffusers
import transformers
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, UNetSpatioTemporalConditionModel
from diffusers import DPMSolverMultistepScheduler, DDPMScheduler, EulerDiscreteScheduler
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 diffusers import StableVideoDiffusionPipeline
from diffusers.pipelines.stable_video_diffusion.pipeline_stable_video_diffusion import _resize_with_antialiasing
from transformers import CLIPTextModel, CLIPTokenizer, CLIPVisionModel, CLIPImageProcessor, CLIPTextConfig
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 MaskStableVideoDiffusionPipeline
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, motion_mask_loss
from xformers.ops import MemoryEfficientAttentionFlashAttentionOp | 20,491 | pixel_values = batch["pixel_values"]
bsz, num_frames = pixel_values.shape[:2]
frames = rearrange(pixel_values, 'b f c h w-> (b f) c h w')
latents = vae.encode(frames).latent_dist.mode()
latents = rearrange(latents, '(b f) c h w-> b f c h w', b=bsz)
latents = latents * vae.config.scaling_factor
if motion_mask:
mask = batch["mask"]
mask = mask.div(255).to(latents.device)
h, w = latents.shape[-2:]
mask = T.Resize((h, w), antialias=False)(mask)
mask[mask<0.5] = 0
mask[mask>=0.5] = 1
mask = rearrange(mask, 'b h w -> b 1 1 h w')
freeze = repeat(latents[:,0], 'b c h w -> b f c h w', f=num_frames)
latents = freeze * (1-mask) + latents * mask
# enocde image latent
image = pixel_values[:,0]
image = image + noise_aug_strength * torch.randn_like(image)
image_latents = vae.encode(image).latent_dist.mode()
image_latents = repeat(image_latents, 'b c h w->b f c h w',f=num_frames)
# vae image to clip image
images = _resize_with_antialiasing(pixel_values[:,0], (224, 224))
images = (images + 1.0) / 2.0 # [-1, 1] -> [0, 1]
images = pipeline.feature_extractor(
images=images,
do_normalize=True,
do_center_crop=False,
do_resize=False,
do_rescale=False,
return_tensors="pt",
).pixel_values
image_embeddings = pipeline._encode_image(images, device, 1, False)
negative_image_embeddings = torch.zeros_like(image_embeddings)
# Add noise to the latents according to the noise magnitude at each timestep
# (this is the forward diffusion process) #[bsz, f, c, h , w]
rnd_normal = torch.randn([bsz, 1, 1, 1, 1], device=device)
sigma = (rnd_normal * P_std + P_mean).exp()
c_skip = 1 / (sigma**2 + 1)
c_out = -sigma / (sigma**2 + 1) ** 0.5
c_in = 1 / (sigma**2 + 1) ** 0.5
c_noise = sigma.log() / 4
loss_weight = (sigma ** 2 + 1) / sigma ** 2
noisy_latents = latents + torch.randn_like(latents) * sigma
input_latents = c_in * noisy_latents
input_latents = torch.cat([input_latents, image_latents], dim=2)
if motion_mask:
mask = repeat(mask, 'b 1 1 h w -> b f 1 h w', f=num_frames)
input_latents = torch.cat([mask, input_latents], dim=2)
motion_bucket_id = 127
fps = 7
added_time_ids = pipeline._get_add_time_ids(fps, motion_bucket_id,
noise_aug_strength, image_embeddings.dtype, bsz, 1, False)
added_time_ids = added_time_ids.to(device)
losses = []
for i in range(2):
encoder_hidden_states = (
negative_image_embeddings if i==0 else image_embeddings
)
model_pred = unet(input_latents, c_noise.reshape([bsz]), encoder_hidden_states=encoder_hidden_states,
added_time_ids=added_time_ids,).sample
predict_x0 = c_out * model_pred + c_skip * noisy_latents
loss = ((predict_x0 - latents)**2 * loss_weight).mean()
'''
if motion_mask:
loss += F.mse_loss(predict_x0*(1-mask), freeze*(1-mask))
'''
losses.append(loss)
loss = losses[0] if len(losses) == 1 else losses[0] + losses[1]
return loss
def main(
pretrained_model_path: str,
output_dir: str,
train_data: Dict,
validation_data: Dict,
extra_train_data: list = [],
dataset_types: Tuple[str] = ('json'),
shuffle: bool = True,
validation_steps: int = 100,
trainable_modules: Tuple[str] = None, # Eg: ("attn1", "attn2")
trainable_text_modules: Tuple[str] = None, # Eg: ("all"), this also applies to trainable_modules
extra_unet_params = None,
extra_text_encoder_params = None,
train_batch_size: int = 1,
max_train_steps: int = 500,
learning_rate: float = 5e-5,
scale_lr: bool = False,
lr_scheduler: str = "constant",
lr_warmup_steps: int = 0,
adam_beta1: float = 0.9,
adam_beta2: float = 0.999,
adam_weight_decay: float = 1e-2,
adam_epsilon: float = 1e-08,
max_grad_norm: float = 1.0,
gradient_accumulation_steps: int = 1,
gradient_checkpointing: bool = False,
text_encoder_gradient_checkpointing: bool = False,
checkpointing_steps: int = 500,
resume_from_checkpoint: Optional[str] = None,
resume_step: Optional[int] = None,
mixed_precision: Optional[str] = "fp16",
use_8bit_adam: bool = False,
enable_xformers_memory_efficient_attention: bool = True,
enable_torch_2_attn: bool = False,
seed: Optional[int] = None,
train_text_encoder: bool = False,
use_offset_noise: bool = False,
rescale_schedule: bool = False,
offset_noise_strength: float = 0.1,
extend_dataset: bool = False,
cache_latents: bool = False,
cached_latent_dir = None,
|
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, eval=False):
if eval:
pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path, torch_dtype=torch.float16, variant='fp16')
else:
pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path)
return pipeline, None, pipeline.feature_extractor, pipeline.scheduler, pipeline.image_processor, \
pipeline.image_encoder, pipeline.vae, pipeline.unet
def convert_svd(pretrained_model_path, out_path):
pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path)
unet = UNetSpatioTemporalConditionModel.from_pretrained(
pretrained_model_path, subfolder="unet_mask", low_cpu_mem_usage=False, ignore_mismatched_sizes=True)
unet.conv_in.bias.data = copy.deepcopy(pipeline.unet.conv_in.bias)
torch.nn.init.zeros_(unet.conv_in.weight)
unet.conv_in.weight.data[:,1:]= copy.deepcopy(pipeline.unet.conv_in.weight)
new_pipeline = StableVideoDiffusionPipeline.from_pretrained(
pretrained_model_path, unet=unet)
new_pipeline.save_pretrained(out_path)
def handle_cache_latents(
should_cache,
output_dir,
train_dataloader,
train_batch_size,
pipeline,
device,
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
pipeline.to(device, dtype=torch.half)
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(device)
bsz, num_frames = pixel_values.shape[:2]
frames = rearrange(pixel_values, 'b f c h w-> (b f) c h w').to(torch.half)
latents = pipeline.vae.encode(frames).latent_dist.mode()
latents = rearrange(latents, '(b f) c h w-> b f c h w', b=bsz)
latents = latents * pipeline.vae.config.scaling_factor
batch['latent'] = latents
# vae image to clip image
images = _resize_with_antialiasing(pixel_values[:,0], (224, 224)).to(torch.half)
images = (images + 1.0) / 2.0 # [-1, 1] -> [0, 1]
images = pipeline.feature_extractor(
images=images,
do_normalize=True,
do_center_crop=False,
do_resize=False,
do_rescale=False,
return_tensors="pt",
).pixel_values
image_embeddings = pipeline._encode_image(images, device, 1, False)
batch['image_embeddings'] = image_embeddings
for k, v in batch.items(): batch[k] = v[0]
torch.save(batch, full_out_path)
del pixel_values
del batch
# We do this to avoid fragmentation from casting latents between devices.
torch.cuda.empty_cache()
else:
cache_save_dir = cached_latent_dir
return torch.utils.data.DataLoader(
CachedDataset(cache_dir=cache_save_dir),
batch_size=train_batch_size,
shuffle=shuffle,
num_workers=0
)
def _set_gradient_checkpointing(self, value=False):
self.gradient_checkpointing = value
self.mid_block.gradient_checkpointing = value
for module in self.down_blocks + self.up_blocks:
module.gradient_checkpointing = value
def unet_and_text_g_c(unet, text_encoder, unet_enable, text_enable):
_set_gradient_checkpointing(unet, 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_trainable_modules(model, trainable_modules=None, is_enabled=True, negation=None):
global already_printed_trainables
# This can most definitely be refactored :-)
unfrozen_params = 0
if trainable_modules is not None:
for name, module in model.named_modules():
for tm in tuple(trainable_modules):
if tm == 'all':
model.requires_grad_(is_enabled)
unfrozen_params =len(list(model.parameters()))
break
if tm in name and 'lora' not in name:
for m in module.parameters():
m.requires_grad_(is_enabled)
if is_enabled: unfrozen_params +=1
if unfrozen_params > 0 and not already_printed_trainables:
already_printed_trainables = True
print(f"{unfrozen_params} params have been unfrozen for training.")
def sample_noise(latents, noise_strength, use_offset_noise=False):
b ,c, f, *_ = latents.shape
noise_latents = torch.randn_like(latents, device=latents.device)
offset_noise = None
if use_offset_noise:
offset_noise = torch.randn(b, c, f, 1, 1, device=latents.device)
noise_latents = noise_latents + noise_strength * offset_noise
return noise_latents
def enforce_zero_terminal_snr(betas):
"""
Corrects noise in diffusion schedulers.
From: Common Diffusion Noise Schedules and Sample Steps are Flawed
https://arxiv.org/pdf/2305.08891.pdf
"""
# Convert betas to alphas_bar_sqrt
alphas = 1 - betas
alphas_bar = alphas.cumprod(0)
alphas_bar_sqrt = alphas_bar.sqrt()
# Store old values.
alphas_bar_sqrt_0 = alphas_bar_sqrt[0].clone()
alphas_bar_sqrt_T = alphas_bar_sqrt[-1].clone()
# Shift so the last timestep is zero.
alphas_bar_sqrt -= alphas_bar_sqrt_T
# Scale so the first timestep is back to the old value.
alphas_bar_sqrt *= alphas_bar_sqrt_0 / (
alphas_bar_sqrt_0 - alphas_bar_sqrt_T
)
# Convert alphas_bar_sqrt to betas
alphas_bar = alphas_bar_sqrt ** 2
alphas = alphas_bar[1:] / alphas_bar[:-1]
alphas = torch.cat([alphas_bar[0:1], alphas])
betas = 1 - alphas
return betas
def should_sample(global_step, validation_steps, validation_data):
return (global_step % validation_steps == 0 or global_step == 5) \
and validation_data.sample_preview
def save_pipe(
path,
global_step,
accelerator,
unet,
text_encoder,
vae,
output_dir,
lora_manager: LoraHandler,
unet_target_replace_module=None,
text_target_replace_module=None,
is_checkpoint=False,
save_pretrained_model=True
):
if is_checkpoint:
save_path = os.path.join(output_dir, f"checkpoint-{global_step}")
os.makedirs(save_path, exist_ok=True)
else:
save_path = output_dir
# Save the dtypes so we can continue training at the same precision.
u_dtype, t_dtype, v_dtype = unet.dtype, text_encoder.dtype, vae.dtype
# Copy the model without creating a reference to it. This allows keeping the state of our lora training if enabled.
unet_save = copy.deepcopy(unet.cpu())
text_encoder_save = copy.deepcopy(text_encoder.cpu())
unet_out = copy.deepcopy(accelerator.unwrap_model(unet_save, keep_fp32_wrapper=False))
text_encoder_out = copy.deepcopy(accelerator.unwrap_model(text_encoder_save, keep_fp32_wrapper=False))
pipeline = StableVideoDiffusionPipeline.from_pretrained(
path, unet=unet_out).to(torch_dtype=torch.float32)
if save_pretrained_model:
pipeline.save_pretrained(save_path)
if is_checkpoint:
unet, text_encoder = accelerator.prepare(unet, text_encoder)
models_to_cast_back = [(unet, u_dtype), (text_encoder, t_dtype), (vae, v_dtype)]
[x[0].to(accelerator.device, dtype=x[1]) for x in models_to_cast_back]
logger.info(f"Saved model at {save_path} on step {global_step}")
del pipeline
del unet_out
del text_encoder_out
torch.cuda.empty_cache()
gc.collect()
def replace_prompt(prompt, token, wlist):
for w in wlist:
if w in prompt: return prompt.replace(w, token)
return prompt
def prompt_image(image, processor, encoder):
if type(image) == str:
image = Image.open(image)
image = processor(images=image, return_tensors="pt")['pixel_values']
image = image.to(encoder.device).to(encoder.dtype)
inputs = encoder(image).pooler_output.to(encoder.dtype).unsqueeze(1)
#inputs = encoder(image).last_hidden_state.to(encoder.dtype)
return inputs
def finetune_unet(pipeline, batch, use_offset_noise,
rescale_schedule, offset_noise_strength, unet, motion_mask,
P_mean=0.7, P_std=1.6, noise_aug_strength=0.02):
pipeline.vae.eval()
pipeline.image_encoder.eval()
vae = pipeline.vae
device = vae.device
# Convert videos to latent space
pixel_values = batch["pixel_values"]
bsz, num_frames = pixel_values.shape[:2]
frames = rearrange(pixel_values, 'b f c h w-> (b f) c h w')
latents = vae.encode(frames).latent_dist.mode()
latents = rearrange(latents, '(b f) c h w-> b f c h w', b=bsz)
latents = latents * vae.config.scaling_factor
if motion_mask:
mask = batch["mask"]
mask = mask.div(255).to(latents.device)
h, w = latents.shape[-2:]
mask = T.Resize((h, w), antialias=False)(mask)
mask[mask<0.5] = 0
mask[mask>=0.5] = 1
mask = rearrange(mask, 'b h w -> b 1 1 h w')
freeze = repeat(latents[:,0], 'b c h w -> b f c h w', f=num_frames)
latents = freeze * (1-mask) + latents * mask
# enocde image latent
image = pixel_values[:,0]
image = image + noise_aug_strength * torch.randn_like(image)
image_latents = vae.encode(image).latent_dist.mode()
image_latents = repeat(image_latents, 'b c h w->b f c h w',f=num_frames)
# vae image to clip image
images = _resize_with_antialiasing(pixel_values[:,0], (224, 224))
images = (images + 1.0) / 2.0 # [-1, 1] -> [0, 1]
images = pipeline.feature_extractor(
images=images,
do_normalize=True,
do_center_crop=False,
do_resize=False,
do_rescale=False,
return_tensors="pt",
).pixel_values
image_embeddings = pipeline._encode_image(images, device, 1, False)
negative_image_embeddings = torch.zeros_like(image_embeddings)
# Add noise to the latents according to the noise magnitude at each timestep
# (this is the forward diffusion process) #[bsz, f, c, h , w]
rnd_normal = torch.randn([bsz, 1, 1, 1, 1], device=device)
sigma = (rnd_normal * P_std + P_mean).exp()
c_skip = 1 / (sigma**2 + 1)
c_out = -sigma / (sigma**2 + 1) ** 0.5
c_in = 1 / (sigma**2 + 1) ** 0.5
c_noise = sigma.log() / 4
loss_weight = (sigma ** 2 + 1) / sigma ** 2
noisy_latents = latents + torch.randn_like(latents) * sigma
input_latents = c_in * noisy_latents
input_latents = torch.cat([input_latents, image_latents], dim=2)
if motion_mask:
mask = repeat(mask, 'b 1 1 h w -> b f 1 h w', f=num_frames)
input_latents = torch.cat([mask, input_latents], dim=2)
motion_bucket_id = 127
fps = 7
added_time_ids = pipeline._get_add_time_ids(fps, motion_bucket_id,
noise_aug_strength, image_embeddings.dtype, bsz, 1, False)
added_time_ids = added_time_ids.to(device)
losses = []
for i in range(2):
encoder_hidden_states = (
negative_image_embeddings if i==0 else image_embeddings
)
model_pred = unet(input_latents, c_noise.reshape([bsz]), encoder_hidden_states=encoder_hidden_states,
added_time_ids=added_time_ids,).sample
predict_x0 = c_out * model_pred + c_skip * noisy_latents
loss = ((predict_x0 - latents)**2 * loss_weight).mean()
'''
if motion_mask:
loss += F.mse_loss(predict_x0*(1-mask), freeze*(1-mask))
'''
losses.append(loss)
loss = losses[0] if len(losses) == 1 else losses[0] + losses[1]
return loss
def main(
pretrained_model_path: str,
output_dir: str,
train_data: Dict,
validation_data: Dict,
extra_train_data: list = [],
dataset_types: Tuple[str] = ('json'),
shuffle: bool = True,
validation_steps: int = 100,
trainable_modules: Tuple[str] = None, # Eg: ("attn1", "attn2")
trainable_text_modules: Tuple[str] = None, # Eg: ("all"), this also applies to trainable_modules
extra_unet_params = None,
extra_text_encoder_params = None,
train_batch_size: int = 1,
max_train_steps: int = 500,
learning_rate: float = 5e-5,
scale_lr: bool = False,
lr_scheduler: str = "constant",
lr_warmup_steps: int = 0,
adam_beta1: float = 0.9,
adam_beta2: float = 0.999,
adam_weight_decay: float = 1e-2,
adam_epsilon: float = 1e-08,
max_grad_norm: float = 1.0,
gradient_accumulation_steps: int = 1,
gradient_checkpointing: bool = False,
text_encoder_gradient_checkpointing: bool = False,
checkpointing_steps: int = 500,
resume_from_checkpoint: Optional[str] = None,
resume_step: Optional[int] = None,
mixed_precision: Optional[str] = "fp16",
use_8bit_adam: bool = False,
enable_xformers_memory_efficient_attention: bool = True,
enable_torch_2_attn: bool = False,
seed: Optional[int] = None,
train_text_encoder: bool = False,
use_offset_noise: bool = False,
rescale_schedule: bool = False,
offset_noise_strength: float = 0.1,
extend_dataset: bool = False,
cache_latents: bool = False,
cached_latent_dir = None, | lora_version: LORA_VERSIONS = LORA_VERSIONS[0], | 9 | 2023-12-07 08:26:29+00:00 | 24k |
rehg-lab/RAVE | annotator/oneformer/detectron2/modeling/meta_arch/retinanet.py | [
{
"identifier": "configurable",
"path": "annotator/oneformer/detectron2/config/config.py",
"snippet": "def configurable(init_func=None, *, from_config=None):\r\n \"\"\"\r\n Decorate a function or a class's __init__ method so that it can be called\r\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 annotator.oneformer.detectron2.config import configurable
from annotator.oneformer.detectron2.layers import CycleBatchNormList, ShapeSpec, batched_nms, cat, get_norm
from annotator.oneformer.detectron2.structures import Boxes, ImageList, Instances, pairwise_iou
from annotator.oneformer.detectron2.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
| 17,658 | match_quality_matrix = pairwise_iou(gt_per_image.gt_boxes, anchors)
matched_idxs, anchor_labels = self.anchor_matcher(match_quality_matrix)
del match_quality_matrix
if len(gt_per_image) > 0:
matched_gt_boxes_i = gt_per_image.gt_boxes.tensor[matched_idxs]
gt_labels_i = gt_per_image.gt_classes[matched_idxs]
# Anchors with label 0 are treated as background.
gt_labels_i[anchor_labels == 0] = self.num_classes
# Anchors with label -1 are ignored.
gt_labels_i[anchor_labels == -1] = -1
else:
matched_gt_boxes_i = torch.zeros_like(anchors.tensor)
gt_labels_i = torch.zeros_like(matched_idxs) + self.num_classes
gt_labels.append(gt_labels_i)
matched_gt_boxes.append(matched_gt_boxes_i)
return gt_labels, matched_gt_boxes
def forward_inference(
self, images: ImageList, features: List[Tensor], predictions: List[List[Tensor]]
):
pred_logits, pred_anchor_deltas = self._transpose_dense_predictions(
predictions, [self.num_classes, 4]
)
anchors = self.anchor_generator(features)
results: List[Instances] = []
for img_idx, image_size in enumerate(images.image_sizes):
scores_per_image = [x[img_idx].sigmoid_() for x in pred_logits]
deltas_per_image = [x[img_idx] for x in pred_anchor_deltas]
results_per_image = self.inference_single_image(
anchors, scores_per_image, deltas_per_image, image_size
)
results.append(results_per_image)
return results
def inference_single_image(
self,
anchors: List[Boxes],
box_cls: List[Tensor],
box_delta: List[Tensor],
image_size: Tuple[int, int],
):
"""
Single-image inference. Return bounding-box detection results by thresholding
on scores and applying non-maximum suppression (NMS).
Arguments:
anchors (list[Boxes]): list of #feature levels. Each entry contains
a Boxes object, which contains all the anchors in that feature level.
box_cls (list[Tensor]): list of #feature levels. Each entry contains
tensor of size (H x W x A, K)
box_delta (list[Tensor]): Same shape as 'box_cls' except that K becomes 4.
image_size (tuple(H, W)): a tuple of the image height and width.
Returns:
Same as `inference`, but for only one image.
"""
pred = self._decode_multi_level_predictions(
anchors,
box_cls,
box_delta,
self.test_score_thresh,
self.test_topk_candidates,
image_size,
)
keep = batched_nms( # per-class NMS
pred.pred_boxes.tensor, pred.scores, pred.pred_classes, self.test_nms_thresh
)
return pred[keep[: self.max_detections_per_image]]
class RetinaNetHead(nn.Module):
"""
The head used in RetinaNet for object classification and box regression.
It has two subnets for the two tasks, with a common structure but separate parameters.
"""
@configurable
def __init__(
self,
*,
input_shape: List[ShapeSpec],
num_classes,
num_anchors,
conv_dims: List[int],
norm="",
prior_prob=0.01,
):
"""
NOTE: this interface is experimental.
Args:
input_shape (List[ShapeSpec]): input shape
num_classes (int): number of classes. Used to label background proposals.
num_anchors (int): number of generated anchors
conv_dims (List[int]): dimensions for each convolution layer
norm (str or callable):
Normalization for conv layers except for the two output layers.
See :func:`detectron2.layers.get_norm` for supported types.
prior_prob (float): Prior weight for computing bias
"""
super().__init__()
self._num_features = len(input_shape)
if norm == "BN" or norm == "SyncBN":
logger.info(
f"Using domain-specific {norm} in RetinaNetHead with len={self._num_features}."
)
bn_class = nn.BatchNorm2d if norm == "BN" else nn.SyncBatchNorm
def norm(c):
return CycleBatchNormList(
length=self._num_features, bn_class=bn_class, num_features=c
)
else:
| # 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)
normalizer = self._ema_update("loss_normalizer", max(num_pos_anchors, 1), 100)
# classification and regression loss
gt_labels_target = F.one_hot(gt_labels[valid_mask], num_classes=self.num_classes + 1)[
:, :-1
] # no loss for the last (background) class
loss_cls = sigmoid_focal_loss_jit(
cat(pred_logits, dim=1)[valid_mask],
gt_labels_target.to(pred_logits[0].dtype),
alpha=self.focal_loss_alpha,
gamma=self.focal_loss_gamma,
reduction="sum",
)
loss_box_reg = _dense_box_regression_loss(
anchors,
self.box2box_transform,
pred_anchor_deltas,
gt_boxes,
pos_mask,
box_reg_loss_type=self.box_reg_loss_type,
smooth_l1_beta=self.smooth_l1_beta,
)
return {
"loss_cls": loss_cls / normalizer,
"loss_box_reg": loss_box_reg / normalizer,
}
@torch.no_grad()
def label_anchors(self, anchors, gt_instances):
"""
Args:
anchors (list[Boxes]): A list of #feature level Boxes.
The Boxes contains anchors of this image on the specific feature level.
gt_instances (list[Instances]): a list of N `Instances`s. The i-th
`Instances` contains the ground-truth per-instance annotations
for the i-th input image.
Returns:
list[Tensor]: List of #img tensors. i-th element is a vector of labels whose length is
the total number of anchors across all feature maps (sum(Hi * Wi * A)).
Label values are in {-1, 0, ..., K}, with -1 means ignore, and K means background.
list[Tensor]: i-th element is a Rx4 tensor, where R is the total number of anchors
across feature maps. The values are the matched gt boxes for each anchor.
Values are undefined for those anchors not labeled as foreground.
"""
anchors = Boxes.cat(anchors) # Rx4
gt_labels = []
matched_gt_boxes = []
for gt_per_image in gt_instances:
match_quality_matrix = pairwise_iou(gt_per_image.gt_boxes, anchors)
matched_idxs, anchor_labels = self.anchor_matcher(match_quality_matrix)
del match_quality_matrix
if len(gt_per_image) > 0:
matched_gt_boxes_i = gt_per_image.gt_boxes.tensor[matched_idxs]
gt_labels_i = gt_per_image.gt_classes[matched_idxs]
# Anchors with label 0 are treated as background.
gt_labels_i[anchor_labels == 0] = self.num_classes
# Anchors with label -1 are ignored.
gt_labels_i[anchor_labels == -1] = -1
else:
matched_gt_boxes_i = torch.zeros_like(anchors.tensor)
gt_labels_i = torch.zeros_like(matched_idxs) + self.num_classes
gt_labels.append(gt_labels_i)
matched_gt_boxes.append(matched_gt_boxes_i)
return gt_labels, matched_gt_boxes
def forward_inference(
self, images: ImageList, features: List[Tensor], predictions: List[List[Tensor]]
):
pred_logits, pred_anchor_deltas = self._transpose_dense_predictions(
predictions, [self.num_classes, 4]
)
anchors = self.anchor_generator(features)
results: List[Instances] = []
for img_idx, image_size in enumerate(images.image_sizes):
scores_per_image = [x[img_idx].sigmoid_() for x in pred_logits]
deltas_per_image = [x[img_idx] for x in pred_anchor_deltas]
results_per_image = self.inference_single_image(
anchors, scores_per_image, deltas_per_image, image_size
)
results.append(results_per_image)
return results
def inference_single_image(
self,
anchors: List[Boxes],
box_cls: List[Tensor],
box_delta: List[Tensor],
image_size: Tuple[int, int],
):
"""
Single-image inference. Return bounding-box detection results by thresholding
on scores and applying non-maximum suppression (NMS).
Arguments:
anchors (list[Boxes]): list of #feature levels. Each entry contains
a Boxes object, which contains all the anchors in that feature level.
box_cls (list[Tensor]): list of #feature levels. Each entry contains
tensor of size (H x W x A, K)
box_delta (list[Tensor]): Same shape as 'box_cls' except that K becomes 4.
image_size (tuple(H, W)): a tuple of the image height and width.
Returns:
Same as `inference`, but for only one image.
"""
pred = self._decode_multi_level_predictions(
anchors,
box_cls,
box_delta,
self.test_score_thresh,
self.test_topk_candidates,
image_size,
)
keep = batched_nms( # per-class NMS
pred.pred_boxes.tensor, pred.scores, pred.pred_classes, self.test_nms_thresh
)
return pred[keep[: self.max_detections_per_image]]
class RetinaNetHead(nn.Module):
"""
The head used in RetinaNet for object classification and box regression.
It has two subnets for the two tasks, with a common structure but separate parameters.
"""
@configurable
def __init__(
self,
*,
input_shape: List[ShapeSpec],
num_classes,
num_anchors,
conv_dims: List[int],
norm="",
prior_prob=0.01,
):
"""
NOTE: this interface is experimental.
Args:
input_shape (List[ShapeSpec]): input shape
num_classes (int): number of classes. Used to label background proposals.
num_anchors (int): number of generated anchors
conv_dims (List[int]): dimensions for each convolution layer
norm (str or callable):
Normalization for conv layers except for the two output layers.
See :func:`detectron2.layers.get_norm` for supported types.
prior_prob (float): Prior weight for computing bias
"""
super().__init__()
self._num_features = len(input_shape)
if norm == "BN" or norm == "SyncBN":
logger.info(
f"Using domain-specific {norm} in RetinaNetHead with len={self._num_features}."
)
bn_class = nn.BatchNorm2d if norm == "BN" else nn.SyncBatchNorm
def norm(c):
return CycleBatchNormList(
length=self._num_features, bn_class=bn_class, num_features=c
)
else:
| norm_name = str(type(get_norm(norm, 32)))
| 1 | 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 | 17,552 |
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:
|
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) | 5 | 2023-12-07 14:03:31+00:00 | 24k |
modelscope/normal-depth-diffusion | ldm/models/diffusion/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 | 14,901 |
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 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:
| """
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
-- 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 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) | 17 | 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 | 21,372 | v_projection_size=self.helper.args.moe.att.v_size,
same_sel=self.helper.args.moe.att.same_sel,
moe_k=self.helper.args.moe.att.k,
qside_n_experts=self.helper.args.moe.att.qside_n_experts,
shared_experts=self.helper.args.moe.att.shared_experts,
kq_n_experts=self.helper.args.moe.att.kq_n_experts,
separate_kq_sel=self.helper.args.moe.att.separate_kq_sel,
moa_mode=self.helper.args.moa.mode,
cvloss=self.helper.args.moa.cvloss,
switchloss=self.helper.args.moa.switchloss,
zloss=self.helper.args.moa.zloss,
rotate_fraction=self.helper.args.rope.rotate_fraction,
rope_base=self.helper.args.rope.base,
moeatt_norm_init=self.helper.args.moe.att.norm_init)
elif self.helper.args.transformer.variant in {"preln_rope", "rope"}:
mklayer = lambda: FastRopeTransformerEncoderLayer(
**base_args, **extra_args,
n_layers=self.helper.args.transformer.encoder_n_layers,
head_projection_size=self.helper.args.transformer.head_projection_size,
preln=self.is_preln(), rotate_fraction = self.helper.args.rope.rotate_fraction,
rope_base=self.helper.args.rope.base)
elif self.helper.args.transformer.variant in {"preln_moe", "moe"}:
# def __init__(self, d_model, nhead, n_bins: int, bin_size: int, n_layers: int, dim_feedforward=2048,
mklayer = lambda: RelativeMoeTransformerEncoderLayer(
**base_args, **extra_args, preln=self.is_preln(),
test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,
n_layers=self.helper.args.transformer.encoder_n_layers,
n_experts=self.helper.args.moe.n_experts,
expert_size=self.helper.args.moe.expert_size,
dropout_mode=self.helper.args.kvmem.dropout,
selection_mode=self.helper.args.moe.selection_mode,
perplexity_reg=self.helper.args.moe.perplexity_reg,
n_heads=self.helper.args.pkm.n_heads,
norm_keys=self.helper.args.moe.norm_keys,
perplexity_reg_mode=self.helper.args.moe.perplexity_reg_mode,
n_random=self.helper.args.moe.n_random,
reg_type=self.helper.args.moe.reg_type,
topk_mode=self.helper.args.moe.topk_mode,
head_projection_size=self.helper.args.transformer.head_projection_size,
activation_after_topk=self.helper.args.moe.activation_after_topk,
drop_parallel=self.helper.args.moe.drop_parallel,
norm_key_init=self.helper.args.moe.norm_key_init,
norm_value_init=self.helper.args.moe.norm_value_init,
normalize_expert_sel_init=self.helper.args.moe.norm_expert_sel_init,
identical_init=self.helper.args.moe.identical_init,
sel_norm=self.helper.args.moe.sel_norm,
ln_affine=self.helper.args.transformer.ln_affine,
moe_dropout_factor=self.helper.args.moe.dropout_factor,
drop_expert=self.helper.args.moe.drop_expert,
sync_distributed=self.helper.args.moe.sync_distributed,
modulation_amplitude=self.helper.args.moe.modulation_amplitude,
moe_init_scale=self.helper.args.moe.init_scale,
moe_attention=self.helper.args.moe.att.enable,
moe_att_n_experts=self.helper.args.moe.att.n_experts,
moe_att_expert_dropout=self.helper.args.moe.drop_expert if self.helper.args.moe.att.drop_expert is None else self.helper.args.moe.att.drop_expert,
moe_att_selection_mode=self.helper.args.moe.att.selection_mode,
moe_att_variant=self.helper.args.moe.att.variant,
moe_att_ppl_reg=self.helper.args.moe.perplexity_reg if self.helper.args.moe.att.perplexity_reg is None else self.helper.args.moe.att.perplexity_reg,
moe_att_k=self.helper.args.moe.att.k,
q_expert=self.helper.args.moe.att.q_expert,
k_expert=self.helper.args.moe.att.k_expert,
v_expert=self.helper.args.moe.att.v_expert,
o_expert=self.helper.args.moe.att.o_expert,
v_projection_size=self.helper.args.moe.att.v_size,
qside_n_experts=self.helper.args.moe.att.qside_n_experts,
moe_att_shared_experts=self.helper.args.moe.att.shared_experts,
moe_att_kq_n_experts=self.helper.args.moe.att.kq_n_experts,
moe_att_separate_kq_sel=self.helper.args.moe.att.separate_kq_sel,
rotate_fraction=self.helper.args.rope.rotate_fraction,
rope_base=self.helper.args.rope.base,
moe_att_norm_init=self.helper.args.moe.att.norm_init,
moe_att_same_sel=self.helper.args.moe.att.same_sel,
moe_att_norm_retrieval=self.helper.args.moe.att.norm_ret)
else:
assert False, f"Invalid variant \"{self.helper.args.transformer.variant}\""
layers = [mklayer() for _ in range(self.helper.args.transformer.encoder_n_layers)]
return layers
def fix_init(self, model):
init_std = 0.02
torch.nn.init.normal_(model.embedding.weight, 0.0, init_std)
# torch.nn.init.normal_(model.embedding_adapter.weight, 0.0, init_std)
initialized = 0
for m in model.modules():
if isinstance(m, (torch.nn.Linear, torch.nn.Embedding)) and hasattr(m, "weight"):
torch.nn.init.normal_(m.weight, 0.0, init_std)
initialized += m.weight.numel()
if isinstance(m, (torch.nn.Linear, torch.nn.LayerNorm)) and m.bias is not None:
torch.nn.init.constant_(m.bias, 0)
initialized += m.bias.numel()
if isinstance(m, (torch.nn.LayerNorm)) and m.weight is not None:
torch.nn.init.normal_(m.weight, 1.0, init_std)
initialized += m.weight.numel()
if isinstance(m, MoE):
torch.nn.init.normal_(m.keys, 0.0, init_std)
torch.nn.init.normal_(m.values, 0.0, init_std)
if m.expert_sel is not None:
torch.nn.init.normal_(m.expert_sel, 0.0, init_std)
m.renorm_keep_std(m.expert_sel)
initialized += m.expert_sel.numel()
initialized += m.keys.numel() + m.values.numel()
if isinstance(m, (FullMoeRelativeAttentionCore)):
for p in m.parameters():
torch.nn.init.normal_(p, 0.0, init_std)
initialized += p.numel()
for s in m.selections.values():
m.renorm_keep_std(s)
print(f"Reinitialized {initialized/self.n_weights*100:.3f}% weights")
def create_model(self) -> torch.nn.Module:
self.validation_started_on = None
# pyright: reportOptionalMemberAccess=false
tlayers = self.get_layers()
|
@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()
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,
dropout=self.helper.args.dropout,
activation=activation
)
if self.helper.args.transformer.variant not in {"preln_moe", "moe"}:
base_args["dim_feedforward"]=int(self.helper.args.state_size * self.helper.args.transformer.ff_multiplier)
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_moeatt"}:
mklayer = lambda: MoeAttentionRelativeTransformerEncoderLayer(
**base_args, **extra_args, moe_att_n_experts=self.helper.args.moe.att.n_experts,
n_layers=self.helper.args.transformer.encoder_n_layers,
head_projection_size=self.helper.args.transformer.head_projection_size,
att_perplexity_reg=self.helper.args.moe.perplexity_reg if self.helper.args.moe.att.perplexity_reg is None else self.helper.args.moe.att.perplexity_reg,
expert_dropout=self.helper.args.moe.drop_expert if self.helper.args.moe.att.drop_expert is None else self.helper.args.moe.att.drop_expert,
att_selection_mode=self.helper.args.moe.att.selection_mode,
preln=self.is_preln(),
attention_variant=self.helper.args.moe.att.variant,
q_expert=self.helper.args.moe.att.q_expert,
k_expert=self.helper.args.moe.att.k_expert,
v_expert=self.helper.args.moe.att.v_expert,
o_expert=self.helper.args.moe.att.o_expert,
norm_qk_score=self.helper.args.moe.att.norm_qk,
v_projection_size=self.helper.args.moe.att.v_size,
same_sel=self.helper.args.moe.att.same_sel,
moe_k=self.helper.args.moe.att.k,
qside_n_experts=self.helper.args.moe.att.qside_n_experts,
shared_experts=self.helper.args.moe.att.shared_experts,
kq_n_experts=self.helper.args.moe.att.kq_n_experts,
separate_kq_sel=self.helper.args.moe.att.separate_kq_sel,
moa_mode=self.helper.args.moa.mode,
cvloss=self.helper.args.moa.cvloss,
switchloss=self.helper.args.moa.switchloss,
zloss=self.helper.args.moa.zloss,
rotate_fraction=self.helper.args.rope.rotate_fraction,
rope_base=self.helper.args.rope.base,
moeatt_norm_init=self.helper.args.moe.att.norm_init)
elif self.helper.args.transformer.variant in {"preln_rope", "rope"}:
mklayer = lambda: FastRopeTransformerEncoderLayer(
**base_args, **extra_args,
n_layers=self.helper.args.transformer.encoder_n_layers,
head_projection_size=self.helper.args.transformer.head_projection_size,
preln=self.is_preln(), rotate_fraction = self.helper.args.rope.rotate_fraction,
rope_base=self.helper.args.rope.base)
elif self.helper.args.transformer.variant in {"preln_moe", "moe"}:
# def __init__(self, d_model, nhead, n_bins: int, bin_size: int, n_layers: int, dim_feedforward=2048,
mklayer = lambda: RelativeMoeTransformerEncoderLayer(
**base_args, **extra_args, preln=self.is_preln(),
test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,
n_layers=self.helper.args.transformer.encoder_n_layers,
n_experts=self.helper.args.moe.n_experts,
expert_size=self.helper.args.moe.expert_size,
dropout_mode=self.helper.args.kvmem.dropout,
selection_mode=self.helper.args.moe.selection_mode,
perplexity_reg=self.helper.args.moe.perplexity_reg,
n_heads=self.helper.args.pkm.n_heads,
norm_keys=self.helper.args.moe.norm_keys,
perplexity_reg_mode=self.helper.args.moe.perplexity_reg_mode,
n_random=self.helper.args.moe.n_random,
reg_type=self.helper.args.moe.reg_type,
topk_mode=self.helper.args.moe.topk_mode,
head_projection_size=self.helper.args.transformer.head_projection_size,
activation_after_topk=self.helper.args.moe.activation_after_topk,
drop_parallel=self.helper.args.moe.drop_parallel,
norm_key_init=self.helper.args.moe.norm_key_init,
norm_value_init=self.helper.args.moe.norm_value_init,
normalize_expert_sel_init=self.helper.args.moe.norm_expert_sel_init,
identical_init=self.helper.args.moe.identical_init,
sel_norm=self.helper.args.moe.sel_norm,
ln_affine=self.helper.args.transformer.ln_affine,
moe_dropout_factor=self.helper.args.moe.dropout_factor,
drop_expert=self.helper.args.moe.drop_expert,
sync_distributed=self.helper.args.moe.sync_distributed,
modulation_amplitude=self.helper.args.moe.modulation_amplitude,
moe_init_scale=self.helper.args.moe.init_scale,
moe_attention=self.helper.args.moe.att.enable,
moe_att_n_experts=self.helper.args.moe.att.n_experts,
moe_att_expert_dropout=self.helper.args.moe.drop_expert if self.helper.args.moe.att.drop_expert is None else self.helper.args.moe.att.drop_expert,
moe_att_selection_mode=self.helper.args.moe.att.selection_mode,
moe_att_variant=self.helper.args.moe.att.variant,
moe_att_ppl_reg=self.helper.args.moe.perplexity_reg if self.helper.args.moe.att.perplexity_reg is None else self.helper.args.moe.att.perplexity_reg,
moe_att_k=self.helper.args.moe.att.k,
q_expert=self.helper.args.moe.att.q_expert,
k_expert=self.helper.args.moe.att.k_expert,
v_expert=self.helper.args.moe.att.v_expert,
o_expert=self.helper.args.moe.att.o_expert,
v_projection_size=self.helper.args.moe.att.v_size,
qside_n_experts=self.helper.args.moe.att.qside_n_experts,
moe_att_shared_experts=self.helper.args.moe.att.shared_experts,
moe_att_kq_n_experts=self.helper.args.moe.att.kq_n_experts,
moe_att_separate_kq_sel=self.helper.args.moe.att.separate_kq_sel,
rotate_fraction=self.helper.args.rope.rotate_fraction,
rope_base=self.helper.args.rope.base,
moe_att_norm_init=self.helper.args.moe.att.norm_init,
moe_att_same_sel=self.helper.args.moe.att.same_sel,
moe_att_norm_retrieval=self.helper.args.moe.att.norm_ret)
else:
assert False, f"Invalid variant \"{self.helper.args.transformer.variant}\""
layers = [mklayer() for _ in range(self.helper.args.transformer.encoder_n_layers)]
return layers
def fix_init(self, model):
init_std = 0.02
torch.nn.init.normal_(model.embedding.weight, 0.0, init_std)
# torch.nn.init.normal_(model.embedding_adapter.weight, 0.0, init_std)
initialized = 0
for m in model.modules():
if isinstance(m, (torch.nn.Linear, torch.nn.Embedding)) and hasattr(m, "weight"):
torch.nn.init.normal_(m.weight, 0.0, init_std)
initialized += m.weight.numel()
if isinstance(m, (torch.nn.Linear, torch.nn.LayerNorm)) and m.bias is not None:
torch.nn.init.constant_(m.bias, 0)
initialized += m.bias.numel()
if isinstance(m, (torch.nn.LayerNorm)) and m.weight is not None:
torch.nn.init.normal_(m.weight, 1.0, init_std)
initialized += m.weight.numel()
if isinstance(m, MoE):
torch.nn.init.normal_(m.keys, 0.0, init_std)
torch.nn.init.normal_(m.values, 0.0, init_std)
if m.expert_sel is not None:
torch.nn.init.normal_(m.expert_sel, 0.0, init_std)
m.renorm_keep_std(m.expert_sel)
initialized += m.expert_sel.numel()
initialized += m.keys.numel() + m.values.numel()
if isinstance(m, (FullMoeRelativeAttentionCore)):
for p in m.parameters():
torch.nn.init.normal_(p, 0.0, init_std)
initialized += p.numel()
for s in m.selections.values():
m.renorm_keep_std(s)
print(f"Reinitialized {initialized/self.n_weights*100:.3f}% weights")
def create_model(self) -> torch.nn.Module:
self.validation_started_on = None
# pyright: reportOptionalMemberAccess=false
tlayers = self.get_layers()
| model = TransformerLanguageModel( | 0 | 2023-12-13 08:45:02+00:00 | 24k |
AIFSH/NativeDancer | nativedancer/third_part/magicanimate/pipelines/pipeline_animation.py | [
{
"identifier": "UNet3DConditionModel",
"path": "nativedancer/third_part/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_siz... | 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.pipelines.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 ..models.unet_controlnet import UNet3DConditionModel
from ..models.controlnet import ControlNetModel
from ..models.mutual_self_attention import ReferenceAttentionControl
from ..pipelines.context import (
get_context_scheduler,
get_total_steps
)
from ..utils.util import get_tensor_interpolation_method
from accelerate import cpu_offload | 16,791 | # *************************************************************************
# 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,
| # *************************************************************************
# 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, | controlnet: ControlNetModel, | 1 | 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 | 21,552 | # Print results
pf = '%22s' + '%11i' * 2 + '%11.3g' * 8 # print format
LOGGER.info(pf % ("all", seen, nt.sum(), *metrics.mean_results()))
if nt.sum() == 0:
LOGGER.warning(f'WARNING ⚠️ no labels found in {task} set, can not compute metrics without labels')
# Print results per class
if (verbose or (nc < 50 and not training)) and nc > 1 and len(stats):
for i, c in enumerate(metrics.ap_class_index):
LOGGER.info(pf % (names[c], seen, nt[c], *metrics.class_result(i)))
# Print speeds
t = tuple(x.t / seen * 1E3 for x in dt) # speeds per image
if not training:
shape = (batch_size, 3, imgsz, imgsz)
LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {shape}' % t)
# Plots
if plots:
confusion_matrix.plot(save_dir=save_dir, names=list(names.values()))
# callbacks.run('on_val_end')
mp_bbox, mr_bbox, map50_bbox, map_bbox, mp_mask, mr_mask, map50_mask, map_mask = metrics.mean_results()
# Save JSON
if save_json and len(jdict):
w = Path(weights[0] if isinstance(weights, list) else weights).stem if weights is not None else '' # weights
anno_json = str(Path(data.get('path', '../coco')) / 'annotations/instances_val2017.json') # annotations json
pred_json = str(save_dir / f"{w}_predictions.json") # predictions json
LOGGER.info(f'\nEvaluating pycocotools mAP... saving {pred_json}...')
with open(pred_json, 'w') as f:
json.dump(jdict, f)
try: # https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb
anno = COCO(anno_json) # init annotations api
pred = anno.loadRes(pred_json) # init predictions api
results = []
for eval in COCOeval(anno, pred, 'bbox'), COCOeval(anno, pred, 'segm'):
if is_coco:
eval.params.imgIds = [int(Path(x).stem) for x in dataloader.dataset.im_files] # img ID to evaluate
eval.evaluate()
eval.accumulate()
eval.summarize()
results.extend(eval.stats[:2]) # update results (mAP@0.5:0.95, mAP@0.5)
map_bbox, map50_bbox, map_mask, map50_mask = results
except Exception as e:
LOGGER.info(f'pycocotools unable to run: {e}')
# Return results
model.float() # for training
if not training:
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}")
final_metric = mp_bbox, mr_bbox, map50_bbox, map_bbox, mp_mask, mr_mask, map50_mask, map_mask
return (*final_metric, *(loss.cpu() / len(dataloader)).tolist()), metrics.get_maps(nc), t
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--data', type=str, default=ROOT / 'data/BCC.yaml', help='dataset.yaml path')
parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'runs_2/train-seg/base/weights/best.pt', help='model path(s)')
parser.add_argument('--batch-size', type=int, default=1, help='batch size')
parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='inference size (pixels)')
parser.add_argument('--conf-thres', type=float, default=0.01, help='confidence threshold')
parser.add_argument('--iou-thres', type=float, default=0.45, help='NMS IoU threshold')
parser.add_argument('--max-det', type=int, default=300, help='maximum detections per image')
parser.add_argument('--task', default='val', help='train, val, test, speed or study')
parser.add_argument('--device', default='6', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')
parser.add_argument('--single-cls', action='store_true', help='treat as single-class dataset')
parser.add_argument('--augment', action='store_true', help='augmented inference')
parser.add_argument('--verbose', action='store_true', help='report mAP by class')
parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
parser.add_argument('--save-hybrid', action='store_true', help='save label+prediction hybrid results to *.txt')
parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
parser.add_argument('--save-json', action='store_true', help='save a COCO-JSON results file')
parser.add_argument('--project', default=ROOT / 'runs_2/val_test', help='save results to project/name')
parser.add_argument('--name', default='base', help='save to project/name')
parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
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.data = check_yaml(opt.data) # check YAML
# opt.save_json |= opt.data.endswith('coco.yaml')
opt.save_txt |= opt.save_hybrid
print_args(vars(opt))
return opt
def main(opt):
check_requirements(requirements=ROOT / 'requirements.txt', exclude=('tensorboard', 'thop'))
if opt.task in ('train', 'val', 'test'): # run normally
if opt.conf_thres > 0.001: # https://github.com/ultralytics/yolov5/issues/1466
LOGGER.warning(f'WARNING ⚠️ confidence threshold {opt.conf_thres} > 0.001 produces invalid results')
if opt.save_hybrid:
LOGGER.warning('WARNING ⚠️ --save-hybrid returns high mAP from hybrid labels, not from predictions alone')
run(**vars(opt))
else:
weights = opt.weights if isinstance(opt.weights, list) else [opt.weights]
opt.half = torch.cuda.is_available() and opt.device != 'cpu' # FP16 for fastest results
if opt.task == 'speed': # speed benchmarks
# python val.py --task speed --data coco.yaml --batch 1 --weights yolov5n.pt yolov5s.pt...
opt.conf_thres, opt.iou_thres, opt.save_json = 0.25, 0.45, False
for opt.weights in weights:
run(**vars(opt), plots=False)
elif opt.task == 'study': # speed vs mAP benchmarks
# python val.py --task study --data coco.yaml --iou 0.7 --weights yolov5n.pt yolov5s.pt...
for opt.weights in weights:
f = f'study_{Path(opt.data).stem}_{Path(opt.weights).stem}.txt' # filename to save to
x, y = list(range(256, 1536 + 128, 128)), [] # x axis (image sizes), y axis
for opt.imgsz in x: # img-size
LOGGER.info(f'\nRunning {f} --imgsz {opt.imgsz}...')
r, _, t = run(**vars(opt), plots=False)
y.append(r + t) # results and times
np.savetxt(f, y, fmt='%10.4g') # save
os.system('zip -r study.zip study_*.txt')
| # 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')
# 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]:
act = time.time()
preds, protos, train_out = model(im) if compute_loss else (*model(im, augment=augment)[:2], None)
#print('time.time():',time.time()-act)
# 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].cpu()) # 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)
plot_images_and_masks(im, output_to_target(preds, max_det=15), plot_masks, paths,
save_dir / f'val_batch{batch_i}_pred.jpg', names) # pred
# callbacks.run('on_val_batch_end')
# Compute metrics
stats = [torch.cat(x, 0).cpu().numpy() for x in zip(*stats)] # to numpy
if len(stats) and stats[0].any():
results = ap_per_class_box_and_mask(*stats, plot=plots, save_dir=save_dir, names=names)
metrics.update(results)
nt = np.bincount(stats[4].astype(int), minlength=nc) # number of targets per class
# Print results
pf = '%22s' + '%11i' * 2 + '%11.3g' * 8 # print format
LOGGER.info(pf % ("all", seen, nt.sum(), *metrics.mean_results()))
if nt.sum() == 0:
LOGGER.warning(f'WARNING ⚠️ no labels found in {task} set, can not compute metrics without labels')
# Print results per class
if (verbose or (nc < 50 and not training)) and nc > 1 and len(stats):
for i, c in enumerate(metrics.ap_class_index):
LOGGER.info(pf % (names[c], seen, nt[c], *metrics.class_result(i)))
# Print speeds
t = tuple(x.t / seen * 1E3 for x in dt) # speeds per image
if not training:
shape = (batch_size, 3, imgsz, imgsz)
LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {shape}' % t)
# Plots
if plots:
confusion_matrix.plot(save_dir=save_dir, names=list(names.values()))
# callbacks.run('on_val_end')
mp_bbox, mr_bbox, map50_bbox, map_bbox, mp_mask, mr_mask, map50_mask, map_mask = metrics.mean_results()
# Save JSON
if save_json and len(jdict):
w = Path(weights[0] if isinstance(weights, list) else weights).stem if weights is not None else '' # weights
anno_json = str(Path(data.get('path', '../coco')) / 'annotations/instances_val2017.json') # annotations json
pred_json = str(save_dir / f"{w}_predictions.json") # predictions json
LOGGER.info(f'\nEvaluating pycocotools mAP... saving {pred_json}...')
with open(pred_json, 'w') as f:
json.dump(jdict, f)
try: # https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb
anno = COCO(anno_json) # init annotations api
pred = anno.loadRes(pred_json) # init predictions api
results = []
for eval in COCOeval(anno, pred, 'bbox'), COCOeval(anno, pred, 'segm'):
if is_coco:
eval.params.imgIds = [int(Path(x).stem) for x in dataloader.dataset.im_files] # img ID to evaluate
eval.evaluate()
eval.accumulate()
eval.summarize()
results.extend(eval.stats[:2]) # update results (mAP@0.5:0.95, mAP@0.5)
map_bbox, map50_bbox, map_mask, map50_mask = results
except Exception as e:
LOGGER.info(f'pycocotools unable to run: {e}')
# Return results
model.float() # for training
if not training:
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}")
final_metric = mp_bbox, mr_bbox, map50_bbox, map_bbox, mp_mask, mr_mask, map50_mask, map_mask
return (*final_metric, *(loss.cpu() / len(dataloader)).tolist()), metrics.get_maps(nc), t
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--data', type=str, default=ROOT / 'data/BCC.yaml', help='dataset.yaml path')
parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'runs_2/train-seg/base/weights/best.pt', help='model path(s)')
parser.add_argument('--batch-size', type=int, default=1, help='batch size')
parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='inference size (pixels)')
parser.add_argument('--conf-thres', type=float, default=0.01, help='confidence threshold')
parser.add_argument('--iou-thres', type=float, default=0.45, help='NMS IoU threshold')
parser.add_argument('--max-det', type=int, default=300, help='maximum detections per image')
parser.add_argument('--task', default='val', help='train, val, test, speed or study')
parser.add_argument('--device', default='6', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')
parser.add_argument('--single-cls', action='store_true', help='treat as single-class dataset')
parser.add_argument('--augment', action='store_true', help='augmented inference')
parser.add_argument('--verbose', action='store_true', help='report mAP by class')
parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
parser.add_argument('--save-hybrid', action='store_true', help='save label+prediction hybrid results to *.txt')
parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
parser.add_argument('--save-json', action='store_true', help='save a COCO-JSON results file')
parser.add_argument('--project', default=ROOT / 'runs_2/val_test', help='save results to project/name')
parser.add_argument('--name', default='base', help='save to project/name')
parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
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.data = check_yaml(opt.data) # check YAML
# opt.save_json |= opt.data.endswith('coco.yaml')
opt.save_txt |= opt.save_hybrid
print_args(vars(opt))
return opt
def main(opt):
check_requirements(requirements=ROOT / 'requirements.txt', exclude=('tensorboard', 'thop'))
if opt.task in ('train', 'val', 'test'): # run normally
if opt.conf_thres > 0.001: # https://github.com/ultralytics/yolov5/issues/1466
LOGGER.warning(f'WARNING ⚠️ confidence threshold {opt.conf_thres} > 0.001 produces invalid results')
if opt.save_hybrid:
LOGGER.warning('WARNING ⚠️ --save-hybrid returns high mAP from hybrid labels, not from predictions alone')
run(**vars(opt))
else:
weights = opt.weights if isinstance(opt.weights, list) else [opt.weights]
opt.half = torch.cuda.is_available() and opt.device != 'cpu' # FP16 for fastest results
if opt.task == 'speed': # speed benchmarks
# python val.py --task speed --data coco.yaml --batch 1 --weights yolov5n.pt yolov5s.pt...
opt.conf_thres, opt.iou_thres, opt.save_json = 0.25, 0.45, False
for opt.weights in weights:
run(**vars(opt), plots=False)
elif opt.task == 'study': # speed vs mAP benchmarks
# python val.py --task study --data coco.yaml --iou 0.7 --weights yolov5n.pt yolov5s.pt...
for opt.weights in weights:
f = f'study_{Path(opt.data).stem}_{Path(opt.weights).stem}.txt' # filename to save to
x, y = list(range(256, 1536 + 128, 128)), [] # x axis (image sizes), y axis
for opt.imgsz in x: # img-size
LOGGER.info(f'\nRunning {f} --imgsz {opt.imgsz}...')
r, _, t = run(**vars(opt), plots=False)
y.append(r + t) # results and times
np.savetxt(f, y, fmt='%10.4g') # save
os.system('zip -r study.zip study_*.txt') | plot_val_study(x=x) # plot | 22 | 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 | 16,010 | -1, self.depth_channels + 1)[:, 1:]
return gt_depths.float()
def eval_step(self, batch, batch_idx, prefix: str):
(sweep_imgs, mats, img_metas, _, _, _, _, pts_pv) = batch
if torch.cuda.is_available():
if self.return_image:
sweep_imgs = sweep_imgs.cuda()
for key, value in mats.items():
mats[key] = value.cuda()
if self.return_radar_pv:
pts_pv = pts_pv.cuda()
preds = self(sweep_imgs, mats,
pts_pv=pts_pv,
is_train=False)
if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):
results = self.model.module.get_bboxes(preds, img_metas)
else:
results = self.model.get_bboxes(preds, img_metas)
for i in range(len(results)):
results[i][0] = results[i][0].tensor.detach().cpu().numpy()
results[i][1] = results[i][1].detach().cpu().numpy()
results[i][2] = results[i][2].detach().cpu().numpy()
results[i].append(img_metas[i])
return results
def validation_epoch_end(self, validation_step_outputs):
detection_losses = list()
heatmap_losses = list()
bbox_losses = list()
depth_losses = list()
for validation_step_output in validation_step_outputs:
detection_losses.append(validation_step_output[0])
heatmap_losses.append(validation_step_output[1])
bbox_losses.append(validation_step_output[2])
depth_losses.append(validation_step_output[3])
synchronize()
self.log('val/detection', torch.mean(torch.stack(detection_losses)), on_epoch=True)
self.log('val/heatmap', torch.mean(torch.stack(heatmap_losses)), on_epoch=True)
self.log('val/bbox', torch.mean(torch.stack(bbox_losses)), on_epoch=True)
self.log('val/depth', torch.mean(torch.stack(depth_losses)), on_epoch=True)
def validation_step(self, batch, batch_idx):
(sweep_imgs, mats, _, gt_boxes_3d, gt_labels_3d, _, depth_labels, pts_pv) = batch
if torch.cuda.is_available():
if self.return_image:
sweep_imgs = sweep_imgs.cuda()
for key, value in mats.items():
mats[key] = value.cuda()
if self.return_radar_pv:
pts_pv = pts_pv.cuda()
gt_boxes_3d = [gt_box.cuda() for gt_box in gt_boxes_3d]
gt_labels_3d = [gt_label.cuda() for gt_label in gt_labels_3d]
with torch.no_grad():
preds, depth_preds = self(sweep_imgs, mats,
pts_pv=pts_pv,
is_train=True)
targets = self.model.get_targets(gt_boxes_3d, gt_labels_3d)
loss_detection, loss_heatmap, loss_bbox = self.model.loss(targets, preds)
if len(depth_labels.shape) == 5:
# only key-frame will calculate depth loss
depth_labels = depth_labels[:, 0, ...].contiguous()
loss_depth = self.get_depth_loss(depth_labels.cuda(), depth_preds, weight=3.)
return loss_detection, loss_heatmap, loss_bbox, loss_depth
def test_epoch_end(self, test_step_outputs):
all_pred_results = list()
all_img_metas = list()
for test_step_output in test_step_outputs:
for i in range(len(test_step_output)):
all_pred_results.append(test_step_output[i][:3])
all_img_metas.append(test_step_output[i][3])
synchronize()
# TODO: Change another way.
dataset_length = len(self.val_dataloader().dataset)
all_pred_results = sum(
map(list, zip(*all_gather_object(all_pred_results))),
[])[:dataset_length]
all_img_metas = sum(map(list, zip(*all_gather_object(all_img_metas))),
[])[:dataset_length]
if self.global_rank == 0:
self.evaluator.evaluate(all_pred_results, all_img_metas)
def configure_optimizers(self):
optimizer = build_optimizer(self.model, self.optimizer_config)
scheduler = MultiStepLR(optimizer, [19, 23])
return [[optimizer], [scheduler]]
def train_dataloader(self):
train_dataset = NuscDatasetRadarDet(
ida_aug_conf=self.ida_aug_conf,
bda_aug_conf=self.bda_aug_conf,
rda_aug_conf=self.rda_aug_conf,
img_backbone_conf=self.backbone_img_conf,
classes=self.class_names,
data_root=self.data_root,
info_paths=self.train_info_paths,
is_train=True,
use_cbgs=self.data_use_cbgs,
img_conf=self.img_conf,
load_interval=self.load_interval,
num_sweeps=self.num_sweeps,
sweep_idxes=self.sweep_idxes,
key_idxes=self.key_idxes,
return_image=self.return_image,
return_depth=self.return_depth,
return_radar_pv=self.return_radar_pv,
remove_z_axis=self.remove_z_axis,
depth_path='depth_gt',
radar_pv_path='radar_pv_filter'
)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=self.batch_size_per_device,
num_workers=4,
drop_last=True,
shuffle=False,
| # 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,
self.head_conf)
self.mode = 'valid'
self.img_conf = img_conf
self.data_use_cbgs = False
self.load_interval = 1
self.num_sweeps = 1
self.sweep_idxes = list()
self.key_idxes = list()
self.data_return_depth = True
self.downsample_factor = self.backbone_img_conf['downsample_factor']
self.dbound = self.backbone_img_conf['d_bound']
self.depth_channels = int(
(self.dbound[1] - self.dbound[0]) / self.dbound[2])
self.use_fusion = False
self.train_info_paths = 'data/nuScenes/nuscenes_infos_train.pkl'
self.val_info_paths = 'data/nuScenes/nuscenes_infos_val.pkl'
self.predict_info_paths = 'data/nuScenes/nuscenes_infos_test.pkl'
self.return_image = True
self.return_depth = True
self.return_radar_pv = False
self.remove_z_axis = True
def forward(self, sweep_imgs, mats, is_train=False, **inputs):
return self.model(sweep_imgs, mats, is_train=is_train)
def training_step(self, batch):
if self.global_rank == 0:
for pg in self.trainer.optimizers[0].param_groups:
self.log('learning_rate', pg["lr"])
(sweep_imgs, mats, _, gt_boxes_3d, gt_labels_3d, _, depth_labels, pts_pv) = batch
if torch.cuda.is_available():
if self.return_image:
sweep_imgs = sweep_imgs.cuda()
for key, value in mats.items():
mats[key] = value.cuda()
if self.return_radar_pv:
pts_pv = pts_pv.cuda()
gt_boxes_3d = [gt_box.cuda() for gt_box in gt_boxes_3d]
gt_labels_3d = [gt_label.cuda() for gt_label in gt_labels_3d]
preds, depth_preds = self(sweep_imgs, mats,
pts_pv=pts_pv,
is_train=True)
targets = self.model.get_targets(gt_boxes_3d, gt_labels_3d)
loss_detection, loss_heatmap, loss_bbox = self.model.loss(targets, preds)
if len(depth_labels.shape) == 5:
# only key-frame will calculate depth loss
depth_labels = depth_labels[:, 0, ...].contiguous()
loss_depth = self.get_depth_loss(depth_labels.cuda(), depth_preds)
self.log('train/detection', loss_detection)
self.log('train/heatmap', loss_heatmap)
self.log('train/bbox', loss_bbox)
self.log('train/depth', loss_depth)
return loss_detection + loss_depth
def get_depth_loss(self, depth_labels, depth_preds, weight=3.):
depth_labels = self.get_downsampled_gt_depth(depth_labels)
depth_preds = depth_preds.permute(0, 2, 3, 1).contiguous().view(
-1, self.depth_channels)
fg_mask = torch.max(depth_labels, dim=1).values > 0.0
with autocast(enabled=False):
loss_depth = (F.binary_cross_entropy(
depth_preds[fg_mask],
depth_labels[fg_mask],
reduction='none',
).sum() / max(1.0, fg_mask.sum()))
return weight * loss_depth
def get_downsampled_gt_depth(self, gt_depths):
"""
Input:
gt_depths: [B, N, H, W]
Output:
gt_depths: [B*N*h*w, d]
"""
B, N, H, W = gt_depths.shape
gt_depths = gt_depths.view(
B * N,
H // self.downsample_factor,
self.downsample_factor,
W // self.downsample_factor,
self.downsample_factor,
1,
)
gt_depths = gt_depths.permute(0, 1, 3, 5, 2, 4).contiguous()
gt_depths = gt_depths.view(
-1, self.downsample_factor * self.downsample_factor)
gt_depths_tmp = torch.where(gt_depths == 0.0,
1e5 * torch.ones_like(gt_depths),
gt_depths)
gt_depths = torch.min(gt_depths_tmp, dim=-1).values
gt_depths = gt_depths.view(B * N, H // self.downsample_factor,
W // self.downsample_factor)
gt_depths = (gt_depths -
(self.dbound[0] - self.dbound[2])) / self.dbound[2]
gt_depths = torch.where(
(gt_depths < self.depth_channels + 1) & (gt_depths > 0.),
gt_depths, torch.zeros_like(gt_depths))
gt_depths = F.one_hot(gt_depths.long(),
num_classes=self.depth_channels + 1).view(
-1, self.depth_channels + 1)[:, 1:]
return gt_depths.float()
def eval_step(self, batch, batch_idx, prefix: str):
(sweep_imgs, mats, img_metas, _, _, _, _, pts_pv) = batch
if torch.cuda.is_available():
if self.return_image:
sweep_imgs = sweep_imgs.cuda()
for key, value in mats.items():
mats[key] = value.cuda()
if self.return_radar_pv:
pts_pv = pts_pv.cuda()
preds = self(sweep_imgs, mats,
pts_pv=pts_pv,
is_train=False)
if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):
results = self.model.module.get_bboxes(preds, img_metas)
else:
results = self.model.get_bboxes(preds, img_metas)
for i in range(len(results)):
results[i][0] = results[i][0].tensor.detach().cpu().numpy()
results[i][1] = results[i][1].detach().cpu().numpy()
results[i][2] = results[i][2].detach().cpu().numpy()
results[i].append(img_metas[i])
return results
def validation_epoch_end(self, validation_step_outputs):
detection_losses = list()
heatmap_losses = list()
bbox_losses = list()
depth_losses = list()
for validation_step_output in validation_step_outputs:
detection_losses.append(validation_step_output[0])
heatmap_losses.append(validation_step_output[1])
bbox_losses.append(validation_step_output[2])
depth_losses.append(validation_step_output[3])
synchronize()
self.log('val/detection', torch.mean(torch.stack(detection_losses)), on_epoch=True)
self.log('val/heatmap', torch.mean(torch.stack(heatmap_losses)), on_epoch=True)
self.log('val/bbox', torch.mean(torch.stack(bbox_losses)), on_epoch=True)
self.log('val/depth', torch.mean(torch.stack(depth_losses)), on_epoch=True)
def validation_step(self, batch, batch_idx):
(sweep_imgs, mats, _, gt_boxes_3d, gt_labels_3d, _, depth_labels, pts_pv) = batch
if torch.cuda.is_available():
if self.return_image:
sweep_imgs = sweep_imgs.cuda()
for key, value in mats.items():
mats[key] = value.cuda()
if self.return_radar_pv:
pts_pv = pts_pv.cuda()
gt_boxes_3d = [gt_box.cuda() for gt_box in gt_boxes_3d]
gt_labels_3d = [gt_label.cuda() for gt_label in gt_labels_3d]
with torch.no_grad():
preds, depth_preds = self(sweep_imgs, mats,
pts_pv=pts_pv,
is_train=True)
targets = self.model.get_targets(gt_boxes_3d, gt_labels_3d)
loss_detection, loss_heatmap, loss_bbox = self.model.loss(targets, preds)
if len(depth_labels.shape) == 5:
# only key-frame will calculate depth loss
depth_labels = depth_labels[:, 0, ...].contiguous()
loss_depth = self.get_depth_loss(depth_labels.cuda(), depth_preds, weight=3.)
return loss_detection, loss_heatmap, loss_bbox, loss_depth
def test_epoch_end(self, test_step_outputs):
all_pred_results = list()
all_img_metas = list()
for test_step_output in test_step_outputs:
for i in range(len(test_step_output)):
all_pred_results.append(test_step_output[i][:3])
all_img_metas.append(test_step_output[i][3])
synchronize()
# TODO: Change another way.
dataset_length = len(self.val_dataloader().dataset)
all_pred_results = sum(
map(list, zip(*all_gather_object(all_pred_results))),
[])[:dataset_length]
all_img_metas = sum(map(list, zip(*all_gather_object(all_img_metas))),
[])[:dataset_length]
if self.global_rank == 0:
self.evaluator.evaluate(all_pred_results, all_img_metas)
def configure_optimizers(self):
optimizer = build_optimizer(self.model, self.optimizer_config)
scheduler = MultiStepLR(optimizer, [19, 23])
return [[optimizer], [scheduler]]
def train_dataloader(self):
train_dataset = NuscDatasetRadarDet(
ida_aug_conf=self.ida_aug_conf,
bda_aug_conf=self.bda_aug_conf,
rda_aug_conf=self.rda_aug_conf,
img_backbone_conf=self.backbone_img_conf,
classes=self.class_names,
data_root=self.data_root,
info_paths=self.train_info_paths,
is_train=True,
use_cbgs=self.data_use_cbgs,
img_conf=self.img_conf,
load_interval=self.load_interval,
num_sweeps=self.num_sweeps,
sweep_idxes=self.sweep_idxes,
key_idxes=self.key_idxes,
return_image=self.return_image,
return_depth=self.return_depth,
return_radar_pv=self.return_radar_pv,
remove_z_axis=self.remove_z_axis,
depth_path='depth_gt',
radar_pv_path='radar_pv_filter'
)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=self.batch_size_per_device,
num_workers=4,
drop_last=True,
shuffle=False, | collate_fn=partial(collate_fn, | 1 | 2023-12-06 14:57:49+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 | 14,828 | #!/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):
| #!/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] | 14 | 2023-12-13 03:09:32+00:00 | 24k |
MarilynKeller/aitviewer-skel | aitviewer/scene/scene.py | [
{
"identifier": "CONFIG",
"path": "aitviewer/configuration.py",
"snippet": "CONFIG = Configuration()"
},
{
"identifier": "CoordinateSystem",
"path": "aitviewer/renderables/coordinate_system.py",
"snippet": "class CoordinateSystem(RigidBodies):\n \"\"\"\n Render a coordinate system ... | import moderngl
import numpy as np
from aitviewer.configuration import CONFIG as C
from aitviewer.renderables.coordinate_system import CoordinateSystem
from aitviewer.renderables.lines import Lines2D
from aitviewer.renderables.plane import ChessboardPlane
from aitviewer.scene.camera import ViewerCamera
from aitviewer.scene.light import Light
from aitviewer.scene.node import Node
from aitviewer.utils.utils import (
compute_union_of_bounds,
compute_union_of_current_bounds,
) | 17,064 | # Copyright (C) 2023 ETH Zurich, Manuel Kaufmann, Velko Vechev, Dario Mylonopoulos
class Scene(Node):
"""Generic scene node"""
def __init__(self, **kwargs):
"""Create a scene with a name."""
kwargs["gui_material"] = False
super(Scene, self).__init__(**kwargs)
# References resources in the scene
self.lights = []
self.camera = None
# Scene has a reference to ctx
self.ctx = None
self.backface_culling = True
| # Copyright (C) 2023 ETH Zurich, Manuel Kaufmann, Velko Vechev, Dario Mylonopoulos
class Scene(Node):
"""Generic scene node"""
def __init__(self, **kwargs):
"""Create a scene with a name."""
kwargs["gui_material"] = False
super(Scene, self).__init__(**kwargs)
# References resources in the scene
self.lights = []
self.camera = None
# Scene has a reference to ctx
self.ctx = None
self.backface_culling = True | self.fps = C.scene_fps | 3 | 2023-12-07 16:13:50+00:00 | 24k |
nexB/dejacode | reporting/admin.py | [
{
"identifier": "DataspacedAdmin",
"path": "dje/admin.py",
"snippet": "class DataspacedAdmin(\n DataspacedFKMixin,\n ProtectedFieldsMixin,\n AdvancedSearchAdminMixin,\n HistoryAdminMixin,\n admin.ModelAdmin,\n):\n formfield_overrides = {\n models.DateField: {\"widget\": AdminDat... | from django.contrib import admin
from django.contrib.admin.views.main import ORDER_VAR
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import NON_FIELD_ERRORS
from django.db.models import PositiveSmallIntegerField
from django.forms import HiddenInput
from django.utils.html import format_html
from django.utils.http import urlencode
from django.utils.translation import gettext_lazy as _
from dje.admin import DataspacedAdmin
from dje.admin import DataspacedFKMixin
from dje.admin import dejacode_site
from dje.admin import get_additional_information_fieldset
from dje.client_data import add_client_data
from dje.filters import MissingInFilter
from dje.list_display import AsJoinList
from dje.list_display import AsLink
from dje.utils import CHANGELIST_LINK_TEMPLATE
from dje.utils import queryset_to_html_list
from reporting.filters import ReportingQueryListFilter
from reporting.forms import ColumnTemplateForm
from reporting.forms import QueryForm
from reporting.forms import ReportForm
from reporting.forms import ReportMassUpdateForm
from reporting.forms import get_model_data_for_column_template
from reporting.forms import get_model_data_for_order_field
from reporting.forms import get_model_data_for_query
from reporting.inlines import ColumnTemplateAssignedFieldInline
from reporting.inlines import FilterInline
from reporting.inlines import OrderFieldInline
from reporting.introspection import get_model_label
from reporting.models import Card
from reporting.models import CardLayout
from reporting.models import ColumnTemplate
from reporting.models import Filter
from reporting.models import LayoutAssignedCard
from reporting.models import OrderField
from reporting.models import Query
from reporting.models import Report | 18,290 | data = form.cleaned_data
# The 'id' field is a ModelChoiceField which validates to a model instance
id = form.cleaned_data.get("id")
if id:
pk = id.pk
d = {
"pk": pk,
"field_name": data.get("field_name", ""),
"lookup": data.get("lookup", ""),
"value": data.get("value", ""),
"runtime_parameter": data.get("runtime_parameter", ""),
"negate": data.get("negate", ""),
}
filters.append(d)
return filters
@staticmethod
def get_order_fields_as_dicts(request, forms):
order_fields = []
for form in forms:
pk = None
if request.method == "GET":
data = form.initial
pk = form.instance.pk
if request.method == "POST":
data = form.cleaned_data
# The 'id' field is a ModelChoiceField which validates to a
# model instance
id = form.cleaned_data.get("id")
if id:
pk = id.pk
d = {
"pk": pk,
"field_name": data.get("field_name", ""),
"seq": data.get("seq", ""),
"sort": data.get("sort", ""),
}
order_fields.append(d)
return order_fields
def _changeform_view(self, request, object_id, form_url, extra_context):
response = super()._changeform_view(request, object_id, form_url, extra_context)
if response.status_code == 200:
if request.method == "POST" and "_popup" in request.GET:
return response
add_client_data(request, **self.get_client_data(request))
inline_admin_formsets = response.context_data["inline_admin_formsets"]
filter_admin_formsets = [
formset
for formset in inline_admin_formsets
if formset.opts.__class__ == FilterInline
]
if not filter_admin_formsets:
return response
filter_formset = filter_admin_formsets[0].formset
order_field_admin_formsets = [
formset
for formset in inline_admin_formsets
if formset.opts.__class__ == OrderFieldInline
]
if not order_field_admin_formsets:
return response
order_field_formset = order_field_admin_formsets[0].formset
add_client_data(
request,
filter_formset_prefix=filter_formset.prefix,
filter_formset_initial_form_count=filter_formset.initial_form_count(),
filter_formset_has_errors=any(filter_formset.errors),
filter_formset_all_errors=flatten_errors(filter_formset.errors),
order_field_formset_prefix=order_field_formset.prefix,
order_field_formset_initial_form_count=order_field_formset.initial_form_count(),
filters=self.get_filters_as_dicts(request, filter_formset.forms),
order_fields=self.get_order_fields_as_dicts(request, order_field_formset.forms),
)
return response
@admin.register(ColumnTemplate, site=dejacode_site)
class ColumnTemplateAdmin(DataspacedAdmin):
form = ColumnTemplateForm
list_display = ("name", "description", "content_type", "get_field_names", "get_dataspace")
list_filter = DataspacedAdmin.list_filter + (
"content_type",
MissingInFilter,
)
fieldsets = (
("", {"fields": ("name", "description", "content_type")}),
get_additional_information_fieldset(),
)
search_fields = ("name",)
inlines = (ColumnTemplateAssignedFieldInline,)
change_form_template = "admin/reporting/columntemplate/change_form.html"
long_description = (
"A Column template provides you with the ability to identify the data "
"columns, with your own labels, to appear in a report using the column "
"order that you specify. You can combine a column template with any "
"query of the same object type (license, component, owner) to create "
"your own Reports."
)
@admin.display(description=_("Assigned fields"))
def get_field_names(self, instance):
field_names = [assigned_field.field_name for assigned_field in instance.fields.all()]
return format_html("<br>".join(field_names))
def get_queryset(self, request):
qs = super().get_queryset(request)
return qs.select_related("content_type").prefetch_related("fields")
def get_client_data(self, request):
| #
# 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.
#
def get_content_type_map():
return dict(
[
(c.pk, get_model_label(c.model_class()))
for c in ContentType.objects.all()
if c.model_class()
]
)
def flatten_errors(formset_errors):
"""
Convert a FormSet.errors, which is a list of dicts, into a flat list of
error messages.
"""
flattened = []
for error_dict in formset_errors:
for field_name, errors in error_dict.items():
for error in errors.as_data():
message = list(error)[0]
if field_name != NON_FIELD_ERRORS:
val = f'Field "{field_name}": {message}'
else:
val = message
flattened.append(val)
return flattened
@admin.register(Query, site=dejacode_site)
class QueryAdmin(DataspacedAdmin):
form = QueryForm
change_form_template = "admin/reporting/query/change_form.html"
# We are using an inline for ``Filter``, but are not rendering the standard
# Django inline UI in favor of a custom Ember-based inline UI.
inlines = [FilterInline, OrderFieldInline]
fieldsets = (
("", {"fields": ("name", "description", "content_type", "operator")}),
get_additional_information_fieldset(),
("Preview", {"fields": ("get_preview",)}),
)
readonly_fields = DataspacedAdmin.readonly_fields + ("get_preview",)
list_display = ("name", "description", "content_type", "operator", "get_dataspace")
list_filter = DataspacedAdmin.list_filter + (
"content_type",
MissingInFilter,
)
search_fields = ("name",)
long_description = (
"A Query provides you with the ability to select data from application "
"licenses, components, and owners using the criteria that meet your "
"business requirements. You can access a changelist of the data you "
"select using the Preview feature, and you can also combine a query "
"with a column template to create your own Report."
)
def get_queryset(self, request):
return (
super()
.get_queryset(request)
.select_related(
"content_type",
)
.prefetch_related(
"filters",
"order_fields",
)
)
def get_object(self, request, object_id, from_field=None):
"""
Injects the `request` on the object instance.
Required for `get_preview()`.
"""
obj = super().get_object(request, object_id, from_field)
if obj:
obj._request = request
return obj
@admin.display(description=_("Results"))
def get_preview(self, query_instance):
"""
Return a preview of the Query results.
The logic starts with a count and will not eval/render the QuerySet
if over 100 results.
Between 1 and 100 results, a 5 items list will be display, next to a
link to the changelist for the QuerySet. See #9248.
"""
if query_instance.filters.count() == 0:
return "No filters defined"
request = getattr(query_instance, "_request", None)
if not request:
return
try:
qs = query_instance.get_qs(user=request.user)
qs_count = qs.count()
except Exception as e:
return f"Error: {e}"
if not qs_count:
return "No results."
model = query_instance.content_type.model_class()
model_admin = dejacode_site._registry.get(model)
if not model_admin: # Models like Request do not have a ModelAdmin.
return f"{qs_count} results."
params = {ReportingQueryListFilter.parameter_name: query_instance.id}
order_list = query_instance.get_order_list_for_url(request, model_admin)
if order_list:
params[ORDER_VAR] = ".".join(order_list)
if qs_count >= 100:
url = query_instance.get_changelist_url()
href = f"{url}?{urlencode(params)}"
return format_html(
CHANGELIST_LINK_TEMPLATE, href, qs_count, model._meta.verbose_name_plural
)
return queryset_to_html_list(qs, params, qs_limit=5)
def get_query_options(self, request):
"""
Return a dictionary of Query options to be injected in the client_data
and user for the "Use a query as value" list of choices.
The QuerySet is reused from self.get_queryset() and scoped to the
current object dataspace on edition, or on the current user dataspace
on addition.
"""
# The object instance is set on the request in the DataspacedAdmin.get_form() method
if request._object: # Edition
dataspace = request._object.dataspace
else: # Addition
dataspace = request.user.dataspace
queryset = self.get_queryset(request).scope(dataspace)
return [
{
"id": query.pk,
"name": query.name,
"content_type": get_model_label(query.content_type.model_class()),
}
for query in queryset
]
def get_client_data(self, request):
return {
"model_data": get_model_data_for_query(),
"order_field_model_data": get_model_data_for_order_field(),
"content_type_map": get_content_type_map(),
"lookups": [
{
"label": v,
"value": k,
}
for k, v in Filter.LOOKUP_CHOICES
],
"query_options": self.get_query_options(request),
"sort_options": [v for k, v in OrderField.SORT_CHOICES],
}
@staticmethod
def get_filters_as_dicts(request, forms):
filters = []
for form in forms:
pk = None
if request.method == "GET":
data = form.initial
pk = form.instance.pk
if request.method == "POST":
data = form.cleaned_data
# The 'id' field is a ModelChoiceField which validates to a model instance
id = form.cleaned_data.get("id")
if id:
pk = id.pk
d = {
"pk": pk,
"field_name": data.get("field_name", ""),
"lookup": data.get("lookup", ""),
"value": data.get("value", ""),
"runtime_parameter": data.get("runtime_parameter", ""),
"negate": data.get("negate", ""),
}
filters.append(d)
return filters
@staticmethod
def get_order_fields_as_dicts(request, forms):
order_fields = []
for form in forms:
pk = None
if request.method == "GET":
data = form.initial
pk = form.instance.pk
if request.method == "POST":
data = form.cleaned_data
# The 'id' field is a ModelChoiceField which validates to a
# model instance
id = form.cleaned_data.get("id")
if id:
pk = id.pk
d = {
"pk": pk,
"field_name": data.get("field_name", ""),
"seq": data.get("seq", ""),
"sort": data.get("sort", ""),
}
order_fields.append(d)
return order_fields
def _changeform_view(self, request, object_id, form_url, extra_context):
response = super()._changeform_view(request, object_id, form_url, extra_context)
if response.status_code == 200:
if request.method == "POST" and "_popup" in request.GET:
return response
add_client_data(request, **self.get_client_data(request))
inline_admin_formsets = response.context_data["inline_admin_formsets"]
filter_admin_formsets = [
formset
for formset in inline_admin_formsets
if formset.opts.__class__ == FilterInline
]
if not filter_admin_formsets:
return response
filter_formset = filter_admin_formsets[0].formset
order_field_admin_formsets = [
formset
for formset in inline_admin_formsets
if formset.opts.__class__ == OrderFieldInline
]
if not order_field_admin_formsets:
return response
order_field_formset = order_field_admin_formsets[0].formset
add_client_data(
request,
filter_formset_prefix=filter_formset.prefix,
filter_formset_initial_form_count=filter_formset.initial_form_count(),
filter_formset_has_errors=any(filter_formset.errors),
filter_formset_all_errors=flatten_errors(filter_formset.errors),
order_field_formset_prefix=order_field_formset.prefix,
order_field_formset_initial_form_count=order_field_formset.initial_form_count(),
filters=self.get_filters_as_dicts(request, filter_formset.forms),
order_fields=self.get_order_fields_as_dicts(request, order_field_formset.forms),
)
return response
@admin.register(ColumnTemplate, site=dejacode_site)
class ColumnTemplateAdmin(DataspacedAdmin):
form = ColumnTemplateForm
list_display = ("name", "description", "content_type", "get_field_names", "get_dataspace")
list_filter = DataspacedAdmin.list_filter + (
"content_type",
MissingInFilter,
)
fieldsets = (
("", {"fields": ("name", "description", "content_type")}),
get_additional_information_fieldset(),
)
search_fields = ("name",)
inlines = (ColumnTemplateAssignedFieldInline,)
change_form_template = "admin/reporting/columntemplate/change_form.html"
long_description = (
"A Column template provides you with the ability to identify the data "
"columns, with your own labels, to appear in a report using the column "
"order that you specify. You can combine a column template with any "
"query of the same object type (license, component, owner) to create "
"your own Reports."
)
@admin.display(description=_("Assigned fields"))
def get_field_names(self, instance):
field_names = [assigned_field.field_name for assigned_field in instance.fields.all()]
return format_html("<br>".join(field_names))
def get_queryset(self, request):
qs = super().get_queryset(request)
return qs.select_related("content_type").prefetch_related("fields")
def get_client_data(self, request): | model_data = get_model_data_for_column_template(request.user.dataspace) | 15 | 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 | 17,623 | l.bias.data = l.bias.data.to(dtype)
if isinstance(l, (nn.MultiheadAttention, Attention)):
for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
tensor = getattr(l, attr)
if tensor is not None:
tensor.data = tensor.data.to(dtype)
for name in ["text_projection", "proj"]:
if hasattr(l, name):
attr = getattr(l, name)
if attr is not None:
attr.data = attr.data.to(dtype)
model.apply(_convert_weights)
convert_weights_to_fp16 = convert_weights_to_lp # backwards compat
# used to maintain checkpoint compatibility
def convert_to_custom_text_state_dict(state_dict: dict):
if 'text_projection' in state_dict:
# old format state_dict, move text tower -> .text
new_state_dict = {}
for k, v in state_dict.items():
if any(k.startswith(p) for p in (
'text_projection',
'positional_embedding',
'token_embedding',
'transformer',
'ln_final',
)):
k = 'text.' + k
new_state_dict[k] = v
return new_state_dict
return state_dict
def build_model_from_openai_state_dict(
state_dict: dict,
quick_gelu=True,
cast_dtype=torch.float16,
):
vit = "visual.proj" in state_dict
if vit:
vision_width = state_dict["visual.conv1.weight"].shape[0]
vision_layers = len(
[k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")])
vision_patch_size = state_dict["visual.conv1.weight"].shape[-1]
grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5)
image_size = vision_patch_size * grid_size
else:
counts: list = [
len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]]
vision_layers = tuple(counts)
vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0]
output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5)
vision_patch_size = None
assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0]
image_size = output_width * 32
embed_dim = state_dict["text_projection"].shape[1]
context_length = state_dict["positional_embedding"].shape[0]
vocab_size = state_dict["token_embedding.weight"].shape[0]
transformer_width = state_dict["ln_final.weight"].shape[0]
transformer_heads = transformer_width // 64
transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith(f"transformer.resblocks")))
vision_cfg = CLIPVisionCfg(
layers=vision_layers,
width=vision_width,
patch_size=vision_patch_size,
image_size=image_size,
)
text_cfg = CLIPTextCfg(
context_length=context_length,
vocab_size=vocab_size,
width=transformer_width,
heads=transformer_heads,
layers=transformer_layers,
)
model = CLIP(
embed_dim,
vision_cfg=vision_cfg,
text_cfg=text_cfg,
quick_gelu=quick_gelu, # OpenAI models were trained with QuickGELU
cast_dtype=cast_dtype,
)
for key in ["input_resolution", "context_length", "vocab_size"]:
state_dict.pop(key, None)
convert_weights_to_fp16(model) # OpenAI state dicts are partially converted to float16
model.load_state_dict(state_dict)
return model.eval()
def trace_model(model, batch_size=256, device=torch.device('cpu')):
model.eval()
image_size = model.visual.image_size
example_images = torch.ones((batch_size, 3, image_size, image_size), device=device)
example_text = torch.zeros((batch_size, model.context_length), dtype=torch.int, device=device)
model = torch.jit.trace_module(
model,
inputs=dict(
forward=(example_images, example_text),
encode_text=(example_text,),
encode_image=(example_images,)
))
model.visual.image_size = image_size
return model
def resize_pos_embed(state_dict, model, interpolation: str = 'bicubic', antialias: bool = True):
# Rescale the grid of position embeddings when loading from state_dict
old_pos_embed = state_dict.get('visual.positional_embedding', None)
if old_pos_embed is None or not hasattr(model.visual, 'grid_size'):
return
| """ 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(
context_length=text_cfg.context_length,
vocab_size=text_cfg.vocab_size,
width=text_cfg.width,
heads=text_cfg.heads,
layers=text_cfg.layers,
ls_init_value=text_cfg.ls_init_value,
output_dim=embed_dim,
embed_cls=text_cfg.embed_cls,
output_tokens=text_cfg.output_tokens,
pad_id=text_cfg.pad_id,
act_layer=act_layer,
norm_layer=norm_layer,
)
return text
class CLIP(nn.Module):
output_dict: torch.jit.Final[bool]
def __init__(
self,
embed_dim: int,
vision_cfg: CLIPVisionCfg,
text_cfg: CLIPTextCfg,
quick_gelu: bool = False,
cast_dtype: Optional[torch.dtype] = None,
output_dict: bool = False,
freeze_text=True,
):
assert freeze_text, 'For now we must freeze text'
super().__init__()
self.output_dict = output_dict
self.visual = _build_vision_tower(embed_dim, vision_cfg, quick_gelu, cast_dtype)
text = _build_text_tower(embed_dim, text_cfg, quick_gelu, cast_dtype)
if freeze_text:
print(f'Freeze text encoder parameters', flush=True)
for param in text.parameters():
param.requires_grad = False
text.eval()
self.transformer = text.transformer
self.vocab_size = text.vocab_size
self.embed_dim = embed_dim
self.token_embedding = text.token_embedding
self.positional_embedding = text.positional_embedding
self.ln_final = text.ln_final
self.text_projection = text.text_projection
self.register_buffer('attn_mask', text.attn_mask, persistent=False)
self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
def lock_image_tower(self, unlocked_groups=0, freeze_bn_stats=False, **kwargs):
self.visual.lock(unlocked_groups=unlocked_groups, freeze_bn_stats=freeze_bn_stats)
@torch.jit.ignore
def set_grad_checkpointing(self, enable=True):
self.visual.set_grad_checkpointing(enable)
self.transformer.grad_checkpointing = enable
def encode_image(self, image, normalize: bool = False):
features = self.visual(image)
return F.normalize(features, dim=-1) if normalize else features
def encode_dense(self, image, normalize: bool = False, keep_shape=False):
features = self.visual.encode_dense(image, keep_shape=keep_shape)
if normalize:
if keep_shape:
features = F.normalize(features, dim=1)
else:
features = F.normalize(features, dim=-1)
return features
def encode_pseudo_boxes(self, image, normed_boxes, normalize: bool = False,
extract_type='v1'):
features = self.visual.extract_roi_features(image, normed_boxes,
extract_type=extract_type)
if normalize:
features = F.normalize(features, dim=-1)
return features
def _pool_masks(self, image, masks, normalize, mask_attn=False):
if mask_attn:
mask_pooled = self.visual.mask_attn_pool(image, masks)
else:
mask_pooled = self.visual.mask_pool(image, masks)
if normalize:
mask_pooled = F.normalize(mask_pooled, dim=-1)
return mask_pooled
def _pool_masks_v3(self, image, masks, normalize):
mask_pooled_v1, x_dense = self.visual.mask_attn_pool(image, masks, return_dense=True)
x_dense = F.normalize(x_dense, dim=-1).flatten(1, 2) # bs, h*w, c
x_dense = torch.repeat_interleave(
x_dense, torch.tensor([len(m) for m in masks], device=x_dense.device), dim=0)
masks = torch.cat(masks).float().flatten(-2, -1) # bs, h*w
mask_pooled_v2 = (x_dense * masks.unsqueeze(-1)).sum(1) / masks.sum(1, keepdim=True)
if normalize:
mask_pooled_v1 = F.normalize(mask_pooled_v1, dim=-1)
mask_pooled_v2 = F.normalize(mask_pooled_v2, dim=-1)
return mask_pooled_v1, mask_pooled_v2
def encode_masks(self, image, masks, normalize=True, mask_attn=False):
return self._pool_masks(image, masks, normalize, mask_attn)
def encode_text(self, text, normalize: bool = False):
cast_dtype = self.transformer.get_cast_dtype()
x = self.token_embedding(text).to(cast_dtype) # [batch_size, n_ctx, d_model]
x = x + self.positional_embedding.to(cast_dtype)
x = x.permute(1, 0, 2) # NLD -> LND
x = self.transformer(x, attn_mask=self.attn_mask)
x = x.permute(1, 0, 2) # LND -> NLD
x = self.ln_final(x) # [batch_size, n_ctx, transformer.width]
# take features from the eot embedding (eot_token is the highest number in each sequence)
x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
return F.normalize(x, dim=-1) if normalize else x
def forward(self, image, text=None):
image_features = self.encode_image(image, normalize=True)
if text is None:
text_features = None
else:
text_features = self.encode_text(text, normalize=True)
if self.output_dict:
return {
"image_features": image_features,
"text_features": text_features,
"logit_scale": self.logit_scale.exp()
}
return image_features, text_features, self.logit_scale.exp()
def train(self, mode: bool = True):
if not isinstance(mode, bool):
raise ValueError("training mode is expected to be boolean")
self.training = mode
for name, module in self.named_children():
if name == 'visual':
if mode:
logging.info(f'========Set module {name} as train mode========')
else:
logging.info(f'========Set module {name} as eval mode========')
module.train(mode)
else:
logging.info(f'========Set module {name} as eval mode========')
module.train(mode=False)
return self
class CustomTextCLIP(nn.Module):
output_dict: torch.jit.Final[bool]
def __init__(
self,
embed_dim: int,
vision_cfg: CLIPVisionCfg,
text_cfg: CLIPTextCfg,
quick_gelu: bool = False,
cast_dtype: Optional[torch.dtype] = None,
output_dict: bool = False,
):
super().__init__()
self.output_dict = output_dict
self.visual = _build_vision_tower(embed_dim, vision_cfg, quick_gelu, cast_dtype)
self.text = _build_text_tower(embed_dim, text_cfg, quick_gelu, cast_dtype)
self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
def lock_image_tower(self, unlocked_groups=0, freeze_bn_stats=False):
# lock image tower as per LiT - https://arxiv.org/abs/2111.07991
self.visual.lock(unlocked_groups=unlocked_groups, freeze_bn_stats=freeze_bn_stats)
def lock_text_tower(self, unlocked_layers: int = 0, freeze_layer_norm: bool = True):
self.text.lock(unlocked_layers, freeze_layer_norm)
@torch.jit.ignore
def set_grad_checkpointing(self, enable=True):
self.visual.set_grad_checkpointing(enable)
self.text.set_grad_checkpointing(enable)
def encode_pseudo_boxes(self, image, normed_boxes, normalize: bool = False):
features = self.visual.extract_roi_features(image, normed_boxes)
return F.normalize(features, dim=-1) if normalize else features
def encode_image(self, image, normalize: bool = False):
features = self.visual(image)
return F.normalize(features, dim=-1) if normalize else features
def encode_text(self, text, normalize: bool = False):
features = self.text(text)
return F.normalize(features, dim=-1) if normalize else features
def forward(self, image, text):
image_features = self.encode_image(image, normalize=True)
if text is None:
text_features = None
else:
text_features = self.encode_text(text, normalize=True)
if self.output_dict:
return {
"image_features": image_features,
"text_features": text_features,
"logit_scale": self.logit_scale.exp()
}
return image_features, text_features, self.logit_scale.exp()
def convert_weights_to_lp(model: nn.Module, dtype=torch.float16):
"""Convert applicable model parameters to low-precision (bf16 or fp16)"""
def _convert_weights(l):
if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
l.weight.data = l.weight.data.to(dtype)
if l.bias is not None:
l.bias.data = l.bias.data.to(dtype)
if isinstance(l, (nn.MultiheadAttention, Attention)):
for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
tensor = getattr(l, attr)
if tensor is not None:
tensor.data = tensor.data.to(dtype)
for name in ["text_projection", "proj"]:
if hasattr(l, name):
attr = getattr(l, name)
if attr is not None:
attr.data = attr.data.to(dtype)
model.apply(_convert_weights)
convert_weights_to_fp16 = convert_weights_to_lp # backwards compat
# used to maintain checkpoint compatibility
def convert_to_custom_text_state_dict(state_dict: dict):
if 'text_projection' in state_dict:
# old format state_dict, move text tower -> .text
new_state_dict = {}
for k, v in state_dict.items():
if any(k.startswith(p) for p in (
'text_projection',
'positional_embedding',
'token_embedding',
'transformer',
'ln_final',
)):
k = 'text.' + k
new_state_dict[k] = v
return new_state_dict
return state_dict
def build_model_from_openai_state_dict(
state_dict: dict,
quick_gelu=True,
cast_dtype=torch.float16,
):
vit = "visual.proj" in state_dict
if vit:
vision_width = state_dict["visual.conv1.weight"].shape[0]
vision_layers = len(
[k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")])
vision_patch_size = state_dict["visual.conv1.weight"].shape[-1]
grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5)
image_size = vision_patch_size * grid_size
else:
counts: list = [
len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]]
vision_layers = tuple(counts)
vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0]
output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5)
vision_patch_size = None
assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0]
image_size = output_width * 32
embed_dim = state_dict["text_projection"].shape[1]
context_length = state_dict["positional_embedding"].shape[0]
vocab_size = state_dict["token_embedding.weight"].shape[0]
transformer_width = state_dict["ln_final.weight"].shape[0]
transformer_heads = transformer_width // 64
transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith(f"transformer.resblocks")))
vision_cfg = CLIPVisionCfg(
layers=vision_layers,
width=vision_width,
patch_size=vision_patch_size,
image_size=image_size,
)
text_cfg = CLIPTextCfg(
context_length=context_length,
vocab_size=vocab_size,
width=transformer_width,
heads=transformer_heads,
layers=transformer_layers,
)
model = CLIP(
embed_dim,
vision_cfg=vision_cfg,
text_cfg=text_cfg,
quick_gelu=quick_gelu, # OpenAI models were trained with QuickGELU
cast_dtype=cast_dtype,
)
for key in ["input_resolution", "context_length", "vocab_size"]:
state_dict.pop(key, None)
convert_weights_to_fp16(model) # OpenAI state dicts are partially converted to float16
model.load_state_dict(state_dict)
return model.eval()
def trace_model(model, batch_size=256, device=torch.device('cpu')):
model.eval()
image_size = model.visual.image_size
example_images = torch.ones((batch_size, 3, image_size, image_size), device=device)
example_text = torch.zeros((batch_size, model.context_length), dtype=torch.int, device=device)
model = torch.jit.trace_module(
model,
inputs=dict(
forward=(example_images, example_text),
encode_text=(example_text,),
encode_image=(example_images,)
))
model.visual.image_size = image_size
return model
def resize_pos_embed(state_dict, model, interpolation: str = 'bicubic', antialias: bool = True):
# Rescale the grid of position embeddings when loading from state_dict
old_pos_embed = state_dict.get('visual.positional_embedding', None)
if old_pos_embed is None or not hasattr(model.visual, 'grid_size'):
return | grid_size = to_2tuple(model.visual.grid_size) | 9 | 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 | 17,267 | 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,
20105: 'FriendListMessage',
20106: 'FriendListUpdateMessage',
20107: 'AddableFriendsMessage',
20108: KeepAliveServerMessage,
20109: 'FriendOnlineStatusMessage',
20110: 'FriendLoggedInMessage',
20111: 'FriendLoggedOutMessage',
20112: 'AddFriendFailedMessage',
20117: 'ReportUserStatusMessage',
20118: 'ChatAccountBanStatusMessage',
20121: 'BillingRequestFailedMessage',
20132: 'UnlockAccountOkMessage',
20133: 'UnlockAccountFailedMessage',
20151: 'AppleBillingProcessedByServerMessage',
20152: 'GoogleBillingProcessedByServerMessage',
20153: 'TencentBillingProcessedByServerMessage',
20154: 'CafeBazaarBillingProcessedByServerMessage',
20156: 'KunlunBillingProcessedByServerMessage',
20161: 'ShutdownStartedMessage',
20171: 'PersonalBreakStartedMessage',
20173: 'YoozooBillingProcessedByServerMessage',
20199: 'FriendSuggestionsMessage',
20205: 'AvatarNameChangeFailedMessage',
20206: 'AvatarOnlineStatusUpdated',
20207: 'AllianceOnlineStatusUpdatedMessage',
20300: 'AvatarNameCheckResponseMessage',
20402: 'CreateGameFailedMessage',
20405: 'MatchMakingStatusMessage',
20406: 'MatchMakingCancelledMessage',
20501: 'AcceptFriendFailedMessage',
20523: 'YoozooOrderAvailableMessage',
20545: 'YoozooOrderDeliveryFailedMessage',
20559: 'StartLoadingMessage',
20801: 'NotificationMessage',
20802: 'OpponentRejoinsMatchNotificationMessage',
20931: 'AntiAddictionDataUpdatedMessage',
22089: 'GetTokenFriendResultMessage',
22100: 'CreatePlayerMapResponseMessage',
22101: 'DeletePlayerMapResponseMessage',
22102: 'PlayerMapsMessage',
22103: 'UpdatePlayerMapResponseMessage',
22104: 'SubmitPlayerMapResponseMessage',
22105: 'PublishPlayerMapResponseMessage',
22106: 'ChangePlayerMapNameMResponseMessage',
22107: 'PlayerMapInfoUpdatedMessage',
22109: 'DebugPlayerMapReviewResultOverrideSetMessage',
22111: 'PlayerMapGreenlightedMessage',
22125: 'ReportPlayerMapResponseMessage',
22150: 'RankedMatchStartMessage',
22151: 'RankedMatchBanStartedMessage',
22152: 'RankedMatchBanHeroResponseMessage',
22153: 'RankedMatchBanEndedMessage',
22154: 'RankedMatchPickStartedMessage',
22155: 'RankedMatchPickHeroFailedMessage',
22156: 'RankedMatchHeroPickedMessage',
22157: 'RankedMatchHeroDataUpdatedMessage',
22158: 'RankedMatchFinalPreparationStartedMessage',
22159: 'RankedMatchTerminatedMessage',
22202: 'MapPreviewMessage',
22377: 'GoogleServiceAccountBoundMessage',
22687: 'GamecenterAccountAlreadyBoundMessage',
22957: 'PvpMatchmakeNotificationMessage',
23067: 'SCIDLogoutAllDevicesResultMessage',
23302: 'GetAllianceInviteTokenResultMessage',
23456: BattleEndMessage,
23457: LobbyInfoMessage,
23458: 'BattleLogMessage',
23459: 'BattleLogReplayAvailableMessage',
23494: 'GoogleServiceAccountAlreadyBoundMessage',
23774: 'PlayerJWTokenMessage',
24101: OwnHomeDataMessage,
24104: OutOfSyncMessage,
24105: 'SpectacleFailedMessage',
24106: 'StopHomeLogicMessage',
24108: 'MatchmakeFailedMessage',
24109: 'VisionUpdateMessage',
24111: AvailableServerCommandMessage,
24112: 'UdpConnectionInfoMessage',
24113: PlayerProfileMessage,
24114: 'HomeBattleReplayDataMessage',
24115: 'ServerErrorMessage',
24116: 'HomeBattleReplayFailedMessage',
24117: 'HomeBattleReplayViewedMessage',
24123: 'SeasonRewardsMessage',
24124: 'TeamMessage',
24125: 'TeamLeftMessage',
24129: 'TeamErrorMessage',
24130: 'TeamGameStartingMessage',
24131: 'TeamStreamMessage',
24177: 'SetRegionResponseMessage',
24178: 'SetCountryResponseMessage',
24199: 'LookForGameRoomRequestMessage',
24201: 'FacebookAccountBoundMessage',
24202: 'FacebookAccountAlreadyBoundMessage',
24203: 'KakaoAccountBoundMessage',
24204: 'KakaoAccountAlreadyBoundMessage',
24205: 'LineAccountAlreadyBoundMessage',
24206: 'LineAccountBoundMessage',
24214: 'FacebookAccountUnboundMessage',
24215: 'KakaoAccountUnboundMessage',
24216: 'LineAccountUnboundMessage',
24220: 'TencentAccountBoundMessage',
24221: 'TencentAccountAlreadyBoundMessage',
24223: 'tencentCheckCanPayResponseMessage',
|
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,
20105: 'FriendListMessage',
20106: 'FriendListUpdateMessage',
20107: 'AddableFriendsMessage',
20108: KeepAliveServerMessage,
20109: 'FriendOnlineStatusMessage',
20110: 'FriendLoggedInMessage',
20111: 'FriendLoggedOutMessage',
20112: 'AddFriendFailedMessage',
20117: 'ReportUserStatusMessage',
20118: 'ChatAccountBanStatusMessage',
20121: 'BillingRequestFailedMessage',
20132: 'UnlockAccountOkMessage',
20133: 'UnlockAccountFailedMessage',
20151: 'AppleBillingProcessedByServerMessage',
20152: 'GoogleBillingProcessedByServerMessage',
20153: 'TencentBillingProcessedByServerMessage',
20154: 'CafeBazaarBillingProcessedByServerMessage',
20156: 'KunlunBillingProcessedByServerMessage',
20161: 'ShutdownStartedMessage',
20171: 'PersonalBreakStartedMessage',
20173: 'YoozooBillingProcessedByServerMessage',
20199: 'FriendSuggestionsMessage',
20205: 'AvatarNameChangeFailedMessage',
20206: 'AvatarOnlineStatusUpdated',
20207: 'AllianceOnlineStatusUpdatedMessage',
20300: 'AvatarNameCheckResponseMessage',
20402: 'CreateGameFailedMessage',
20405: 'MatchMakingStatusMessage',
20406: 'MatchMakingCancelledMessage',
20501: 'AcceptFriendFailedMessage',
20523: 'YoozooOrderAvailableMessage',
20545: 'YoozooOrderDeliveryFailedMessage',
20559: 'StartLoadingMessage',
20801: 'NotificationMessage',
20802: 'OpponentRejoinsMatchNotificationMessage',
20931: 'AntiAddictionDataUpdatedMessage',
22089: 'GetTokenFriendResultMessage',
22100: 'CreatePlayerMapResponseMessage',
22101: 'DeletePlayerMapResponseMessage',
22102: 'PlayerMapsMessage',
22103: 'UpdatePlayerMapResponseMessage',
22104: 'SubmitPlayerMapResponseMessage',
22105: 'PublishPlayerMapResponseMessage',
22106: 'ChangePlayerMapNameMResponseMessage',
22107: 'PlayerMapInfoUpdatedMessage',
22109: 'DebugPlayerMapReviewResultOverrideSetMessage',
22111: 'PlayerMapGreenlightedMessage',
22125: 'ReportPlayerMapResponseMessage',
22150: 'RankedMatchStartMessage',
22151: 'RankedMatchBanStartedMessage',
22152: 'RankedMatchBanHeroResponseMessage',
22153: 'RankedMatchBanEndedMessage',
22154: 'RankedMatchPickStartedMessage',
22155: 'RankedMatchPickHeroFailedMessage',
22156: 'RankedMatchHeroPickedMessage',
22157: 'RankedMatchHeroDataUpdatedMessage',
22158: 'RankedMatchFinalPreparationStartedMessage',
22159: 'RankedMatchTerminatedMessage',
22202: 'MapPreviewMessage',
22377: 'GoogleServiceAccountBoundMessage',
22687: 'GamecenterAccountAlreadyBoundMessage',
22957: 'PvpMatchmakeNotificationMessage',
23067: 'SCIDLogoutAllDevicesResultMessage',
23302: 'GetAllianceInviteTokenResultMessage',
23456: BattleEndMessage,
23457: LobbyInfoMessage,
23458: 'BattleLogMessage',
23459: 'BattleLogReplayAvailableMessage',
23494: 'GoogleServiceAccountAlreadyBoundMessage',
23774: 'PlayerJWTokenMessage',
24101: OwnHomeDataMessage,
24104: OutOfSyncMessage,
24105: 'SpectacleFailedMessage',
24106: 'StopHomeLogicMessage',
24108: 'MatchmakeFailedMessage',
24109: 'VisionUpdateMessage',
24111: AvailableServerCommandMessage,
24112: 'UdpConnectionInfoMessage',
24113: PlayerProfileMessage,
24114: 'HomeBattleReplayDataMessage',
24115: 'ServerErrorMessage',
24116: 'HomeBattleReplayFailedMessage',
24117: 'HomeBattleReplayViewedMessage',
24123: 'SeasonRewardsMessage',
24124: 'TeamMessage',
24125: 'TeamLeftMessage',
24129: 'TeamErrorMessage',
24130: 'TeamGameStartingMessage',
24131: 'TeamStreamMessage',
24177: 'SetRegionResponseMessage',
24178: 'SetCountryResponseMessage',
24199: 'LookForGameRoomRequestMessage',
24201: 'FacebookAccountBoundMessage',
24202: 'FacebookAccountAlreadyBoundMessage',
24203: 'KakaoAccountBoundMessage',
24204: 'KakaoAccountAlreadyBoundMessage',
24205: 'LineAccountAlreadyBoundMessage',
24206: 'LineAccountBoundMessage',
24214: 'FacebookAccountUnboundMessage',
24215: 'KakaoAccountUnboundMessage',
24216: 'LineAccountUnboundMessage',
24220: 'TencentAccountBoundMessage',
24221: 'TencentAccountAlreadyBoundMessage',
24223: 'tencentCheckCanPayResponseMessage', | 24301: AllianceDataMessage, | 21 | 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,050 | # 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 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)) | 8 | 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,233 |
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
|
## 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) | 0 | 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,086 |
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[
|
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] | 12 | 2023-12-12 21:50:25+00:00 | 24k |
ZS-YANG/FemtoDet-v3 | mmdet/datasets/transforms/transforms.py | [
{
"identifier": "TRANSFORMS",
"path": "mmdet/registry.py",
"snippet": "TRANSFORMS = Registry(\n 'transform',\n parent=MMENGINE_TRANSFORMS,\n locations=['mmdet.datasets.transforms'])"
},
{
"identifier": "autocast_box_type",
"path": "mmdet/structures/bbox/box_type.py",
"snippet": ... | import copy
import inspect
import math
import warnings
import cv2
import mmcv
import numpy as np
import albumentations
from typing import List, Optional, Sequence, Tuple, Union
from mmcv.image import imresize
from mmcv.image.geometric import _scale_size
from mmcv.transforms import BaseTransform
from mmcv.transforms import Pad as MMCV_Pad
from mmcv.transforms import RandomFlip as MMCV_RandomFlip
from mmcv.transforms import Resize as MMCV_Resize
from mmcv.transforms.utils import avoid_cache_randomness, cache_randomness
from mmengine.dataset import BaseDataset
from mmengine.utils import is_str
from numpy import random
from mmdet.registry import TRANSFORMS
from mmdet.structures.bbox import HorizontalBoxes, autocast_box_type
from mmdet.structures.mask import BitmapMasks, PolygonMasks
from mmdet.utils import log_img_scale
from imagecorruptions import corrupt
from albumentations import Compose | 17,900 | assert (cutout_shape is None) ^ (cutout_ratio is None), \
'Either cutout_shape or cutout_ratio should be specified.'
assert (isinstance(cutout_shape, (list, tuple))
or isinstance(cutout_ratio, (list, tuple)))
if isinstance(n_holes, tuple):
assert len(n_holes) == 2 and 0 <= n_holes[0] < n_holes[1]
else:
n_holes = (n_holes, n_holes)
self.n_holes = n_holes
self.fill_in = fill_in
self.with_ratio = cutout_ratio is not None
self.candidates = cutout_ratio if self.with_ratio else cutout_shape
if not isinstance(self.candidates, list):
self.candidates = [self.candidates]
@autocast_box_type()
def transform(self, results: dict) -> dict:
"""Call function to drop some regions of image."""
h, w, c = results['img'].shape
n_holes = np.random.randint(self.n_holes[0], self.n_holes[1] + 1)
for _ in range(n_holes):
x1 = np.random.randint(0, w)
y1 = np.random.randint(0, h)
index = np.random.randint(0, len(self.candidates))
if not self.with_ratio:
cutout_w, cutout_h = self.candidates[index]
else:
cutout_w = int(self.candidates[index][0] * w)
cutout_h = int(self.candidates[index][1] * h)
x2 = np.clip(x1 + cutout_w, 0, w)
y2 = np.clip(y1 + cutout_h, 0, h)
results['img'][y1:y2, x1:x2, :] = self.fill_in
return results
def __repr__(self):
repr_str = self.__class__.__name__
repr_str += f'(n_holes={self.n_holes}, '
repr_str += (f'cutout_ratio={self.candidates}, ' if self.with_ratio
else f'cutout_shape={self.candidates}, ')
repr_str += f'fill_in={self.fill_in})'
return repr_str
@TRANSFORMS.register_module()
class Mosaic(BaseTransform):
"""Mosaic augmentation.
Given 4 images, mosaic transform combines them into
one output image. The output image is composed of the parts from each sub-
image.
.. code:: text
mosaic transform
center_x
+------------------------------+
| pad | pad |
| +-----------+ |
| | | |
| | image1 |--------+ |
| | | | |
| | | image2 | |
center_y |----+-------------+-----------|
| | cropped | |
|pad | image3 | image4 |
| | | |
+----|-------------+-----------+
| |
+-------------+
The mosaic transform steps are as follows:
1. Choose the mosaic center as the intersections of 4 images
2. Get the left top image according to the index, and randomly
sample another 3 images from the custom dataset.
3. Sub image will be cropped if image is larger than mosaic patch
Required Keys:
- img
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_bboxes_labels (np.int64) (optional)
- gt_ignore_flags (bool) (optional)
- mix_results (List[dict])
Modified Keys:
- img
- img_shape
- gt_bboxes (optional)
- gt_bboxes_labels (optional)
- gt_ignore_flags (optional)
Args:
img_scale (Sequence[int]): Image size before mosaic pipeline of single
image. The shape order should be (width, height).
Defaults to (640, 640).
center_ratio_range (Sequence[float]): Center ratio range of mosaic
output. Defaults to (0.5, 1.5).
bbox_clip_border (bool, optional): Whether to clip the objects outside
the border of the image. In some dataset like MOT17, the gt bboxes
are allowed to cross the border of images. Therefore, we don't
need to clip the gt bboxes in these cases. Defaults to True.
pad_val (int): Pad value. Defaults to 114.
prob (float): Probability of applying this transformation.
Defaults to 1.0.
"""
def __init__(self,
img_scale: Tuple[int, int] = (640, 640),
center_ratio_range: Tuple[float, float] = (0.5, 1.5),
bbox_clip_border: bool = True,
pad_val: float = 114.0,
prob: float = 1.0) -> None:
assert isinstance(img_scale, tuple)
assert 0 <= prob <= 1.0, 'The probability should be in range [0,1]. ' \
f'got {prob}.'
| # Copyright (c) OpenMMLab. All rights reserved.
try:
except ImportError:
corrupt = None
try:
except ImportError:
albumentations = None
Compose = None
Number = Union[int, float]
def _fixed_scale_size(
size: Tuple[int, int],
scale: Union[float, int, tuple],
) -> Tuple[int, int]:
"""Rescale a size by a ratio.
Args:
size (tuple[int]): (w, h).
scale (float | tuple(float)): Scaling factor.
Returns:
tuple[int]: scaled size.
"""
if isinstance(scale, (float, int)):
scale = (scale, scale)
w, h = size
# don't need o.5 offset
return int(w * float(scale[0])), int(h * float(scale[1]))
def rescale_size(old_size: tuple,
scale: Union[float, int, tuple],
return_scale: bool = False) -> tuple:
"""Calculate the new size to be rescaled to.
Args:
old_size (tuple[int]): The old size (w, h) of image.
scale (float | tuple[int]): The scaling factor or maximum size.
If it is a float number, then the image will be rescaled by this
factor, else if it is a tuple of 2 integers, then the image will
be rescaled as large as possible within the scale.
return_scale (bool): Whether to return the scaling factor besides the
rescaled image size.
Returns:
tuple[int]: The new rescaled image size.
"""
w, h = old_size
if isinstance(scale, (float, int)):
if scale <= 0:
raise ValueError(f'Invalid scale {scale}, must be positive.')
scale_factor = scale
elif isinstance(scale, tuple):
max_long_edge = max(scale)
max_short_edge = min(scale)
scale_factor = min(max_long_edge / max(h, w),
max_short_edge / min(h, w))
else:
raise TypeError(
f'Scale must be a number or tuple of int, but got {type(scale)}')
# only change this
new_size = _fixed_scale_size((w, h), scale_factor)
if return_scale:
return new_size, scale_factor
else:
return new_size
def imrescale(
img: np.ndarray,
scale: Union[float, Tuple[int, int]],
return_scale: bool = False,
interpolation: str = 'bilinear',
backend: Optional[str] = None
) -> Union[np.ndarray, Tuple[np.ndarray, float]]:
"""Resize image while keeping the aspect ratio.
Args:
img (ndarray): The input image.
scale (float | tuple[int]): The scaling factor or maximum size.
If it is a float number, then the image will be rescaled by this
factor, else if it is a tuple of 2 integers, then the image will
be rescaled as large as possible within the scale.
return_scale (bool): Whether to return the scaling factor besides the
rescaled image.
interpolation (str): Same as :func:`resize`.
backend (str | None): Same as :func:`resize`.
Returns:
ndarray: The rescaled image.
"""
h, w = img.shape[:2]
new_size, scale_factor = rescale_size((w, h), scale, return_scale=True)
rescaled_img = imresize(
img, new_size, interpolation=interpolation, backend=backend)
if return_scale:
return rescaled_img, scale_factor
else:
return rescaled_img
@TRANSFORMS.register_module()
class Resize(MMCV_Resize):
"""Resize images & bbox & seg.
This transform resizes the input image according to ``scale`` or
``scale_factor``. Bboxes, masks, and seg map are then resized
with the same scale factor.
if ``scale`` and ``scale_factor`` are both set, it will use ``scale`` to
resize.
Required Keys:
- img
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_masks (BitmapMasks | PolygonMasks) (optional)
- gt_seg_map (np.uint8) (optional)
Modified Keys:
- img
- img_shape
- gt_bboxes
- gt_masks
- gt_seg_map
Added Keys:
- scale
- scale_factor
- keep_ratio
- homography_matrix
Args:
scale (int or tuple): Images scales for resizing. Defaults to None
scale_factor (float or tuple[float]): Scale factors for resizing.
Defaults to None.
keep_ratio (bool): Whether to keep the aspect ratio when resizing the
image. Defaults to False.
clip_object_border (bool): Whether to clip the objects
outside the border of the image. In some dataset like MOT17, the gt
bboxes are allowed to cross the border of images. Therefore, we
don't need to clip the gt bboxes in these cases. Defaults to True.
backend (str): Image resize backend, choices are 'cv2' and 'pillow'.
These two backends generates slightly different results. Defaults
to 'cv2'.
interpolation (str): Interpolation method, accepted values are
"nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
backend, "nearest", "bilinear" for 'pillow' backend. Defaults
to 'bilinear'.
"""
def _resize_masks(self, results: dict) -> None:
"""Resize masks with ``results['scale']``"""
if results.get('gt_masks', None) is not None:
if self.keep_ratio:
results['gt_masks'] = results['gt_masks'].rescale(
results['scale'])
else:
results['gt_masks'] = results['gt_masks'].resize(
results['img_shape'])
def _resize_bboxes(self, results: dict) -> None:
"""Resize bounding boxes with ``results['scale_factor']``."""
if results.get('gt_bboxes', None) is not None:
results['gt_bboxes'].rescale_(results['scale_factor'])
if self.clip_object_border:
results['gt_bboxes'].clip_(results['img_shape'])
def _record_homography_matrix(self, results: dict) -> None:
"""Record the homography matrix for the Resize."""
w_scale, h_scale = results['scale_factor']
homography_matrix = np.array(
[[w_scale, 0, 0], [0, h_scale, 0], [0, 0, 1]], dtype=np.float32)
if results.get('homography_matrix', None) is None:
results['homography_matrix'] = homography_matrix
else:
results['homography_matrix'] = homography_matrix @ results[
'homography_matrix']
@autocast_box_type()
def transform(self, results: dict) -> dict:
"""Transform function to resize images, bounding boxes and semantic
segmentation map.
Args:
results (dict): Result dict from loading pipeline.
Returns:
dict: Resized results, 'img', 'gt_bboxes', 'gt_seg_map',
'scale', 'scale_factor', 'height', 'width', and 'keep_ratio' keys
are updated in result dict.
"""
if self.scale:
results['scale'] = self.scale
else:
img_shape = results['img'].shape[:2]
results['scale'] = _scale_size(img_shape[::-1], self.scale_factor)
self._resize_img(results)
self._resize_bboxes(results)
self._resize_masks(results)
self._resize_seg(results)
self._record_homography_matrix(results)
return results
def __repr__(self) -> str:
repr_str = self.__class__.__name__
repr_str += f'(scale={self.scale}, '
repr_str += f'scale_factor={self.scale_factor}, '
repr_str += f'keep_ratio={self.keep_ratio}, '
repr_str += f'clip_object_border={self.clip_object_border}), '
repr_str += f'backend={self.backend}), '
repr_str += f'interpolation={self.interpolation})'
return repr_str
@TRANSFORMS.register_module()
class FixScaleResize(Resize):
"""Compared to Resize, FixScaleResize fixes the scaling issue when
`keep_ratio=true`."""
def _resize_img(self, results):
"""Resize images with ``results['scale']``."""
if results.get('img', None) is not None:
if self.keep_ratio:
img, scale_factor = imrescale(
results['img'],
results['scale'],
interpolation=self.interpolation,
return_scale=True,
backend=self.backend)
new_h, new_w = img.shape[:2]
h, w = results['img'].shape[:2]
w_scale = new_w / w
h_scale = new_h / h
else:
img, w_scale, h_scale = mmcv.imresize(
results['img'],
results['scale'],
interpolation=self.interpolation,
return_scale=True,
backend=self.backend)
results['img'] = img
results['img_shape'] = img.shape[:2]
results['scale_factor'] = (w_scale, h_scale)
results['keep_ratio'] = self.keep_ratio
@TRANSFORMS.register_module()
class ResizeShortestEdge(BaseTransform):
"""Resize the image and mask while keeping the aspect ratio unchanged.
Modified from https://github.com/facebookresearch/detectron2/blob/main/detectron2/data/transforms/augmentation_impl.py#L130 # noqa:E501
This transform attempts to scale the shorter edge to the given
`scale`, as long as the longer edge does not exceed `max_size`.
If `max_size` is reached, then downscale so that the longer
edge does not exceed `max_size`.
Required Keys:
- img
- gt_seg_map (optional)
Modified Keys:
- img
- img_shape
- gt_seg_map (optional))
Added Keys:
- scale
- scale_factor
- keep_ratio
Args:
scale (Union[int, Tuple[int, int]]): The target short edge length.
If it's tuple, will select the min value as the short edge length.
max_size (int): The maximum allowed longest edge length.
"""
def __init__(self,
scale: Union[int, Tuple[int, int]],
max_size: Optional[int] = None,
resize_type: str = 'Resize',
**resize_kwargs) -> None:
super().__init__()
self.scale = scale
self.max_size = max_size
self.resize_cfg = dict(type=resize_type, **resize_kwargs)
self.resize = TRANSFORMS.build({'scale': 0, **self.resize_cfg})
def _get_output_shape(
self, img: np.ndarray,
short_edge_length: Union[int, Tuple[int, int]]) -> Tuple[int, int]:
"""Compute the target image shape with the given `short_edge_length`.
Args:
img (np.ndarray): The input image.
short_edge_length (Union[int, Tuple[int, int]]): The target short
edge length. If it's tuple, will select the min value as the
short edge length.
"""
h, w = img.shape[:2]
if isinstance(short_edge_length, int):
size = short_edge_length * 1.0
elif isinstance(short_edge_length, tuple):
size = min(short_edge_length) * 1.0
scale = size / min(h, w)
if h < w:
new_h, new_w = size, scale * w
else:
new_h, new_w = scale * h, size
if self.max_size and max(new_h, new_w) > self.max_size:
scale = self.max_size * 1.0 / max(new_h, new_w)
new_h *= scale
new_w *= scale
new_h = int(new_h + 0.5)
new_w = int(new_w + 0.5)
return new_w, new_h
def transform(self, results: dict) -> dict:
self.resize.scale = self._get_output_shape(results['img'], self.scale)
return self.resize(results)
@TRANSFORMS.register_module()
class FixShapeResize(Resize):
"""Resize images & bbox & seg to the specified size.
This transform resizes the input image according to ``width`` and
``height``. Bboxes, masks, and seg map are then resized
with the same parameters.
Required Keys:
- img
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_masks (BitmapMasks | PolygonMasks) (optional)
- gt_seg_map (np.uint8) (optional)
Modified Keys:
- img
- img_shape
- gt_bboxes
- gt_masks
- gt_seg_map
Added Keys:
- scale
- scale_factor
- keep_ratio
- homography_matrix
Args:
width (int): width for resizing.
height (int): height for resizing.
Defaults to None.
pad_val (Number | dict[str, Number], optional): Padding value for if
the pad_mode is "constant". If it is a single number, the value
to pad the image is the number and to pad the semantic
segmentation map is 255. If it is a dict, it should have the
following keys:
- img: The value to pad the image.
- seg: The value to pad the semantic segmentation map.
Defaults to dict(img=0, seg=255).
keep_ratio (bool): Whether to keep the aspect ratio when resizing the
image. Defaults to False.
clip_object_border (bool): Whether to clip the objects
outside the border of the image. In some dataset like MOT17, the gt
bboxes are allowed to cross the border of images. Therefore, we
don't need to clip the gt bboxes in these cases. Defaults to True.
backend (str): Image resize backend, choices are 'cv2' and 'pillow'.
These two backends generates slightly different results. Defaults
to 'cv2'.
interpolation (str): Interpolation method, accepted values are
"nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
backend, "nearest", "bilinear" for 'pillow' backend. Defaults
to 'bilinear'.
"""
def __init__(self,
width: int,
height: int,
pad_val: Union[Number, dict] = dict(img=0, seg=255),
keep_ratio: bool = False,
clip_object_border: bool = True,
backend: str = 'cv2',
interpolation: str = 'bilinear') -> None:
assert width is not None and height is not None, (
'`width` and'
'`height` can not be `None`')
self.width = width
self.height = height
self.scale = (width, height)
self.backend = backend
self.interpolation = interpolation
self.keep_ratio = keep_ratio
self.clip_object_border = clip_object_border
if keep_ratio is True:
# padding to the fixed size when keep_ratio=True
self.pad_transform = Pad(size=self.scale, pad_val=pad_val)
@autocast_box_type()
def transform(self, results: dict) -> dict:
"""Transform function to resize images, bounding boxes and semantic
segmentation map.
Args:
results (dict): Result dict from loading pipeline.
Returns:
dict: Resized results, 'img', 'gt_bboxes', 'gt_seg_map',
'scale', 'scale_factor', 'height', 'width', and 'keep_ratio' keys
are updated in result dict.
"""
img = results['img']
h, w = img.shape[:2]
if self.keep_ratio:
scale_factor = min(self.width / w, self.height / h)
results['scale_factor'] = (scale_factor, scale_factor)
real_w, real_h = int(w * float(scale_factor) +
0.5), int(h * float(scale_factor) + 0.5)
img, scale_factor = mmcv.imrescale(
results['img'], (real_w, real_h),
interpolation=self.interpolation,
return_scale=True,
backend=self.backend)
# the w_scale and h_scale has minor difference
# a real fix should be done in the mmcv.imrescale in the future
results['img'] = img
results['img_shape'] = img.shape[:2]
results['keep_ratio'] = self.keep_ratio
results['scale'] = (real_w, real_h)
else:
results['scale'] = (self.width, self.height)
results['scale_factor'] = (self.width / w, self.height / h)
super()._resize_img(results)
self._resize_bboxes(results)
self._resize_masks(results)
self._resize_seg(results)
self._record_homography_matrix(results)
if self.keep_ratio:
self.pad_transform(results)
return results
def __repr__(self) -> str:
repr_str = self.__class__.__name__
repr_str += f'(width={self.width}, height={self.height}, '
repr_str += f'keep_ratio={self.keep_ratio}, '
repr_str += f'clip_object_border={self.clip_object_border}), '
repr_str += f'backend={self.backend}), '
repr_str += f'interpolation={self.interpolation})'
return repr_str
@TRANSFORMS.register_module()
class RandomFlip(MMCV_RandomFlip):
"""Flip the image & bbox & mask & segmentation map. Added or Updated keys:
flip, flip_direction, img, gt_bboxes, and gt_seg_map. There are 3 flip
modes:
- ``prob`` is float, ``direction`` is string: the image will be
``direction``ly flipped with probability of ``prob`` .
E.g., ``prob=0.5``, ``direction='horizontal'``,
then image will be horizontally flipped with probability of 0.5.
- ``prob`` is float, ``direction`` is list of string: the image will
be ``direction[i]``ly flipped with probability of
``prob/len(direction)``.
E.g., ``prob=0.5``, ``direction=['horizontal', 'vertical']``,
then image will be horizontally flipped with probability of 0.25,
vertically with probability of 0.25.
- ``prob`` is list of float, ``direction`` is list of string:
given ``len(prob) == len(direction)``, the image will
be ``direction[i]``ly flipped with probability of ``prob[i]``.
E.g., ``prob=[0.3, 0.5]``, ``direction=['horizontal',
'vertical']``, then image will be horizontally flipped with
probability of 0.3, vertically with probability of 0.5.
Required Keys:
- img
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_masks (BitmapMasks | PolygonMasks) (optional)
- gt_seg_map (np.uint8) (optional)
Modified Keys:
- img
- gt_bboxes
- gt_masks
- gt_seg_map
Added Keys:
- flip
- flip_direction
- homography_matrix
Args:
prob (float | list[float], optional): The flipping probability.
Defaults to None.
direction(str | list[str]): The flipping direction. Options
If input is a list, the length must equal ``prob``. Each
element in ``prob`` indicates the flip probability of
corresponding direction. Defaults to 'horizontal'.
"""
def _record_homography_matrix(self, results: dict) -> None:
"""Record the homography matrix for the RandomFlip."""
cur_dir = results['flip_direction']
h, w = results['img'].shape[:2]
if cur_dir == 'horizontal':
homography_matrix = np.array([[-1, 0, w], [0, 1, 0], [0, 0, 1]],
dtype=np.float32)
elif cur_dir == 'vertical':
homography_matrix = np.array([[1, 0, 0], [0, -1, h], [0, 0, 1]],
dtype=np.float32)
elif cur_dir == 'diagonal':
homography_matrix = np.array([[-1, 0, w], [0, -1, h], [0, 0, 1]],
dtype=np.float32)
else:
homography_matrix = np.eye(3, dtype=np.float32)
if results.get('homography_matrix', None) is None:
results['homography_matrix'] = homography_matrix
else:
results['homography_matrix'] = homography_matrix @ results[
'homography_matrix']
@autocast_box_type()
def _flip(self, results: dict) -> None:
"""Flip images, bounding boxes, and semantic segmentation map."""
# flip image
results['img'] = mmcv.imflip(
results['img'], direction=results['flip_direction'])
img_shape = results['img'].shape[:2]
# flip bboxes
if results.get('gt_bboxes', None) is not None:
results['gt_bboxes'].flip_(img_shape, results['flip_direction'])
# flip masks
if results.get('gt_masks', None) is not None:
results['gt_masks'] = results['gt_masks'].flip(
results['flip_direction'])
# flip segs
if results.get('gt_seg_map', None) is not None:
results['gt_seg_map'] = mmcv.imflip(
results['gt_seg_map'], direction=results['flip_direction'])
# record homography matrix for flip
self._record_homography_matrix(results)
@TRANSFORMS.register_module()
class RandomShift(BaseTransform):
"""Shift the image and box given shift pixels and probability.
Required Keys:
- img
- gt_bboxes (BaseBoxes[torch.float32])
- gt_bboxes_labels (np.int64)
- gt_ignore_flags (bool) (optional)
Modified Keys:
- img
- gt_bboxes
- gt_bboxes_labels
- gt_ignore_flags (bool) (optional)
Args:
prob (float): Probability of shifts. Defaults to 0.5.
max_shift_px (int): The max pixels for shifting. Defaults to 32.
filter_thr_px (int): The width and height threshold for filtering.
The bbox and the rest of the targets below the width and
height threshold will be filtered. Defaults to 1.
"""
def __init__(self,
prob: float = 0.5,
max_shift_px: int = 32,
filter_thr_px: int = 1) -> None:
assert 0 <= prob <= 1
assert max_shift_px >= 0
self.prob = prob
self.max_shift_px = max_shift_px
self.filter_thr_px = int(filter_thr_px)
@cache_randomness
def _random_prob(self) -> float:
return random.uniform(0, 1)
@autocast_box_type()
def transform(self, results: dict) -> dict:
"""Transform function to random shift images, bounding boxes.
Args:
results (dict): Result dict from loading pipeline.
Returns:
dict: Shift results.
"""
if self._random_prob() < self.prob:
img_shape = results['img'].shape[:2]
random_shift_x = random.randint(-self.max_shift_px,
self.max_shift_px)
random_shift_y = random.randint(-self.max_shift_px,
self.max_shift_px)
new_x = max(0, random_shift_x)
ori_x = max(0, -random_shift_x)
new_y = max(0, random_shift_y)
ori_y = max(0, -random_shift_y)
# TODO: support mask and semantic segmentation maps.
bboxes = results['gt_bboxes'].clone()
bboxes.translate_([random_shift_x, random_shift_y])
# clip border
bboxes.clip_(img_shape)
# remove invalid bboxes
valid_inds = (bboxes.widths > self.filter_thr_px).numpy() & (
bboxes.heights > self.filter_thr_px).numpy()
# If the shift does not contain any gt-bbox area, skip this
# image.
if not valid_inds.any():
return results
bboxes = bboxes[valid_inds]
results['gt_bboxes'] = bboxes
results['gt_bboxes_labels'] = results['gt_bboxes_labels'][
valid_inds]
if results.get('gt_ignore_flags', None) is not None:
results['gt_ignore_flags'] = \
results['gt_ignore_flags'][valid_inds]
# shift img
img = results['img']
new_img = np.zeros_like(img)
img_h, img_w = img.shape[:2]
new_h = img_h - np.abs(random_shift_y)
new_w = img_w - np.abs(random_shift_x)
new_img[new_y:new_y + new_h, new_x:new_x + new_w] \
= img[ori_y:ori_y + new_h, ori_x:ori_x + new_w]
results['img'] = new_img
return results
def __repr__(self):
repr_str = self.__class__.__name__
repr_str += f'(prob={self.prob}, '
repr_str += f'max_shift_px={self.max_shift_px}, '
repr_str += f'filter_thr_px={self.filter_thr_px})'
return repr_str
@TRANSFORMS.register_module()
class Pad(MMCV_Pad):
"""Pad the image & segmentation map.
There are three padding modes: (1) pad to a fixed size and (2) pad to the
minimum size that is divisible by some number. and (3)pad to square. Also,
pad to square and pad to the minimum size can be used as the same time.
Required Keys:
- img
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_masks (BitmapMasks | PolygonMasks) (optional)
- gt_seg_map (np.uint8) (optional)
Modified Keys:
- img
- img_shape
- gt_masks
- gt_seg_map
Added Keys:
- pad_shape
- pad_fixed_size
- pad_size_divisor
Args:
size (tuple, optional): Fixed padding size.
Expected padding shape (width, height). Defaults to None.
size_divisor (int, optional): The divisor of padded size. Defaults to
None.
pad_to_square (bool): Whether to pad the image into a square.
Currently only used for YOLOX. Defaults to False.
pad_val (Number | dict[str, Number], optional) - Padding value for if
the pad_mode is "constant". If it is a single number, the value
to pad the image is the number and to pad the semantic
segmentation map is 255. If it is a dict, it should have the
following keys:
- img: The value to pad the image.
- seg: The value to pad the semantic segmentation map.
Defaults to dict(img=0, seg=255).
padding_mode (str): Type of padding. Should be: constant, edge,
reflect or symmetric. Defaults to 'constant'.
- constant: pads with a constant value, this value is specified
with pad_val.
- edge: pads with the last value at the edge of the image.
- reflect: pads with reflection of image without repeating the last
value on the edge. For example, padding [1, 2, 3, 4] with 2
elements on both sides in reflect mode will result in
[3, 2, 1, 2, 3, 4, 3, 2].
- symmetric: pads with reflection of image repeating the last value
on the edge. For example, padding [1, 2, 3, 4] with 2 elements on
both sides in symmetric mode will result in
[2, 1, 1, 2, 3, 4, 4, 3]
"""
def _pad_masks(self, results: dict) -> None:
"""Pad masks according to ``results['pad_shape']``."""
if results.get('gt_masks', None) is not None:
pad_val = self.pad_val.get('masks', 0)
pad_shape = results['pad_shape'][:2]
results['gt_masks'] = results['gt_masks'].pad(
pad_shape, pad_val=pad_val)
def transform(self, results: dict) -> dict:
"""Call function to pad images, masks, semantic segmentation maps.
Args:
results (dict): Result dict from loading pipeline.
Returns:
dict: Updated result dict.
"""
self._pad_img(results)
self._pad_seg(results)
self._pad_masks(results)
return results
@TRANSFORMS.register_module()
class RandomCrop(BaseTransform):
"""Random crop the image & bboxes & masks.
The absolute ``crop_size`` is sampled based on ``crop_type`` and
``image_size``, then the cropped results are generated.
Required Keys:
- img
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_bboxes_labels (np.int64) (optional)
- gt_masks (BitmapMasks | PolygonMasks) (optional)
- gt_ignore_flags (bool) (optional)
- gt_seg_map (np.uint8) (optional)
Modified Keys:
- img
- img_shape
- gt_bboxes (optional)
- gt_bboxes_labels (optional)
- gt_masks (optional)
- gt_ignore_flags (optional)
- gt_seg_map (optional)
- gt_instances_ids (options, only used in MOT/VIS)
Added Keys:
- homography_matrix
Args:
crop_size (tuple): The relative ratio or absolute pixels of
(width, height).
crop_type (str, optional): One of "relative_range", "relative",
"absolute", "absolute_range". "relative" randomly crops
(h * crop_size[0], w * crop_size[1]) part from an input of size
(h, w). "relative_range" uniformly samples relative crop size from
range [crop_size[0], 1] and [crop_size[1], 1] for height and width
respectively. "absolute" crops from an input with absolute size
(crop_size[0], crop_size[1]). "absolute_range" uniformly samples
crop_h in range [crop_size[0], min(h, crop_size[1])] and crop_w
in range [crop_size[0], min(w, crop_size[1])].
Defaults to "absolute".
allow_negative_crop (bool, optional): Whether to allow a crop that does
not contain any bbox area. Defaults to False.
recompute_bbox (bool, optional): Whether to re-compute the boxes based
on cropped instance masks. Defaults to False.
bbox_clip_border (bool, optional): Whether clip the objects outside
the border of the image. Defaults to True.
Note:
- If the image is smaller than the absolute crop size, return the
original image.
- The keys for bboxes, labels and masks must be aligned. That is,
``gt_bboxes`` corresponds to ``gt_labels`` and ``gt_masks``, and
``gt_bboxes_ignore`` corresponds to ``gt_labels_ignore`` and
``gt_masks_ignore``.
- If the crop does not contain any gt-bbox region and
``allow_negative_crop`` is set to False, skip this image.
"""
def __init__(self,
crop_size: tuple,
crop_type: str = 'absolute',
allow_negative_crop: bool = False,
recompute_bbox: bool = False,
bbox_clip_border: bool = True) -> None:
if crop_type not in [
'relative_range', 'relative', 'absolute', 'absolute_range'
]:
raise ValueError(f'Invalid crop_type {crop_type}.')
if crop_type in ['absolute', 'absolute_range']:
assert crop_size[0] > 0 and crop_size[1] > 0
assert isinstance(crop_size[0], int) and isinstance(
crop_size[1], int)
if crop_type == 'absolute_range':
assert crop_size[0] <= crop_size[1]
else:
assert 0 < crop_size[0] <= 1 and 0 < crop_size[1] <= 1
self.crop_size = crop_size
self.crop_type = crop_type
self.allow_negative_crop = allow_negative_crop
self.bbox_clip_border = bbox_clip_border
self.recompute_bbox = recompute_bbox
def _crop_data(self, results: dict, crop_size: Tuple[int, int],
allow_negative_crop: bool) -> Union[dict, None]:
"""Function to randomly crop images, bounding boxes, masks, semantic
segmentation maps.
Args:
results (dict): Result dict from loading pipeline.
crop_size (Tuple[int, int]): Expected absolute size after
cropping, (h, w).
allow_negative_crop (bool): Whether to allow a crop that does not
contain any bbox area.
Returns:
results (Union[dict, None]): Randomly cropped results, 'img_shape'
key in result dict is updated according to crop size. None will
be returned when there is no valid bbox after cropping.
"""
assert crop_size[0] > 0 and crop_size[1] > 0
img = results['img']
margin_h = max(img.shape[0] - crop_size[0], 0)
margin_w = max(img.shape[1] - crop_size[1], 0)
offset_h, offset_w = self._rand_offset((margin_h, margin_w))
crop_y1, crop_y2 = offset_h, offset_h + crop_size[0]
crop_x1, crop_x2 = offset_w, offset_w + crop_size[1]
# Record the homography matrix for the RandomCrop
homography_matrix = np.array(
[[1, 0, -offset_w], [0, 1, -offset_h], [0, 0, 1]],
dtype=np.float32)
if results.get('homography_matrix', None) is None:
results['homography_matrix'] = homography_matrix
else:
results['homography_matrix'] = homography_matrix @ results[
'homography_matrix']
# crop the image
img = img[crop_y1:crop_y2, crop_x1:crop_x2, ...]
img_shape = img.shape
results['img'] = img
results['img_shape'] = img_shape[:2]
# crop bboxes accordingly and clip to the image boundary
if results.get('gt_bboxes', None) is not None:
bboxes = results['gt_bboxes']
bboxes.translate_([-offset_w, -offset_h])
if self.bbox_clip_border:
bboxes.clip_(img_shape[:2])
valid_inds = bboxes.is_inside(img_shape[:2]).numpy()
# If the crop does not contain any gt-bbox area and
# allow_negative_crop is False, skip this image.
if (not valid_inds.any() and not allow_negative_crop):
return None
results['gt_bboxes'] = bboxes[valid_inds]
if results.get('gt_ignore_flags', None) is not None:
results['gt_ignore_flags'] = \
results['gt_ignore_flags'][valid_inds]
if results.get('gt_bboxes_labels', None) is not None:
results['gt_bboxes_labels'] = \
results['gt_bboxes_labels'][valid_inds]
if results.get('gt_masks', None) is not None:
results['gt_masks'] = results['gt_masks'][
valid_inds.nonzero()[0]].crop(
np.asarray([crop_x1, crop_y1, crop_x2, crop_y2]))
if self.recompute_bbox:
results['gt_bboxes'] = results['gt_masks'].get_bboxes(
type(results['gt_bboxes']))
# We should remove the instance ids corresponding to invalid boxes.
if results.get('gt_instances_ids', None) is not None:
results['gt_instances_ids'] = \
results['gt_instances_ids'][valid_inds]
# crop semantic seg
if results.get('gt_seg_map', None) is not None:
results['gt_seg_map'] = results['gt_seg_map'][crop_y1:crop_y2,
crop_x1:crop_x2]
return results
@cache_randomness
def _rand_offset(self, margin: Tuple[int, int]) -> Tuple[int, int]:
"""Randomly generate crop offset.
Args:
margin (Tuple[int, int]): The upper bound for the offset generated
randomly.
Returns:
Tuple[int, int]: The random offset for the crop.
"""
margin_h, margin_w = margin
offset_h = np.random.randint(0, margin_h + 1)
offset_w = np.random.randint(0, margin_w + 1)
return offset_h, offset_w
@cache_randomness
def _get_crop_size(self, image_size: Tuple[int, int]) -> Tuple[int, int]:
"""Randomly generates the absolute crop size based on `crop_type` and
`image_size`.
Args:
image_size (Tuple[int, int]): (h, w).
Returns:
crop_size (Tuple[int, int]): (crop_h, crop_w) in absolute pixels.
"""
h, w = image_size
if self.crop_type == 'absolute':
return min(self.crop_size[1], h), min(self.crop_size[0], w)
elif self.crop_type == 'absolute_range':
crop_h = np.random.randint(
min(h, self.crop_size[0]),
min(h, self.crop_size[1]) + 1)
crop_w = np.random.randint(
min(w, self.crop_size[0]),
min(w, self.crop_size[1]) + 1)
return crop_h, crop_w
elif self.crop_type == 'relative':
crop_w, crop_h = self.crop_size
return int(h * crop_h + 0.5), int(w * crop_w + 0.5)
else:
# 'relative_range'
crop_size = np.asarray(self.crop_size, dtype=np.float32)
crop_h, crop_w = crop_size + np.random.rand(2) * (1 - crop_size)
return int(h * crop_h + 0.5), int(w * crop_w + 0.5)
@autocast_box_type()
def transform(self, results: dict) -> Union[dict, None]:
"""Transform function to randomly crop images, bounding boxes, masks,
semantic segmentation maps.
Args:
results (dict): Result dict from loading pipeline.
Returns:
results (Union[dict, None]): Randomly cropped results, 'img_shape'
key in result dict is updated according to crop size. None will
be returned when there is no valid bbox after cropping.
"""
image_size = results['img'].shape[:2]
crop_size = self._get_crop_size(image_size)
results = self._crop_data(results, crop_size, self.allow_negative_crop)
return results
def __repr__(self) -> str:
repr_str = self.__class__.__name__
repr_str += f'(crop_size={self.crop_size}, '
repr_str += f'crop_type={self.crop_type}, '
repr_str += f'allow_negative_crop={self.allow_negative_crop}, '
repr_str += f'recompute_bbox={self.recompute_bbox}, '
repr_str += f'bbox_clip_border={self.bbox_clip_border})'
return repr_str
@TRANSFORMS.register_module()
class SegRescale(BaseTransform):
"""Rescale semantic segmentation maps.
This transform rescale the ``gt_seg_map`` according to ``scale_factor``.
Required Keys:
- gt_seg_map
Modified Keys:
- gt_seg_map
Args:
scale_factor (float): The scale factor of the final output. Defaults
to 1.
backend (str): Image rescale backend, choices are 'cv2' and 'pillow'.
These two backends generates slightly different results. Defaults
to 'cv2'.
"""
def __init__(self, scale_factor: float = 1, backend: str = 'cv2') -> None:
self.scale_factor = scale_factor
self.backend = backend
def transform(self, results: dict) -> dict:
"""Transform function to scale the semantic segmentation map.
Args:
results (dict): Result dict from loading pipeline.
Returns:
dict: Result dict with semantic segmentation map scaled.
"""
if self.scale_factor != 1:
results['gt_seg_map'] = mmcv.imrescale(
results['gt_seg_map'],
self.scale_factor,
interpolation='nearest',
backend=self.backend)
return results
def __repr__(self) -> str:
repr_str = self.__class__.__name__
repr_str += f'(scale_factor={self.scale_factor}, '
repr_str += f'backend={self.backend})'
return repr_str
@TRANSFORMS.register_module()
class PhotoMetricDistortion(BaseTransform):
"""Apply photometric distortion to image sequentially, every transformation
is applied with a probability of 0.5. The position of random contrast is in
second or second to last.
1. random brightness
2. random contrast (mode 0)
3. convert color from BGR to HSV
4. random saturation
5. random hue
6. convert color from HSV to BGR
7. random contrast (mode 1)
8. randomly swap channels
Required Keys:
- img (np.uint8)
Modified Keys:
- img (np.float32)
Args:
brightness_delta (int): delta of brightness.
contrast_range (sequence): range of contrast.
saturation_range (sequence): range of saturation.
hue_delta (int): delta of hue.
"""
def __init__(self,
brightness_delta: int = 32,
contrast_range: Sequence[Number] = (0.5, 1.5),
saturation_range: Sequence[Number] = (0.5, 1.5),
hue_delta: int = 18) -> None:
self.brightness_delta = brightness_delta
self.contrast_lower, self.contrast_upper = contrast_range
self.saturation_lower, self.saturation_upper = saturation_range
self.hue_delta = hue_delta
@cache_randomness
def _random_flags(self) -> Sequence[Number]:
mode = random.randint(2)
brightness_flag = random.randint(2)
contrast_flag = random.randint(2)
saturation_flag = random.randint(2)
hue_flag = random.randint(2)
swap_flag = random.randint(2)
delta_value = random.uniform(-self.brightness_delta,
self.brightness_delta)
alpha_value = random.uniform(self.contrast_lower, self.contrast_upper)
saturation_value = random.uniform(self.saturation_lower,
self.saturation_upper)
hue_value = random.uniform(-self.hue_delta, self.hue_delta)
swap_value = random.permutation(3)
return (mode, brightness_flag, contrast_flag, saturation_flag,
hue_flag, swap_flag, delta_value, alpha_value,
saturation_value, hue_value, swap_value)
def transform(self, results: dict) -> dict:
"""Transform function to perform photometric distortion on images.
Args:
results (dict): Result dict from loading pipeline.
Returns:
dict: Result dict with images distorted.
"""
assert 'img' in results, '`img` is not found in results'
img = results['img']
img = img.astype(np.float32)
(mode, brightness_flag, contrast_flag, saturation_flag, hue_flag,
swap_flag, delta_value, alpha_value, saturation_value, hue_value,
swap_value) = self._random_flags()
# random brightness
if brightness_flag:
img += delta_value
# mode == 0 --> do random contrast first
# mode == 1 --> do random contrast last
if mode == 1:
if contrast_flag:
img *= alpha_value
# convert color from BGR to HSV
img = mmcv.bgr2hsv(img)
# random saturation
if saturation_flag:
img[..., 1] *= saturation_value
# For image(type=float32), after convert bgr to hsv by opencv,
# valid saturation value range is [0, 1]
if saturation_value > 1:
img[..., 1] = img[..., 1].clip(0, 1)
# random hue
if hue_flag:
img[..., 0] += hue_value
img[..., 0][img[..., 0] > 360] -= 360
img[..., 0][img[..., 0] < 0] += 360
# convert color from HSV to BGR
img = mmcv.hsv2bgr(img)
# random contrast
if mode == 0:
if contrast_flag:
img *= alpha_value
# randomly swap channels
if swap_flag:
img = img[..., swap_value]
results['img'] = img
return results
def __repr__(self) -> str:
repr_str = self.__class__.__name__
repr_str += f'(brightness_delta={self.brightness_delta}, '
repr_str += 'contrast_range='
repr_str += f'{(self.contrast_lower, self.contrast_upper)}, '
repr_str += 'saturation_range='
repr_str += f'{(self.saturation_lower, self.saturation_upper)}, '
repr_str += f'hue_delta={self.hue_delta})'
return repr_str
@TRANSFORMS.register_module()
class Expand(BaseTransform):
"""Random expand the image & bboxes & masks & segmentation map.
Randomly place the original image on a canvas of ``ratio`` x original image
size filled with mean values. The ratio is in the range of ratio_range.
Required Keys:
- img
- img_shape
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_masks (BitmapMasks | PolygonMasks) (optional)
- gt_seg_map (np.uint8) (optional)
Modified Keys:
- img
- img_shape
- gt_bboxes
- gt_masks
- gt_seg_map
Args:
mean (sequence): mean value of dataset.
to_rgb (bool): if need to convert the order of mean to align with RGB.
ratio_range (sequence)): range of expand ratio.
seg_ignore_label (int): label of ignore segmentation map.
prob (float): probability of applying this transformation
"""
def __init__(self,
mean: Sequence[Number] = (0, 0, 0),
to_rgb: bool = True,
ratio_range: Sequence[Number] = (1, 4),
seg_ignore_label: int = None,
prob: float = 0.5) -> None:
self.to_rgb = to_rgb
self.ratio_range = ratio_range
if to_rgb:
self.mean = mean[::-1]
else:
self.mean = mean
self.min_ratio, self.max_ratio = ratio_range
self.seg_ignore_label = seg_ignore_label
self.prob = prob
@cache_randomness
def _random_prob(self) -> float:
return random.uniform(0, 1)
@cache_randomness
def _random_ratio(self) -> float:
return random.uniform(self.min_ratio, self.max_ratio)
@cache_randomness
def _random_left_top(self, ratio: float, h: int,
w: int) -> Tuple[int, int]:
left = int(random.uniform(0, w * ratio - w))
top = int(random.uniform(0, h * ratio - h))
return left, top
@autocast_box_type()
def transform(self, results: dict) -> dict:
"""Transform function to expand images, bounding boxes, masks,
segmentation map.
Args:
results (dict): Result dict from loading pipeline.
Returns:
dict: Result dict with images, bounding boxes, masks, segmentation
map expanded.
"""
if self._random_prob() > self.prob:
return results
assert 'img' in results, '`img` is not found in results'
img = results['img']
h, w, c = img.shape
ratio = self._random_ratio()
# speedup expand when meets large image
if np.all(self.mean == self.mean[0]):
expand_img = np.empty((int(h * ratio), int(w * ratio), c),
img.dtype)
expand_img.fill(self.mean[0])
else:
expand_img = np.full((int(h * ratio), int(w * ratio), c),
self.mean,
dtype=img.dtype)
left, top = self._random_left_top(ratio, h, w)
expand_img[top:top + h, left:left + w] = img
results['img'] = expand_img
results['img_shape'] = expand_img.shape[:2]
# expand bboxes
if results.get('gt_bboxes', None) is not None:
results['gt_bboxes'].translate_([left, top])
# expand masks
if results.get('gt_masks', None) is not None:
results['gt_masks'] = results['gt_masks'].expand(
int(h * ratio), int(w * ratio), top, left)
# expand segmentation map
if results.get('gt_seg_map', None) is not None:
gt_seg = results['gt_seg_map']
expand_gt_seg = np.full((int(h * ratio), int(w * ratio)),
self.seg_ignore_label,
dtype=gt_seg.dtype)
expand_gt_seg[top:top + h, left:left + w] = gt_seg
results['gt_seg_map'] = expand_gt_seg
return results
def __repr__(self) -> str:
repr_str = self.__class__.__name__
repr_str += f'(mean={self.mean}, to_rgb={self.to_rgb}, '
repr_str += f'ratio_range={self.ratio_range}, '
repr_str += f'seg_ignore_label={self.seg_ignore_label}, '
repr_str += f'prob={self.prob})'
return repr_str
@TRANSFORMS.register_module()
class MinIoURandomCrop(BaseTransform):
"""Random crop the image & bboxes & masks & segmentation map, the cropped
patches have minimum IoU requirement with original image & bboxes & masks.
& segmentation map, the IoU threshold is randomly selected from min_ious.
Required Keys:
- img
- img_shape
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_bboxes_labels (np.int64) (optional)
- gt_masks (BitmapMasks | PolygonMasks) (optional)
- gt_ignore_flags (bool) (optional)
- gt_seg_map (np.uint8) (optional)
Modified Keys:
- img
- img_shape
- gt_bboxes
- gt_bboxes_labels
- gt_masks
- gt_ignore_flags
- gt_seg_map
Args:
min_ious (Sequence[float]): minimum IoU threshold for all intersections
with bounding boxes.
min_crop_size (float): minimum crop's size (i.e. h,w := a*h, a*w,
where a >= min_crop_size).
bbox_clip_border (bool, optional): Whether clip the objects outside
the border of the image. Defaults to True.
"""
def __init__(self,
min_ious: Sequence[float] = (0.1, 0.3, 0.5, 0.7, 0.9),
min_crop_size: float = 0.3,
bbox_clip_border: bool = True) -> None:
self.min_ious = min_ious
self.sample_mode = (1, *min_ious, 0)
self.min_crop_size = min_crop_size
self.bbox_clip_border = bbox_clip_border
@cache_randomness
def _random_mode(self) -> Number:
return random.choice(self.sample_mode)
@autocast_box_type()
def transform(self, results: dict) -> dict:
"""Transform function to crop images and bounding boxes with minimum
IoU constraint.
Args:
results (dict): Result dict from loading pipeline.
Returns:
dict: Result dict with images and bounding boxes cropped, \
'img_shape' key is updated.
"""
assert 'img' in results, '`img` is not found in results'
assert 'gt_bboxes' in results, '`gt_bboxes` is not found in results'
img = results['img']
boxes = results['gt_bboxes']
h, w, c = img.shape
while True:
mode = self._random_mode()
self.mode = mode
if mode == 1:
return results
min_iou = self.mode
for i in range(50):
new_w = random.uniform(self.min_crop_size * w, w)
new_h = random.uniform(self.min_crop_size * h, h)
# h / w in [0.5, 2]
if new_h / new_w < 0.5 or new_h / new_w > 2:
continue
left = random.uniform(w - new_w)
top = random.uniform(h - new_h)
patch = np.array(
(int(left), int(top), int(left + new_w), int(top + new_h)))
# Line or point crop is not allowed
if patch[2] == patch[0] or patch[3] == patch[1]:
continue
overlaps = boxes.overlaps(
HorizontalBoxes(patch.reshape(-1, 4).astype(np.float32)),
boxes).numpy().reshape(-1)
if len(overlaps) > 0 and overlaps.min() < min_iou:
continue
# center of boxes should inside the crop img
# only adjust boxes and instance masks when the gt is not empty
if len(overlaps) > 0:
# adjust boxes
def is_center_of_bboxes_in_patch(boxes, patch):
centers = boxes.centers.numpy()
mask = ((centers[:, 0] > patch[0]) *
(centers[:, 1] > patch[1]) *
(centers[:, 0] < patch[2]) *
(centers[:, 1] < patch[3]))
return mask
mask = is_center_of_bboxes_in_patch(boxes, patch)
if not mask.any():
continue
if results.get('gt_bboxes', None) is not None:
boxes = results['gt_bboxes']
mask = is_center_of_bboxes_in_patch(boxes, patch)
boxes = boxes[mask]
boxes.translate_([-patch[0], -patch[1]])
if self.bbox_clip_border:
boxes.clip_(
[patch[3] - patch[1], patch[2] - patch[0]])
results['gt_bboxes'] = boxes
# ignore_flags
if results.get('gt_ignore_flags', None) is not None:
results['gt_ignore_flags'] = \
results['gt_ignore_flags'][mask]
# labels
if results.get('gt_bboxes_labels', None) is not None:
results['gt_bboxes_labels'] = results[
'gt_bboxes_labels'][mask]
# mask fields
if results.get('gt_masks', None) is not None:
results['gt_masks'] = results['gt_masks'][
mask.nonzero()[0]].crop(patch)
# adjust the img no matter whether the gt is empty before crop
img = img[patch[1]:patch[3], patch[0]:patch[2]]
results['img'] = img
results['img_shape'] = img.shape[:2]
# seg fields
if results.get('gt_seg_map', None) is not None:
results['gt_seg_map'] = results['gt_seg_map'][
patch[1]:patch[3], patch[0]:patch[2]]
return results
def __repr__(self) -> str:
repr_str = self.__class__.__name__
repr_str += f'(min_ious={self.min_ious}, '
repr_str += f'min_crop_size={self.min_crop_size}, '
repr_str += f'bbox_clip_border={self.bbox_clip_border})'
return repr_str
@TRANSFORMS.register_module()
class Corrupt(BaseTransform):
"""Corruption augmentation.
Corruption transforms implemented based on
`imagecorruptions <https://github.com/bethgelab/imagecorruptions>`_.
Required Keys:
- img (np.uint8)
Modified Keys:
- img (np.uint8)
Args:
corruption (str): Corruption name.
severity (int): The severity of corruption. Defaults to 1.
"""
def __init__(self, corruption: str, severity: int = 1) -> None:
self.corruption = corruption
self.severity = severity
def transform(self, results: dict) -> dict:
"""Call function to corrupt image.
Args:
results (dict): Result dict from loading pipeline.
Returns:
dict: Result dict with images corrupted.
"""
if corrupt is None:
raise RuntimeError('imagecorruptions is not installed')
results['img'] = corrupt(
results['img'].astype(np.uint8),
corruption_name=self.corruption,
severity=self.severity)
return results
def __repr__(self) -> str:
repr_str = self.__class__.__name__
repr_str += f'(corruption={self.corruption}, '
repr_str += f'severity={self.severity})'
return repr_str
@TRANSFORMS.register_module()
@avoid_cache_randomness
class Albu(BaseTransform):
"""Albumentation augmentation.
Adds custom transformations from Albumentations library.
Please, visit `https://albumentations.readthedocs.io`
to get more information.
Required Keys:
- img (np.uint8)
- gt_bboxes (HorizontalBoxes[torch.float32]) (optional)
- gt_masks (BitmapMasks | PolygonMasks) (optional)
Modified Keys:
- img (np.uint8)
- gt_bboxes (HorizontalBoxes[torch.float32]) (optional)
- gt_masks (BitmapMasks | PolygonMasks) (optional)
- img_shape (tuple)
An example of ``transforms`` is as followed:
.. code-block::
[
dict(
type='ShiftScaleRotate',
shift_limit=0.0625,
scale_limit=0.0,
rotate_limit=0,
interpolation=1,
p=0.5),
dict(
type='RandomBrightnessContrast',
brightness_limit=[0.1, 0.3],
contrast_limit=[0.1, 0.3],
p=0.2),
dict(type='ChannelShuffle', p=0.1),
dict(
type='OneOf',
transforms=[
dict(type='Blur', blur_limit=3, p=1.0),
dict(type='MedianBlur', blur_limit=3, p=1.0)
],
p=0.1),
]
Args:
transforms (list[dict]): A list of albu transformations
bbox_params (dict, optional): Bbox_params for albumentation `Compose`
keymap (dict, optional): Contains
{'input key':'albumentation-style key'}
skip_img_without_anno (bool): Whether to skip the image if no ann left
after aug. Defaults to False.
"""
def __init__(self,
transforms: List[dict],
bbox_params: Optional[dict] = None,
keymap: Optional[dict] = None,
skip_img_without_anno: bool = False) -> None:
if Compose is None:
raise RuntimeError('albumentations is not installed')
# Args will be modified later, copying it will be safer
transforms = copy.deepcopy(transforms)
if bbox_params is not None:
bbox_params = copy.deepcopy(bbox_params)
if keymap is not None:
keymap = copy.deepcopy(keymap)
self.transforms = transforms
self.filter_lost_elements = False
self.skip_img_without_anno = skip_img_without_anno
# A simple workaround to remove masks without boxes
if (isinstance(bbox_params, dict) and 'label_fields' in bbox_params
and 'filter_lost_elements' in bbox_params):
self.filter_lost_elements = True
self.origin_label_fields = bbox_params['label_fields']
bbox_params['label_fields'] = ['idx_mapper']
del bbox_params['filter_lost_elements']
self.bbox_params = (
self.albu_builder(bbox_params) if bbox_params else None)
self.aug = Compose([self.albu_builder(t) for t in self.transforms],
bbox_params=self.bbox_params)
if not keymap:
self.keymap_to_albu = {
'img': 'image',
'gt_masks': 'masks',
'gt_bboxes': 'bboxes'
}
else:
self.keymap_to_albu = keymap
self.keymap_back = {v: k for k, v in self.keymap_to_albu.items()}
def albu_builder(self, cfg: dict) -> albumentations:
"""Import a module from albumentations.
It inherits some of :func:`build_from_cfg` logic.
Args:
cfg (dict): Config dict. It should at least contain the key "type".
Returns:
obj: The constructed object.
"""
assert isinstance(cfg, dict) and 'type' in cfg
args = cfg.copy()
obj_type = args.pop('type')
if is_str(obj_type):
if albumentations is None:
raise RuntimeError('albumentations is not installed')
obj_cls = getattr(albumentations, obj_type)
elif inspect.isclass(obj_type):
obj_cls = obj_type
else:
raise TypeError(
f'type must be a str or valid type, but got {type(obj_type)}')
if 'transforms' in args:
args['transforms'] = [
self.albu_builder(transform)
for transform in args['transforms']
]
return obj_cls(**args)
@staticmethod
def mapper(d: dict, keymap: dict) -> dict:
"""Dictionary mapper. Renames keys according to keymap provided.
Args:
d (dict): old dict
keymap (dict): {'old_key':'new_key'}
Returns:
dict: new dict.
"""
updated_dict = {}
for k, v in zip(d.keys(), d.values()):
new_k = keymap.get(k, k)
updated_dict[new_k] = d[k]
return updated_dict
@autocast_box_type()
def transform(self, results: dict) -> Union[dict, None]:
"""Transform function of Albu."""
# TODO: gt_seg_map is not currently supported
# dict to albumentations format
results = self.mapper(results, self.keymap_to_albu)
results, ori_masks = self._preprocess_results(results)
results = self.aug(**results)
results = self._postprocess_results(results, ori_masks)
if results is None:
return None
# back to the original format
results = self.mapper(results, self.keymap_back)
results['img_shape'] = results['img'].shape[:2]
return results
def _preprocess_results(self, results: dict) -> tuple:
"""Pre-processing results to facilitate the use of Albu."""
if 'bboxes' in results:
# to list of boxes
if not isinstance(results['bboxes'], HorizontalBoxes):
raise NotImplementedError(
'Albu only supports horizontal boxes now')
bboxes = results['bboxes'].numpy()
results['bboxes'] = [x for x in bboxes]
# add pseudo-field for filtration
if self.filter_lost_elements:
results['idx_mapper'] = np.arange(len(results['bboxes']))
# TODO: Support mask structure in albu
ori_masks = None
if 'masks' in results:
if isinstance(results['masks'], PolygonMasks):
raise NotImplementedError(
'Albu only supports BitMap masks now')
ori_masks = results['masks']
if albumentations.__version__ < '0.5':
results['masks'] = results['masks'].masks
else:
results['masks'] = [mask for mask in results['masks'].masks]
return results, ori_masks
def _postprocess_results(
self,
results: dict,
ori_masks: Optional[Union[BitmapMasks,
PolygonMasks]] = None) -> dict:
"""Post-processing Albu output."""
# albumentations may return np.array or list on different versions
if 'gt_bboxes_labels' in results and isinstance(
results['gt_bboxes_labels'], list):
results['gt_bboxes_labels'] = np.array(
results['gt_bboxes_labels'], dtype=np.int64)
if 'gt_ignore_flags' in results and isinstance(
results['gt_ignore_flags'], list):
results['gt_ignore_flags'] = np.array(
results['gt_ignore_flags'], dtype=bool)
if 'bboxes' in results:
if isinstance(results['bboxes'], list):
results['bboxes'] = np.array(
results['bboxes'], dtype=np.float32)
results['bboxes'] = results['bboxes'].reshape(-1, 4)
results['bboxes'] = HorizontalBoxes(results['bboxes'])
# filter label_fields
if self.filter_lost_elements:
for label in self.origin_label_fields:
results[label] = np.array(
[results[label][i] for i in results['idx_mapper']])
if 'masks' in results:
assert ori_masks is not None
results['masks'] = np.array(
[results['masks'][i] for i in results['idx_mapper']])
results['masks'] = ori_masks.__class__(
results['masks'], ori_masks.height, ori_masks.width)
if (not len(results['idx_mapper'])
and self.skip_img_without_anno):
return None
elif 'masks' in results:
results['masks'] = ori_masks.__class__(results['masks'],
ori_masks.height,
ori_masks.width)
return results
def __repr__(self) -> str:
repr_str = self.__class__.__name__ + f'(transforms={self.transforms})'
return repr_str
@TRANSFORMS.register_module()
@avoid_cache_randomness
class RandomCenterCropPad(BaseTransform):
"""Random center crop and random around padding for CornerNet.
This operation generates randomly cropped image from the original image and
pads it simultaneously. Different from :class:`RandomCrop`, the output
shape may not equal to ``crop_size`` strictly. We choose a random value
from ``ratios`` and the output shape could be larger or smaller than
``crop_size``. The padding operation is also different from :class:`Pad`,
here we use around padding instead of right-bottom padding.
The relation between output image (padding image) and original image:
.. code:: text
output image
+----------------------------+
| padded area |
+------|----------------------------|----------+
| | cropped area | |
| | +---------------+ | |
| | | . center | | | original image
| | | range | | |
| | +---------------+ | |
+------|----------------------------|----------+
| padded area |
+----------------------------+
There are 5 main areas in the figure:
- output image: output image of this operation, also called padding
image in following instruction.
- original image: input image of this operation.
- padded area: non-intersect area of output image and original image.
- cropped area: the overlap of output image and original image.
- center range: a smaller area where random center chosen from.
center range is computed by ``border`` and original image's shape
to avoid our random center is too close to original image's border.
Also this operation act differently in train and test mode, the summary
pipeline is listed below.
Train pipeline:
1. Choose a ``random_ratio`` from ``ratios``, the shape of padding image
will be ``random_ratio * crop_size``.
2. Choose a ``random_center`` in center range.
3. Generate padding image with center matches the ``random_center``.
4. Initialize the padding image with pixel value equals to ``mean``.
5. Copy the cropped area to padding image.
6. Refine annotations.
Test pipeline:
1. Compute output shape according to ``test_pad_mode``.
2. Generate padding image with center matches the original image
center.
3. Initialize the padding image with pixel value equals to ``mean``.
4. Copy the ``cropped area`` to padding image.
Required Keys:
- img (np.float32)
- img_shape (tuple)
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_bboxes_labels (np.int64) (optional)
- gt_ignore_flags (bool) (optional)
Modified Keys:
- img (np.float32)
- img_shape (tuple)
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_bboxes_labels (np.int64) (optional)
- gt_ignore_flags (bool) (optional)
Args:
crop_size (tuple, optional): expected size after crop, final size will
computed according to ratio. Requires (width, height)
in train mode, and None in test mode.
ratios (tuple, optional): random select a ratio from tuple and crop
image to (crop_size[0] * ratio) * (crop_size[1] * ratio).
Only available in train mode. Defaults to (0.9, 1.0, 1.1).
border (int, optional): max distance from center select area to image
border. Only available in train mode. Defaults to 128.
mean (sequence, optional): Mean values of 3 channels.
std (sequence, optional): Std values of 3 channels.
to_rgb (bool, optional): Whether to convert the image from BGR to RGB.
test_mode (bool): whether involve random variables in transform.
In train mode, crop_size is fixed, center coords and ratio is
random selected from predefined lists. In test mode, crop_size
is image's original shape, center coords and ratio is fixed.
Defaults to False.
test_pad_mode (tuple, optional): padding method and padding shape
value, only available in test mode. Default is using
'logical_or' with 127 as padding shape value.
- 'logical_or': final_shape = input_shape | padding_shape_value
- 'size_divisor': final_shape = int(
ceil(input_shape / padding_shape_value) * padding_shape_value)
Defaults to ('logical_or', 127).
test_pad_add_pix (int): Extra padding pixel in test mode.
Defaults to 0.
bbox_clip_border (bool): Whether clip the objects outside
the border of the image. Defaults to True.
"""
def __init__(self,
crop_size: Optional[tuple] = None,
ratios: Optional[tuple] = (0.9, 1.0, 1.1),
border: Optional[int] = 128,
mean: Optional[Sequence] = None,
std: Optional[Sequence] = None,
to_rgb: Optional[bool] = None,
test_mode: bool = False,
test_pad_mode: Optional[tuple] = ('logical_or', 127),
test_pad_add_pix: int = 0,
bbox_clip_border: bool = True) -> None:
if test_mode:
assert crop_size is None, 'crop_size must be None in test mode'
assert ratios is None, 'ratios must be None in test mode'
assert border is None, 'border must be None in test mode'
assert isinstance(test_pad_mode, (list, tuple))
assert test_pad_mode[0] in ['logical_or', 'size_divisor']
else:
assert isinstance(crop_size, (list, tuple))
assert crop_size[0] > 0 and crop_size[1] > 0, (
'crop_size must > 0 in train mode')
assert isinstance(ratios, (list, tuple))
assert test_pad_mode is None, (
'test_pad_mode must be None in train mode')
self.crop_size = crop_size
self.ratios = ratios
self.border = border
# We do not set default value to mean, std and to_rgb because these
# hyper-parameters are easy to forget but could affect the performance.
# Please use the same setting as Normalize for performance assurance.
assert mean is not None and std is not None and to_rgb is not None
self.to_rgb = to_rgb
self.input_mean = mean
self.input_std = std
if to_rgb:
self.mean = mean[::-1]
self.std = std[::-1]
else:
self.mean = mean
self.std = std
self.test_mode = test_mode
self.test_pad_mode = test_pad_mode
self.test_pad_add_pix = test_pad_add_pix
self.bbox_clip_border = bbox_clip_border
def _get_border(self, border, size):
"""Get final border for the target size.
This function generates a ``final_border`` according to image's shape.
The area between ``final_border`` and ``size - final_border`` is the
``center range``. We randomly choose center from the ``center range``
to avoid our random center is too close to original image's border.
Also ``center range`` should be larger than 0.
Args:
border (int): The initial border, default is 128.
size (int): The width or height of original image.
Returns:
int: The final border.
"""
k = 2 * border / size
i = pow(2, np.ceil(np.log2(np.ceil(k))) + (k == int(k)))
return border // i
def _filter_boxes(self, patch, boxes):
"""Check whether the center of each box is in the patch.
Args:
patch (list[int]): The cropped area, [left, top, right, bottom].
boxes (numpy array, (N x 4)): Ground truth boxes.
Returns:
mask (numpy array, (N,)): Each box is inside or outside the patch.
"""
center = boxes.centers.numpy()
mask = (center[:, 0] > patch[0]) * (center[:, 1] > patch[1]) * (
center[:, 0] < patch[2]) * (
center[:, 1] < patch[3])
return mask
def _crop_image_and_paste(self, image, center, size):
"""Crop image with a given center and size, then paste the cropped
image to a blank image with two centers align.
This function is equivalent to generating a blank image with ``size``
as its shape. Then cover it on the original image with two centers (
the center of blank image and the random center of original image)
aligned. The overlap area is paste from the original image and the
outside area is filled with ``mean pixel``.
Args:
image (np array, H x W x C): Original image.
center (list[int]): Target crop center coord.
size (list[int]): Target crop size. [target_h, target_w]
Returns:
cropped_img (np array, target_h x target_w x C): Cropped image.
border (np array, 4): The distance of four border of
``cropped_img`` to the original image area, [top, bottom,
left, right]
patch (list[int]): The cropped area, [left, top, right, bottom].
"""
center_y, center_x = center
target_h, target_w = size
img_h, img_w, img_c = image.shape
x0 = max(0, center_x - target_w // 2)
x1 = min(center_x + target_w // 2, img_w)
y0 = max(0, center_y - target_h // 2)
y1 = min(center_y + target_h // 2, img_h)
patch = np.array((int(x0), int(y0), int(x1), int(y1)))
left, right = center_x - x0, x1 - center_x
top, bottom = center_y - y0, y1 - center_y
cropped_center_y, cropped_center_x = target_h // 2, target_w // 2
cropped_img = np.zeros((target_h, target_w, img_c), dtype=image.dtype)
for i in range(img_c):
cropped_img[:, :, i] += self.mean[i]
y_slice = slice(cropped_center_y - top, cropped_center_y + bottom)
x_slice = slice(cropped_center_x - left, cropped_center_x + right)
cropped_img[y_slice, x_slice, :] = image[y0:y1, x0:x1, :]
border = np.array([
cropped_center_y - top, cropped_center_y + bottom,
cropped_center_x - left, cropped_center_x + right
],
dtype=np.float32)
return cropped_img, border, patch
def _train_aug(self, results):
"""Random crop and around padding the original image.
Args:
results (dict): Image infomations in the augment pipeline.
Returns:
results (dict): The updated dict.
"""
img = results['img']
h, w, c = img.shape
gt_bboxes = results['gt_bboxes']
while True:
scale = random.choice(self.ratios)
new_h = int(self.crop_size[1] * scale)
new_w = int(self.crop_size[0] * scale)
h_border = self._get_border(self.border, h)
w_border = self._get_border(self.border, w)
for i in range(50):
center_x = random.randint(low=w_border, high=w - w_border)
center_y = random.randint(low=h_border, high=h - h_border)
cropped_img, border, patch = self._crop_image_and_paste(
img, [center_y, center_x], [new_h, new_w])
if len(gt_bboxes) == 0:
results['img'] = cropped_img
results['img_shape'] = cropped_img.shape[:2]
return results
# if image do not have valid bbox, any crop patch is valid.
mask = self._filter_boxes(patch, gt_bboxes)
if not mask.any():
continue
results['img'] = cropped_img
results['img_shape'] = cropped_img.shape[:2]
x0, y0, x1, y1 = patch
left_w, top_h = center_x - x0, center_y - y0
cropped_center_x, cropped_center_y = new_w // 2, new_h // 2
# crop bboxes accordingly and clip to the image boundary
gt_bboxes = gt_bboxes[mask]
gt_bboxes.translate_([
cropped_center_x - left_w - x0,
cropped_center_y - top_h - y0
])
if self.bbox_clip_border:
gt_bboxes.clip_([new_h, new_w])
keep = gt_bboxes.is_inside([new_h, new_w]).numpy()
gt_bboxes = gt_bboxes[keep]
results['gt_bboxes'] = gt_bboxes
# ignore_flags
if results.get('gt_ignore_flags', None) is not None:
gt_ignore_flags = results['gt_ignore_flags'][mask]
results['gt_ignore_flags'] = \
gt_ignore_flags[keep]
# labels
if results.get('gt_bboxes_labels', None) is not None:
gt_labels = results['gt_bboxes_labels'][mask]
results['gt_bboxes_labels'] = gt_labels[keep]
if 'gt_masks' in results or 'gt_seg_map' in results:
raise NotImplementedError(
'RandomCenterCropPad only supports bbox.')
return results
def _test_aug(self, results):
"""Around padding the original image without cropping.
The padding mode and value are from ``test_pad_mode``.
Args:
results (dict): Image infomations in the augment pipeline.
Returns:
results (dict): The updated dict.
"""
img = results['img']
h, w, c = img.shape
if self.test_pad_mode[0] in ['logical_or']:
# self.test_pad_add_pix is only used for centernet
target_h = (h | self.test_pad_mode[1]) + self.test_pad_add_pix
target_w = (w | self.test_pad_mode[1]) + self.test_pad_add_pix
elif self.test_pad_mode[0] in ['size_divisor']:
divisor = self.test_pad_mode[1]
target_h = int(np.ceil(h / divisor)) * divisor
target_w = int(np.ceil(w / divisor)) * divisor
else:
raise NotImplementedError(
'RandomCenterCropPad only support two testing pad mode:'
'logical-or and size_divisor.')
cropped_img, border, _ = self._crop_image_and_paste(
img, [h // 2, w // 2], [target_h, target_w])
results['img'] = cropped_img
results['img_shape'] = cropped_img.shape[:2]
results['border'] = border
return results
@autocast_box_type()
def transform(self, results: dict) -> dict:
img = results['img']
assert img.dtype == np.float32, (
'RandomCenterCropPad needs the input image of dtype np.float32,'
' please set "to_float32=True" in "LoadImageFromFile" pipeline')
h, w, c = img.shape
assert c == len(self.mean)
if self.test_mode:
return self._test_aug(results)
else:
return self._train_aug(results)
def __repr__(self):
repr_str = self.__class__.__name__
repr_str += f'(crop_size={self.crop_size}, '
repr_str += f'ratios={self.ratios}, '
repr_str += f'border={self.border}, '
repr_str += f'mean={self.input_mean}, '
repr_str += f'std={self.input_std}, '
repr_str += f'to_rgb={self.to_rgb}, '
repr_str += f'test_mode={self.test_mode}, '
repr_str += f'test_pad_mode={self.test_pad_mode}, '
repr_str += f'bbox_clip_border={self.bbox_clip_border})'
return repr_str
@TRANSFORMS.register_module()
class CutOut(BaseTransform):
"""CutOut operation.
Randomly drop some regions of image used in
`Cutout <https://arxiv.org/abs/1708.04552>`_.
Required Keys:
- img
Modified Keys:
- img
Args:
n_holes (int or tuple[int, int]): Number of regions to be dropped.
If it is given as a list, number of holes will be randomly
selected from the closed interval [``n_holes[0]``, ``n_holes[1]``].
cutout_shape (tuple[int, int] or list[tuple[int, int]], optional):
The candidate shape of dropped regions. It can be
``tuple[int, int]`` to use a fixed cutout shape, or
``list[tuple[int, int]]`` to randomly choose shape
from the list. Defaults to None.
cutout_ratio (tuple[float, float] or list[tuple[float, float]],
optional): The candidate ratio of dropped regions. It can be
``tuple[float, float]`` to use a fixed ratio or
``list[tuple[float, float]]`` to randomly choose ratio
from the list. Please note that ``cutout_shape`` and
``cutout_ratio`` cannot be both given at the same time.
Defaults to None.
fill_in (tuple[float, float, float] or tuple[int, int, int]): The value
of pixel to fill in the dropped regions. Defaults to (0, 0, 0).
"""
def __init__(
self,
n_holes: Union[int, Tuple[int, int]],
cutout_shape: Optional[Union[Tuple[int, int],
List[Tuple[int, int]]]] = None,
cutout_ratio: Optional[Union[Tuple[float, float],
List[Tuple[float, float]]]] = None,
fill_in: Union[Tuple[float, float, float], Tuple[int, int,
int]] = (0, 0, 0)
) -> None:
assert (cutout_shape is None) ^ (cutout_ratio is None), \
'Either cutout_shape or cutout_ratio should be specified.'
assert (isinstance(cutout_shape, (list, tuple))
or isinstance(cutout_ratio, (list, tuple)))
if isinstance(n_holes, tuple):
assert len(n_holes) == 2 and 0 <= n_holes[0] < n_holes[1]
else:
n_holes = (n_holes, n_holes)
self.n_holes = n_holes
self.fill_in = fill_in
self.with_ratio = cutout_ratio is not None
self.candidates = cutout_ratio if self.with_ratio else cutout_shape
if not isinstance(self.candidates, list):
self.candidates = [self.candidates]
@autocast_box_type()
def transform(self, results: dict) -> dict:
"""Call function to drop some regions of image."""
h, w, c = results['img'].shape
n_holes = np.random.randint(self.n_holes[0], self.n_holes[1] + 1)
for _ in range(n_holes):
x1 = np.random.randint(0, w)
y1 = np.random.randint(0, h)
index = np.random.randint(0, len(self.candidates))
if not self.with_ratio:
cutout_w, cutout_h = self.candidates[index]
else:
cutout_w = int(self.candidates[index][0] * w)
cutout_h = int(self.candidates[index][1] * h)
x2 = np.clip(x1 + cutout_w, 0, w)
y2 = np.clip(y1 + cutout_h, 0, h)
results['img'][y1:y2, x1:x2, :] = self.fill_in
return results
def __repr__(self):
repr_str = self.__class__.__name__
repr_str += f'(n_holes={self.n_holes}, '
repr_str += (f'cutout_ratio={self.candidates}, ' if self.with_ratio
else f'cutout_shape={self.candidates}, ')
repr_str += f'fill_in={self.fill_in})'
return repr_str
@TRANSFORMS.register_module()
class Mosaic(BaseTransform):
"""Mosaic augmentation.
Given 4 images, mosaic transform combines them into
one output image. The output image is composed of the parts from each sub-
image.
.. code:: text
mosaic transform
center_x
+------------------------------+
| pad | pad |
| +-----------+ |
| | | |
| | image1 |--------+ |
| | | | |
| | | image2 | |
center_y |----+-------------+-----------|
| | cropped | |
|pad | image3 | image4 |
| | | |
+----|-------------+-----------+
| |
+-------------+
The mosaic transform steps are as follows:
1. Choose the mosaic center as the intersections of 4 images
2. Get the left top image according to the index, and randomly
sample another 3 images from the custom dataset.
3. Sub image will be cropped if image is larger than mosaic patch
Required Keys:
- img
- gt_bboxes (BaseBoxes[torch.float32]) (optional)
- gt_bboxes_labels (np.int64) (optional)
- gt_ignore_flags (bool) (optional)
- mix_results (List[dict])
Modified Keys:
- img
- img_shape
- gt_bboxes (optional)
- gt_bboxes_labels (optional)
- gt_ignore_flags (optional)
Args:
img_scale (Sequence[int]): Image size before mosaic pipeline of single
image. The shape order should be (width, height).
Defaults to (640, 640).
center_ratio_range (Sequence[float]): Center ratio range of mosaic
output. Defaults to (0.5, 1.5).
bbox_clip_border (bool, optional): Whether to clip the objects outside
the border of the image. In some dataset like MOT17, the gt bboxes
are allowed to cross the border of images. Therefore, we don't
need to clip the gt bboxes in these cases. Defaults to True.
pad_val (int): Pad value. Defaults to 114.
prob (float): Probability of applying this transformation.
Defaults to 1.0.
"""
def __init__(self,
img_scale: Tuple[int, int] = (640, 640),
center_ratio_range: Tuple[float, float] = (0.5, 1.5),
bbox_clip_border: bool = True,
pad_val: float = 114.0,
prob: float = 1.0) -> None:
assert isinstance(img_scale, tuple)
assert 0 <= prob <= 1.0, 'The probability should be in range [0,1]. ' \
f'got {prob}.'
| log_img_scale(img_scale, skip_square=True, shape_order='wh') | 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,893 | 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(
self.model.model,
ckpt_fp,
target_replace_module=set(target_replace_module),
)
print(f"[INFO] Saved LoRA to {ckpt_fp}")
def remove_lora(self):
print("[INFO] Removing LoRA")
|
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(
self.model.model,
ckpt_fp,
target_replace_module=set(target_replace_module),
)
print(f"[INFO] Saved LoRA to {ckpt_fp}")
def remove_lora(self):
print("[INFO] Removing LoRA") | monkeypatch_remove_lora(self.model.model) | 1 | 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 | 15,725 | 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(
| 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( | 9 | 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,323 | """
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
)
| # 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]) | 5 | 2023-12-15 20:07:22+00:00 | 24k |
alipay/PainlessInferenceAcceleration | pia/lookahead/models/chatglm/modeling_chatglm.py | [
{
"identifier": "ChatGLMConfig",
"path": "pia/lookahead/models/chatglm/configuration_chatglm.py",
"snippet": "class ChatGLMConfig(PretrainedConfig):\n model_type = \"chatglm\"\n\n def __init__(\n self,\n num_layers=28,\n padded_vocab_size=65024,\n hidden... | import copy
import math
import warnings
import torch
import torch.nn.functional as F
import torch.utils.checkpoint
from typing import Optional, Tuple, List, Callable, Dict, Any
from pia.lookahead.models.chatglm.configuration_chatglm import ChatGLMConfig
from torch import nn
from torch.nn import CrossEntropyLoss, LayerNorm
from torch.nn.utils import skip_init
from transformers.generation.logits_process import LogitsProcessor
from transformers.generation.utils import LogitsProcessorList, StoppingCriteriaList, GenerationConfig, ModelOutput
from transformers.modeling_outputs import (
BaseModelOutputWithPast,
CausalLMOutputWithPast,
)
from transformers.utils import logging
from pia.lookahead.common.pretrained_model import LookaheadPreTrainedModel | 16,924 | attention_output, kv_cache = self.self_attention(
layernorm_output,
attention_mask,
rotary_pos_emb,
kv_cache=kv_cache,
use_cache=use_cache
)
# Residual connection.
if self.apply_residual_connection_post_layernorm:
residual = layernorm_output
else:
residual = hidden_states
# layernorm_input = torch.nn.functional.dropout(attention_output, p=self.hidden_dropout, training=self.training)
layernorm_input = attention_output
layernorm_input = residual + layernorm_input
# Layer norm post the self attention.
layernorm_output = self.post_attention_layernorm(layernorm_input)
# MLP.
mlp_output = self.mlp(layernorm_output)
# Second residual connection.
if self.apply_residual_connection_post_layernorm:
residual = layernorm_output
else:
residual = layernorm_input
# output = torch.nn.functional.dropout(mlp_output, p=self.hidden_dropout, training=self.training)
output = mlp_output
output = residual + output
return output, kv_cache
class GLMTransformer(torch.nn.Module):
"""Transformer class."""
def __init__(self, config: ChatGLMConfig, device=None):
super(GLMTransformer, self).__init__()
self.fp32_residual_connection = config.fp32_residual_connection
self.post_layer_norm = config.post_layer_norm
# Number of layers.
self.num_layers = config.num_layers
# Transformer layers.
def build_layer(layer_number):
return GLMBlock(config, layer_number, device=device)
self.layers = torch.nn.ModuleList([build_layer(i + 1) for i in range(self.num_layers)])
if self.post_layer_norm:
LayerNormFunc = RMSNorm if config.rmsnorm else LayerNorm
# Final layer norm before output.
self.final_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device,
dtype=config.torch_dtype)
self.gradient_checkpointing = False
def _get_layer(self, layer_number):
return self.layers[layer_number]
def forward(
self, hidden_states, attention_mask, rotary_pos_emb, kv_caches=None,
use_cache: Optional[bool] = True,
output_hidden_states: Optional[bool] = False,
):
num_layers = len(self.layers)
if not kv_caches:
kv_caches = [None for _ in range(num_layers)]
presents = () if use_cache else None
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
all_self_attentions = None
all_hidden_states = () if output_hidden_states else None
for index in range(num_layers):
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
layer = self._get_layer(index)
if self.gradient_checkpointing and self.training:
layer_ret = torch.utils.checkpoint.checkpoint(
layer,
hidden_states,
attention_mask,
rotary_pos_emb,
kv_caches[index],
use_cache
)
else:
layer_ret = layer(
hidden_states,
attention_mask,
rotary_pos_emb,
kv_cache=kv_caches[index],
use_cache=use_cache
)
hidden_states, kv_cache = layer_ret
if use_cache:
presents = presents + (kv_cache,)
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
# Final layer norm.
if self.post_layer_norm:
hidden_states = self.final_layernorm(hidden_states)
return hidden_states, presents, all_hidden_states, all_self_attentions
| """ PyTorch ChatGLM model. """
# from transformers.modeling_utils import PreTrainedModel
# flags required to enable jit fusion kernels
# if sys.platform != 'darwin':
# torch._C._jit_set_profiling_mode(False)
# torch._C._jit_set_profiling_executor(False)
# torch._C._jit_override_can_fuse_on_cpu(True)
# torch._C._jit_override_can_fuse_on_gpu(True)
logger = logging.get_logger(__name__)
_CHECKPOINT_FOR_DOC = "THUDM/ChatGLM2-6B"
_CONFIG_FOR_DOC = "ChatGLM6BConfig"
CHATGLM_6B_PRETRAINED_MODEL_ARCHIVE_LIST = [
"THUDM/chatglm2-6b",
# See all ChatGLM models at https://huggingface.co/models?filter=chatglm
]
def default_init(cls, *args, **kwargs):
return cls(*args, **kwargs)
class InvalidScoreLogitsProcessor(LogitsProcessor):
def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:
if torch.isnan(scores).any() or torch.isinf(scores).any():
scores.zero_()
scores[..., 5] = 5e4
return scores
class PrefixEncoder(torch.nn.Module):
"""
The torch.nn model to encode the prefix
Input shape: (batch-size, prefix-length)
Output shape: (batch-size, prefix-length, 2*layers*hidden)
"""
def __init__(self, config: ChatGLMConfig):
super().__init__()
self.prefix_projection = config.prefix_projection
if self.prefix_projection:
# Use a two-layer MLP to encode the prefix
self.embedding = torch.nn.Embedding(config.pre_seq_len, config.hidden_size)
self.trans = torch.nn.Sequential(
torch.nn.Linear(config.hidden_size, config.hidden_size),
torch.nn.Tanh(),
torch.nn.Linear(config.hidden_size, config.num_layers * config.hidden_size * 2)
)
else:
self.embedding = torch.nn.Embedding(config.pre_seq_len,
config.num_layers * config.kv_channels * config.multi_query_group_num * 2)
def forward(self, prefix: torch.Tensor):
if self.prefix_projection:
prefix_tokens = self.embedding(prefix)
past_key_values = self.trans(prefix_tokens)
else:
past_key_values = self.embedding(prefix)
return past_key_values
def split_tensor_along_last_dim(
tensor: torch.Tensor,
num_partitions: int,
contiguous_split_chunks: bool = False,
) -> List[torch.Tensor]:
"""Split a tensor along its last dimension.
Arguments:
tensor: input tensor.
num_partitions: number of partitions to split the tensor
contiguous_split_chunks: If True, make each chunk contiguous
in memory.
Returns:
A list of Tensors
"""
# Get the size and dimension.
last_dim = tensor.dim() - 1
last_dim_size = tensor.size()[last_dim] // num_partitions
# Split.
tensor_list = torch.split(tensor, last_dim_size, dim=last_dim)
# Note: torch.split does not create contiguous tensors by default.
if contiguous_split_chunks:
return tuple(chunk.contiguous() for chunk in tensor_list)
return tensor_list
class RotaryEmbedding(nn.Module):
def __init__(self, dim, original_impl=False, device=None, dtype=None):
super().__init__()
inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2, device=device).to(dtype=dtype) / dim))
self.register_buffer("inv_freq", inv_freq)
self.dim = dim
self.original_impl = original_impl
def forward_impl(
self, seq_len: int, n_elem: int, dtype: torch.dtype, device: torch.device, base: int = 10000
):
"""Enhanced Transformer with Rotary Position Embedding.
Derived from: https://github.com/labmlai/annotated_deep_learning_paper_implementations/blob/master/labml_nn/
transformers/rope/__init__.py. MIT License:
https://github.com/labmlai/annotated_deep_learning_paper_implementations/blob/master/license.
"""
# $\Theta = {\theta_i = 10000^{\frac{2(i-1)}{d}}, i \in [1, 2, ..., \frac{d}{2}]}$
theta = 1.0 / (base ** (torch.arange(0, n_elem, 2, dtype=dtype, device=device) / n_elem))
# Create position indexes `[0, 1, ..., seq_len - 1]`
seq_idx = torch.arange(seq_len, dtype=dtype, device=device)
# Calculate the product of position index and $\theta_i$
idx_theta = torch.outer(seq_idx, theta).float()
cache = torch.stack([torch.cos(idx_theta), torch.sin(idx_theta)], dim=-1)
# this is to mimic the behaviour of complex32, else we will get different results
if dtype in (torch.float16, torch.bfloat16, torch.int8):
cache = cache.bfloat16() if dtype == torch.bfloat16 else cache.half()
return cache
def forward(self, max_seq_len, offset=0):
return self.forward_impl(
max_seq_len, self.dim, dtype=self.inv_freq.dtype, device=self.inv_freq.device
)
# @torch.jit.script
def apply_rotary_pos_emb(x: torch.Tensor, rope_cache: torch.Tensor) -> torch.Tensor:
# x: [sq, b, np, hn]
sq, b, np, hn = x.size(0), x.size(1), x.size(2), x.size(3)
rot_dim = rope_cache.shape[-2] * 2
x, x_pass = x[..., :rot_dim], x[..., rot_dim:]
# truncate to support variable sizes
rope_cache = rope_cache[:sq]
xshaped = x.reshape(sq, -1, np, rot_dim // 2, 2)
rope_cache = rope_cache.view(sq, -1, 1, xshaped.size(3), 2)
x_out2 = torch.stack(
[
xshaped[..., 0] * rope_cache[..., 0] - xshaped[..., 1] * rope_cache[..., 1],
xshaped[..., 1] * rope_cache[..., 0] + xshaped[..., 0] * rope_cache[..., 1],
],
-1,
)
x_out2 = x_out2.flatten(3)
return torch.cat((x_out2, x_pass), dim=-1)
class RMSNorm(torch.nn.Module):
def __init__(self, normalized_shape, eps=1e-5, device=None, dtype=None, **kwargs):
super().__init__()
self.weight = torch.nn.Parameter(torch.empty(normalized_shape, device=device, dtype=dtype))
self.eps = eps
def forward(self, hidden_states: torch.Tensor):
input_dtype = hidden_states.dtype
variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
hidden_states = hidden_states * torch.rsqrt(variance + self.eps)
return (self.weight * hidden_states).to(input_dtype)
class CoreAttention(torch.nn.Module):
def __init__(self, config: ChatGLMConfig, layer_number):
super(CoreAttention, self).__init__()
self.apply_query_key_layer_scaling = config.apply_query_key_layer_scaling
self.attention_softmax_in_fp32 = config.attention_softmax_in_fp32
if self.apply_query_key_layer_scaling:
self.attention_softmax_in_fp32 = True
self.layer_number = max(1, layer_number)
projection_size = config.kv_channels * config.num_attention_heads
# Per attention head and per partition values.
self.hidden_size_per_partition = projection_size
self.hidden_size_per_attention_head = projection_size // config.num_attention_heads
self.num_attention_heads_per_partition = config.num_attention_heads
coeff = None
self.norm_factor = math.sqrt(self.hidden_size_per_attention_head)
if self.apply_query_key_layer_scaling:
coeff = self.layer_number
self.norm_factor *= coeff
self.coeff = coeff
# self.attention_dropout = torch.nn.Dropout(config.attention_dropout)
def forward(self, query_layer, key_layer, value_layer, attention_mask):
pytorch_major_version = int(torch.__version__.split('.')[0])
if pytorch_major_version >= 2:
query_layer, key_layer, value_layer = [k.permute(1, 2, 0, 3) for k in [query_layer, key_layer, value_layer]]
if attention_mask is None and query_layer.shape[2] == key_layer.shape[2]:
context_layer = torch.nn.functional.scaled_dot_product_attention(query_layer, key_layer, value_layer,
is_causal=True)
else:
if attention_mask is not None:
attention_mask = ~attention_mask
context_layer = torch.nn.functional.scaled_dot_product_attention(query_layer, key_layer, value_layer,
attention_mask)
context_layer = context_layer.permute(2, 0, 1, 3)
new_context_layer_shape = context_layer.size()[:-2] + (self.hidden_size_per_partition,)
context_layer = context_layer.reshape(*new_context_layer_shape)
else:
# Raw attention scores
# [b, np, sq, sk]
output_size = (query_layer.size(1), query_layer.size(2), query_layer.size(0), key_layer.size(0))
# [sq, b, np, hn] -> [sq, b * np, hn]
query_layer = query_layer.view(output_size[2], output_size[0] * output_size[1], -1)
# [sk, b, np, hn] -> [sk, b * np, hn]
key_layer = key_layer.view(output_size[3], output_size[0] * output_size[1], -1)
# preallocting input tensor: [b * np, sq, sk]
matmul_input_buffer = torch.empty(
output_size[0] * output_size[1], output_size[2], output_size[3], dtype=query_layer.dtype,
device=query_layer.device
)
# Raw attention scores. [b * np, sq, sk]
matmul_result = torch.baddbmm(
matmul_input_buffer,
query_layer.transpose(0, 1), # [b * np, sq, hn]
key_layer.transpose(0, 1).transpose(1, 2), # [b * np, hn, sk]
beta=0.0,
alpha=(1.0 / self.norm_factor),
)
# change view to [b, np, sq, sk]
attention_scores = matmul_result.view(*output_size)
# ===========================
# Attention probs and dropout
# ===========================
# attention scores and attention mask [b, np, sq, sk]
if self.attention_softmax_in_fp32:
attention_scores = attention_scores.float()
if self.coeff is not None:
attention_scores = attention_scores * self.coeff
if attention_mask is None and attention_scores.shape[2] == attention_scores.shape[3]:
attention_mask = torch.ones(output_size[0], 1, output_size[2], output_size[3],
device=attention_scores.device, dtype=torch.bool)
attention_mask.tril_()
attention_mask = ~attention_mask
if attention_mask is not None:
attention_scores = attention_scores.masked_fill(attention_mask, float("-inf"))
attention_probs = F.softmax(attention_scores, dim=-1)
attention_probs = attention_probs.type_as(value_layer)
# 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.attention_dropout(attention_probs)
# =========================
# Context layer. [sq, b, hp]
# =========================
# value_layer -> context layer.
# [sk, b, np, hn] --> [b, np, sq, hn]
# context layer shape: [b, np, sq, hn]
output_size = (value_layer.size(1), value_layer.size(2), query_layer.size(0), value_layer.size(3))
# change view [sk, b * np, hn]
value_layer = value_layer.view(value_layer.size(0), output_size[0] * output_size[1], -1)
# change view [b * np, sq, sk]
attention_probs = attention_probs.view(output_size[0] * output_size[1], output_size[2], -1)
# matmul: [b * np, sq, hn]
context_layer = torch.bmm(attention_probs, value_layer.transpose(0, 1))
# change view [b, np, sq, hn]
context_layer = context_layer.view(*output_size)
# [b, np, sq, hn] --> [sq, b, np, hn]
context_layer = context_layer.permute(2, 0, 1, 3).contiguous()
# [sq, b, np, hn] --> [sq, b, hp]
new_context_layer_shape = context_layer.size()[:-2] + (self.hidden_size_per_partition,)
context_layer = context_layer.view(*new_context_layer_shape)
return context_layer
class SelfAttention(torch.nn.Module):
"""Parallel self-attention layer abstract class.
Self-attention layer takes input with size [s, b, h]
and returns output of the same size.
"""
def __init__(self, config: ChatGLMConfig, layer_number, device=None):
super(SelfAttention, self).__init__()
self.layer_number = max(1, layer_number)
self.projection_size = config.kv_channels * config.num_attention_heads
# Per attention head and per partition values.
self.hidden_size_per_attention_head = self.projection_size // config.num_attention_heads
self.num_attention_heads_per_partition = config.num_attention_heads
self.multi_query_attention = config.multi_query_attention
self.qkv_hidden_size = 3 * self.projection_size
if self.multi_query_attention:
self.num_multi_query_groups_per_partition = config.multi_query_group_num
self.qkv_hidden_size = (
self.projection_size + 2 * self.hidden_size_per_attention_head * config.multi_query_group_num
)
self.query_key_value = nn.Linear(config.hidden_size, self.qkv_hidden_size,
bias=config.add_bias_linear or config.add_qkv_bias,
device=device, **_config_to_kwargs(config)
)
self.core_attention = CoreAttention(config, self.layer_number)
# Output.
self.dense = nn.Linear(self.projection_size, config.hidden_size, bias=config.add_bias_linear,
device=device, **_config_to_kwargs(config)
)
def _allocate_memory(self, inference_max_sequence_len, batch_size, device=None, dtype=None):
if self.multi_query_attention:
num_attention_heads = self.num_multi_query_groups_per_partition
else:
num_attention_heads = self.num_attention_heads_per_partition
return torch.empty(
inference_max_sequence_len,
batch_size,
num_attention_heads,
self.hidden_size_per_attention_head,
dtype=dtype,
device=device,
)
def forward(
self, hidden_states, attention_mask, rotary_pos_emb, kv_cache=None, use_cache=True
):
# hidden_states: [sq, b, h]
# =================================================
# Pre-allocate memory for key-values for inference.
# =================================================
# =====================
# Query, Key, and Value
# =====================
# Attention heads [sq, b, h] --> [sq, b, (np * 3 * hn)]
mixed_x_layer = self.query_key_value(hidden_states)
if self.multi_query_attention:
(query_layer, key_layer, value_layer) = mixed_x_layer.split(
[
self.num_attention_heads_per_partition * self.hidden_size_per_attention_head,
self.num_multi_query_groups_per_partition * self.hidden_size_per_attention_head,
self.num_multi_query_groups_per_partition * self.hidden_size_per_attention_head,
],
dim=-1,
)
query_layer = query_layer.view(
query_layer.size()[:-1] + (self.num_attention_heads_per_partition, self.hidden_size_per_attention_head)
)
key_layer = key_layer.view(
key_layer.size()[:-1] + (self.num_multi_query_groups_per_partition, self.hidden_size_per_attention_head)
)
value_layer = value_layer.view(
value_layer.size()[:-1]
+ (self.num_multi_query_groups_per_partition, self.hidden_size_per_attention_head)
)
else:
new_tensor_shape = mixed_x_layer.size()[:-1] + \
(self.num_attention_heads_per_partition,
3 * self.hidden_size_per_attention_head)
mixed_x_layer = mixed_x_layer.view(*new_tensor_shape)
# [sq, b, np, 3 * hn] --> 3 [sq, b, np, hn]
(query_layer, key_layer, value_layer) = split_tensor_along_last_dim(mixed_x_layer, 3)
# apply relative positional encoding (rotary embedding)
if rotary_pos_emb is not None:
query_layer = apply_rotary_pos_emb(query_layer, rotary_pos_emb)
key_layer = apply_rotary_pos_emb(key_layer, rotary_pos_emb)
# adjust key and value for inference
if kv_cache is not None:
cache_k, cache_v = kv_cache
key_layer = torch.cat((cache_k, key_layer), dim=0)
value_layer = torch.cat((cache_v, value_layer), dim=0)
if use_cache:
kv_cache = (key_layer, value_layer)
else:
kv_cache = None
if self.multi_query_attention:
key_layer = key_layer.unsqueeze(-2)
key_layer = key_layer.expand(
-1, -1, -1, self.num_attention_heads_per_partition // self.num_multi_query_groups_per_partition, -1
)
key_layer = key_layer.contiguous().view(
key_layer.size()[:2] + (self.num_attention_heads_per_partition, self.hidden_size_per_attention_head)
)
value_layer = value_layer.unsqueeze(-2)
value_layer = value_layer.expand(
-1, -1, -1, self.num_attention_heads_per_partition // self.num_multi_query_groups_per_partition, -1
)
value_layer = value_layer.contiguous().view(
value_layer.size()[:2] + (self.num_attention_heads_per_partition, self.hidden_size_per_attention_head)
)
# ==================================
# core attention computation
# ==================================
context_layer = self.core_attention(query_layer, key_layer, value_layer, attention_mask)
# =================
# Output. [sq, b, h]
# =================
output = self.dense(context_layer)
return output, kv_cache
def _config_to_kwargs(args):
common_kwargs = {
"dtype": args.torch_dtype,
}
return common_kwargs
class MLP(torch.nn.Module):
"""MLP.
MLP will take the input with h hidden state, project it to 4*h
hidden dimension, perform nonlinear transformation, and project the
state back into h hidden dimension.
"""
def __init__(self, config: ChatGLMConfig, device=None):
super(MLP, self).__init__()
self.add_bias = config.add_bias_linear
# Project to 4h. If using swiglu double the output width, see https://arxiv.org/pdf/2002.05202.pdf
self.dense_h_to_4h = nn.Linear(
config.hidden_size,
config.ffn_hidden_size * 2,
bias=self.add_bias,
device=device,
**_config_to_kwargs(config)
)
def swiglu(x):
x = torch.chunk(x, 2, dim=-1)
return F.silu(x[0]) * x[1]
self.activation_func = swiglu
# Project back to h.
self.dense_4h_to_h = nn.Linear(
config.ffn_hidden_size,
config.hidden_size,
bias=self.add_bias,
device=device,
**_config_to_kwargs(config)
)
def forward(self, hidden_states):
# [s, b, 4hp]
intermediate_parallel = self.dense_h_to_4h(hidden_states)
intermediate_parallel = self.activation_func(intermediate_parallel)
# [s, b, h]
output = self.dense_4h_to_h(intermediate_parallel)
return output
class GLMBlock(torch.nn.Module):
"""A single transformer layer.
Transformer layer takes input with size [s, b, h] and returns an
output of the same size.
"""
def __init__(self, config: ChatGLMConfig, layer_number, device=None):
super(GLMBlock, self).__init__()
self.layer_number = layer_number
self.apply_residual_connection_post_layernorm = config.apply_residual_connection_post_layernorm
self.fp32_residual_connection = config.fp32_residual_connection
LayerNormFunc = RMSNorm if config.rmsnorm else LayerNorm
# Layernorm on the input data.
self.input_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device,
dtype=config.torch_dtype)
# Self attention.
self.self_attention = SelfAttention(config, layer_number, device=device)
# self.hidden_dropout = config.hidden_dropout
# Layernorm on the attention output
self.post_attention_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device,
dtype=config.torch_dtype)
# MLP
self.mlp = MLP(config, device=device)
def forward(
self, hidden_states, attention_mask, rotary_pos_emb, kv_cache=None, use_cache=True,
):
# hidden_states: [s, b, h]
# Layer norm at the beginning of the transformer layer.
layernorm_output = self.input_layernorm(hidden_states)
# Self attention.
attention_output, kv_cache = self.self_attention(
layernorm_output,
attention_mask,
rotary_pos_emb,
kv_cache=kv_cache,
use_cache=use_cache
)
# Residual connection.
if self.apply_residual_connection_post_layernorm:
residual = layernorm_output
else:
residual = hidden_states
# layernorm_input = torch.nn.functional.dropout(attention_output, p=self.hidden_dropout, training=self.training)
layernorm_input = attention_output
layernorm_input = residual + layernorm_input
# Layer norm post the self attention.
layernorm_output = self.post_attention_layernorm(layernorm_input)
# MLP.
mlp_output = self.mlp(layernorm_output)
# Second residual connection.
if self.apply_residual_connection_post_layernorm:
residual = layernorm_output
else:
residual = layernorm_input
# output = torch.nn.functional.dropout(mlp_output, p=self.hidden_dropout, training=self.training)
output = mlp_output
output = residual + output
return output, kv_cache
class GLMTransformer(torch.nn.Module):
"""Transformer class."""
def __init__(self, config: ChatGLMConfig, device=None):
super(GLMTransformer, self).__init__()
self.fp32_residual_connection = config.fp32_residual_connection
self.post_layer_norm = config.post_layer_norm
# Number of layers.
self.num_layers = config.num_layers
# Transformer layers.
def build_layer(layer_number):
return GLMBlock(config, layer_number, device=device)
self.layers = torch.nn.ModuleList([build_layer(i + 1) for i in range(self.num_layers)])
if self.post_layer_norm:
LayerNormFunc = RMSNorm if config.rmsnorm else LayerNorm
# Final layer norm before output.
self.final_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device,
dtype=config.torch_dtype)
self.gradient_checkpointing = False
def _get_layer(self, layer_number):
return self.layers[layer_number]
def forward(
self, hidden_states, attention_mask, rotary_pos_emb, kv_caches=None,
use_cache: Optional[bool] = True,
output_hidden_states: Optional[bool] = False,
):
num_layers = len(self.layers)
if not kv_caches:
kv_caches = [None for _ in range(num_layers)]
presents = () if use_cache else None
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
all_self_attentions = None
all_hidden_states = () if output_hidden_states else None
for index in range(num_layers):
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
layer = self._get_layer(index)
if self.gradient_checkpointing and self.training:
layer_ret = torch.utils.checkpoint.checkpoint(
layer,
hidden_states,
attention_mask,
rotary_pos_emb,
kv_caches[index],
use_cache
)
else:
layer_ret = layer(
hidden_states,
attention_mask,
rotary_pos_emb,
kv_cache=kv_caches[index],
use_cache=use_cache
)
hidden_states, kv_cache = layer_ret
if use_cache:
presents = presents + (kv_cache,)
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
# Final layer norm.
if self.post_layer_norm:
hidden_states = self.final_layernorm(hidden_states)
return hidden_states, presents, all_hidden_states, all_self_attentions
| class ChatGLMPreTrainedModel(LookaheadPreTrainedModel): | 1 | 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,306 | 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)
)
]
)
self._feature_size = model_channels
input_block_chans = [model_channels]
ch = model_channels
ds = 1
for level, mult in enumerate(channel_mult):
for nr in range(self.num_res_blocks[level]):
layers = [
ResBlock(
ch,
time_embed_dim,
dropout,
out_channels=mult * model_channels,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
)
]
ch = mult * model_channels
if ds in attention_resolutions:
if num_head_channels == -1:
dim_head = ch // num_heads
else:
num_heads = ch // num_head_channels
dim_head = num_head_channels
if legacy:
#num_heads = 1
dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
if exists(disable_self_attentions):
disabled_sa = disable_self_attentions[level]
else:
disabled_sa = False
if not exists(num_attention_blocks) or nr < num_attention_blocks[level]:
layers.append(
AttentionBlock(
ch,
use_checkpoint=use_checkpoint,
num_heads=num_heads,
num_head_channels=dim_head,
use_new_attention_order=use_new_attention_order,
|
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)
)
]
)
self._feature_size = model_channels
input_block_chans = [model_channels]
ch = model_channels
ds = 1
for level, mult in enumerate(channel_mult):
for nr in range(self.num_res_blocks[level]):
layers = [
ResBlock(
ch,
time_embed_dim,
dropout,
out_channels=mult * model_channels,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
)
]
ch = mult * model_channels
if ds in attention_resolutions:
if num_head_channels == -1:
dim_head = ch // num_heads
else:
num_heads = ch // num_head_channels
dim_head = num_head_channels
if legacy:
#num_heads = 1
dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
if exists(disable_self_attentions):
disabled_sa = disable_self_attentions[level]
else:
disabled_sa = False
if not exists(num_attention_blocks) or nr < num_attention_blocks[level]:
layers.append(
AttentionBlock(
ch,
use_checkpoint=use_checkpoint,
num_heads=num_heads,
num_head_channels=dim_head,
use_new_attention_order=use_new_attention_order, | ) if not use_spatial_transformer else SpatialTransformer( | 4 | 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,540 | 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)
| """
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) | 2 | 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 | 17,572 |
self.use_nfm = use_nfm
#self.n_heads = n_heads
self.n_heads = 12
self.n_blocks = n_blocks
self.dim = dim
self.block_dim = dim // self.n_blocks
#self.head_dim = self.block_dim // self.n_heads
self.head_dim = 64
self.scale = self.head_dim ** -0.5
self.query_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)
self.key_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)
self.value_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)
self.final = GroupLinearLayer(self.head_dim * self.n_heads, self.block_dim, n_blocks)
def forward(self, x, qkv=None):
use_exshare = False
if qkv is not None:
klst, vlst = qkv
seq_len, bsz, _ = x.shape
if use_exshare:
x = x.view(seq_len, bsz, self.n_blocks * self.block_dim)
q = self.query_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)
k = self.key_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)
v = self.value_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)
else:
x = x.view(seq_len, bsz, self.n_blocks * self.block_dim)
q = self.query_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)
k = self.key_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)
v = self.value_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)
q = q.transpose(2,3) * self.scale
k = k.transpose(2,3)
v = v.transpose(2,3)
if random.uniform(0,1) < 0.00001:
print('use NFM?', self.use_nfm)
if self.use_nfm:
if qkv is not None:
klst.append(k)
vlst.append(v)
#print('len qlst', len(qlst))
#for kval in klst:
# print(kval.shape)
k = torch.cat(klst, dim=3)
v = torch.cat(vlst, dim=3)
#should return these q,k,v and save to a big list. Also pull in from the list passed in and concat along dim=3, i.e. so that it's nblocks * nlayers.
#print('running comm attention with shapes', q.shape, k.shape, v.shape)
score = torch.matmul(q, k.transpose(3,4))
#print('score shape', score.shape)
score = F.softmax(score, dim=-1)
out = torch.matmul(score, v).transpose(2,3)
#print('out shape', out.shape)
score = score.mean(dim=2)
out = out.reshape(seq_len, bsz, self.n_blocks * self.head_dim * self.n_heads)
out = self.final(out)
out = out.view(seq_len, bsz, self.dim)
return out, score
class NormLayer(nn.Module):
def __init__(self, num_rims, dim, export=False):
super(NormLayer, self).__init__()
self.num_rims = num_rims
self.dim = dim
self.weight = nn.Parameter(torch.ones(1,1,dim*num_rims,))
self.bias = nn.Parameter(torch.zeros(1,1,dim*num_rims,))
self.norm = LayerNorm(dim, export=export, elementwise_affine=False)
def forward(self, x):
seq_len, bsz, _ = x.shape
x = x.view(seq_len, bsz, self.num_rims, self.dim)
x = self.norm(x)
x = x.view(seq_len, bsz, self.num_rims * self.dim)
weight_use = self.weight.repeat(seq_len, bsz, 1)
bias_use = self.bias.repeat(seq_len, bsz, 1)
x = x * weight_use + bias_use
return x
class TransformerEncoderLayer(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, nb, blockatt, blockatt_memory, use_nfm, out_proj_dim=None):
super().__init__()
self.blockatt = blockatt
self.blockatt_memory = blockatt_memory
self.embed_dim = args.encoder_embed_dim
|
# 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(
embed_dim,
args.encoder_attention_heads,
dropout=args.attention_dropout,
self_attention=args.self_attention,
shared_memory_attention = args.shared_memory_attention,
use_topk = args.use_topk,
topk = args.topk,
num_steps = args.num_steps,
mem_slots = args.mem_slots,
null_attention = args.null_attention,
regressive = args.regressive
)
def upgrade_state_dict_named(self, state_dict, name):
"""
Rename layer norm states from `...layer_norms.0.weight` to
`...self_attn_layer_norm.weight` and `...layer_norms.1.weight` to
`...final_layer_norm.weight`
"""
layer_norm_map = {"0": "self_attn_layer_norm", "1": "final_layer_norm"}
for old, new in layer_norm_map.items():
for m in ("weight", "bias"):
k = "{}.layer_norms.{}.{}".format(name, old, m)
if k in state_dict:
state_dict["{}.{}.{}".format(name, new, m)] = state_dict[k]
del state_dict[k]
def forward(self, x, encoder_padding_mask, attn_mask: Optional[Tensor] = None, state = None, memory = None):
"""
Args:
x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)`
encoder_padding_mask (ByteTensor): binary ByteTensor of shape
`(batch, src_len)` where padding elements are indicated by ``1``.
attn_mask (ByteTensor): binary tensor of shape (T_tgt, T_src), where
T_tgt is the length of query, while T_src is the length of key,
though here both query and key is x here,
attn_mask[t_tgt, t_src] = 1 means when calculating embedding
for t_tgt, t_src is excluded (or masked out), =0 means it is
included in attention
Returns:
encoded output of shape `(seq_len, batch, embed_dim)`
"""
residual = x
if self.normalize_before:
x = self.self_attn_layer_norm(x)
if attn_mask is not None:
attn_mask = attn_mask.masked_fill(attn_mask.to(torch.bool), -1e8)
# anything in original attn_mask = 1, becomes -1e8
# anything in original attn_mask = 0, becomes 0
# Note that we cannot use -inf here, because at some edge cases,
# the attention weight (before softmax) for some padded element in query
# will become -inf, which results in NaN in model parameters
# TODO: to formally solve this problem, we need to change fairseq's
# MultiheadAttention. We will do this later on.
#print(state is not None)
x, memory, _ = self.self_attn(
query=state if state is not None else x,
key=x,
value=x,
key_padding_mask=encoder_padding_mask,
attn_mask=attn_mask,
memory = memory
)
x = F.dropout(x, p=self.dropout, training=self.training)
x = residual + x
if not self.normalize_before:
x = self.self_attn_layer_norm(x)
residual = x
if self.normalize_before:
x = self.final_layer_norm(x)
x = self.activation_fn(self.fc1(x))
x = F.dropout(x, p=float(self.activation_dropout), training=self.training)
x = self.fc2(x)
x = F.dropout(x, p=self.dropout, training=self.training)
x = residual + x
if not self.normalize_before:
x = self.final_layer_norm(x)
if self.final_linear is not None:
x = self.final_linear(x)
return x, memory
class Attention(nn.Module):
def __init__(self, n_heads, n_blocks, dim, use_nfm):
super(Attention, self).__init__()
self.use_nfm = use_nfm
#self.n_heads = n_heads
self.n_heads = 12
self.n_blocks = n_blocks
self.dim = dim
self.block_dim = dim // self.n_blocks
#self.head_dim = self.block_dim // self.n_heads
self.head_dim = 64
self.scale = self.head_dim ** -0.5
self.query_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)
self.key_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)
self.value_net = GroupLinearLayer(self.block_dim, self.head_dim * self.n_heads, n_blocks)
self.final = GroupLinearLayer(self.head_dim * self.n_heads, self.block_dim, n_blocks)
def forward(self, x, qkv=None):
use_exshare = False
if qkv is not None:
klst, vlst = qkv
seq_len, bsz, _ = x.shape
if use_exshare:
x = x.view(seq_len, bsz, self.n_blocks * self.block_dim)
q = self.query_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)
k = self.key_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)
v = self.value_net(x).view(seq_len, 1, bsz*self.n_blocks, self.n_heads, self.head_dim)
else:
x = x.view(seq_len, bsz, self.n_blocks * self.block_dim)
q = self.query_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)
k = self.key_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)
v = self.value_net(x).view(seq_len, bsz, self.n_blocks, self.n_heads, self.head_dim)
q = q.transpose(2,3) * self.scale
k = k.transpose(2,3)
v = v.transpose(2,3)
if random.uniform(0,1) < 0.00001:
print('use NFM?', self.use_nfm)
if self.use_nfm:
if qkv is not None:
klst.append(k)
vlst.append(v)
#print('len qlst', len(qlst))
#for kval in klst:
# print(kval.shape)
k = torch.cat(klst, dim=3)
v = torch.cat(vlst, dim=3)
#should return these q,k,v and save to a big list. Also pull in from the list passed in and concat along dim=3, i.e. so that it's nblocks * nlayers.
#print('running comm attention with shapes', q.shape, k.shape, v.shape)
score = torch.matmul(q, k.transpose(3,4))
#print('score shape', score.shape)
score = F.softmax(score, dim=-1)
out = torch.matmul(score, v).transpose(2,3)
#print('out shape', out.shape)
score = score.mean(dim=2)
out = out.reshape(seq_len, bsz, self.n_blocks * self.head_dim * self.n_heads)
out = self.final(out)
out = out.view(seq_len, bsz, self.dim)
return out, score
class NormLayer(nn.Module):
def __init__(self, num_rims, dim, export=False):
super(NormLayer, self).__init__()
self.num_rims = num_rims
self.dim = dim
self.weight = nn.Parameter(torch.ones(1,1,dim*num_rims,))
self.bias = nn.Parameter(torch.zeros(1,1,dim*num_rims,))
self.norm = LayerNorm(dim, export=export, elementwise_affine=False)
def forward(self, x):
seq_len, bsz, _ = x.shape
x = x.view(seq_len, bsz, self.num_rims, self.dim)
x = self.norm(x)
x = x.view(seq_len, bsz, self.num_rims * self.dim)
weight_use = self.weight.repeat(seq_len, bsz, 1)
bias_use = self.bias.repeat(seq_len, bsz, 1)
x = x * weight_use + bias_use
return x
class TransformerEncoderLayer(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, nb, blockatt, blockatt_memory, use_nfm, out_proj_dim=None):
super().__init__()
self.blockatt = blockatt
self.blockatt_memory = blockatt_memory
self.embed_dim = args.encoder_embed_dim | self.quant_noise = getattr(args, "quant_noise_pq", 0) | 5 | 2023-12-15 13:13:01+00:00 | 24k |
m-abr/FCPCodebase | scripts/utils/Localization.py | [
{
"identifier": "Agent",
"path": "agent/Agent.py",
"snippet": "class Agent(Base_Agent):\n def __init__(self, host:str, agent_port:int, monitor_port:int, unum:int,\n team_name:str, enable_log, enable_draw, wait_for_server=True, is_fat_proxy=False) -> None:\n \n # define r... | from agent.Agent import Agent as Agent
from cpp.localization import localization
from math_ops.Math_Ops import Math_Ops as M
from scripts.commons.Script import Script
from world.commons.Draw import Draw
from world.commons.Other_Robot import Other_Robot | 16,305 |
class Localization():
def __init__(self,script:Script) -> None:
self.script = script
def execute(self):
a = self.script.args
d = self.draw = Draw(True, 0, a.i, 32769) # using independent draw object so that the internal agent drawings can be disabled
# Args: Server IP, Agent Port, Monitor Port, Uniform No., Team name, Enable Log, Enable Draw
self.script.batch_create(Agent, ((a.i,a.p,a.m,1,a.t,False,False),)) # one teammate (dummy goalkeeper without communication)
self.script.batch_create(Agent, ((a.i,a.p,a.m,5,"Opponent",False,False),)) # one opponent
self.script.batch_create(Agent, ((a.i,a.p,a.m,9,a.t,False,False),)) # one main agent (the one who draws its world)
# Beam dummy goalkeeper
self.script.batch_unofficial_beam( ((-14,0,0.5,0),), slice(0,1))
p : Agent = self.script.players[-1] # p identifies the main agent
p.scom.unofficial_set_play_mode("PlayOn")
# Execute
while True:
self.script.batch_commit_and_send(slice(0,1)) # dummy agent does not think
self.script.batch_execute_agent(slice(1,None)) # execute normal agents
self.script.batch_receive(slice(0,1), False) # receive & don't update dummy's world state (to save cpu resources)
self.script.batch_receive(slice(1,None)) # receive & update world state
if p.world.vision_is_up_to_date:
if p.world.robot.loc_is_up_to_date: # localization will draw the world of the last agent to be executed
localization.print_python_data() # print data received by the localization module
localization.draw_visible_elements(not p.world.team_side_is_left) # draw visible elements
localization.print_report() # print report with stats
print("\nPress ctrl+c to return.")
d.circle( p.world.ball_abs_pos, 0.1,6,Draw.Color.purple_magenta,"world", False)
else:
d.annotation( p.world.robot.cheat_abs_pos, "Not enough visual data!", Draw.Color.red,"world", False)
for o in p.world.teammates:
if o.state_last_update != 0 and not o.is_self: # skip if other robot was not yet seen
self._draw_other_robot(p, o, Draw.Color.white)
for o in p.world.opponents:
if o.state_last_update != 0: # skip if other robot was not yet seen
self._draw_other_robot(p, o, Draw.Color.red)
d.flush("world")
def _draw_other_robot(self, p:Agent, o:Other_Robot, team_color):
#p - player that sees
#o - other robot (player that is seen)
d = self.draw
white = Draw.Color.white
green = Draw.Color.green_light
gray = Draw.Color.gray_20
time_diff = p.world.time_local_ms - o.state_last_update
if time_diff > 0:
white = Draw.Color.gray_40
green = Draw.Color.get(107, 139, 107)
gray = Draw.Color.gray_50
#orientation
if len(o.state_abs_pos)==3:
|
class Localization():
def __init__(self,script:Script) -> None:
self.script = script
def execute(self):
a = self.script.args
d = self.draw = Draw(True, 0, a.i, 32769) # using independent draw object so that the internal agent drawings can be disabled
# Args: Server IP, Agent Port, Monitor Port, Uniform No., Team name, Enable Log, Enable Draw
self.script.batch_create(Agent, ((a.i,a.p,a.m,1,a.t,False,False),)) # one teammate (dummy goalkeeper without communication)
self.script.batch_create(Agent, ((a.i,a.p,a.m,5,"Opponent",False,False),)) # one opponent
self.script.batch_create(Agent, ((a.i,a.p,a.m,9,a.t,False,False),)) # one main agent (the one who draws its world)
# Beam dummy goalkeeper
self.script.batch_unofficial_beam( ((-14,0,0.5,0),), slice(0,1))
p : Agent = self.script.players[-1] # p identifies the main agent
p.scom.unofficial_set_play_mode("PlayOn")
# Execute
while True:
self.script.batch_commit_and_send(slice(0,1)) # dummy agent does not think
self.script.batch_execute_agent(slice(1,None)) # execute normal agents
self.script.batch_receive(slice(0,1), False) # receive & don't update dummy's world state (to save cpu resources)
self.script.batch_receive(slice(1,None)) # receive & update world state
if p.world.vision_is_up_to_date:
if p.world.robot.loc_is_up_to_date: # localization will draw the world of the last agent to be executed
localization.print_python_data() # print data received by the localization module
localization.draw_visible_elements(not p.world.team_side_is_left) # draw visible elements
localization.print_report() # print report with stats
print("\nPress ctrl+c to return.")
d.circle( p.world.ball_abs_pos, 0.1,6,Draw.Color.purple_magenta,"world", False)
else:
d.annotation( p.world.robot.cheat_abs_pos, "Not enough visual data!", Draw.Color.red,"world", False)
for o in p.world.teammates:
if o.state_last_update != 0 and not o.is_self: # skip if other robot was not yet seen
self._draw_other_robot(p, o, Draw.Color.white)
for o in p.world.opponents:
if o.state_last_update != 0: # skip if other robot was not yet seen
self._draw_other_robot(p, o, Draw.Color.red)
d.flush("world")
def _draw_other_robot(self, p:Agent, o:Other_Robot, team_color):
#p - player that sees
#o - other robot (player that is seen)
d = self.draw
white = Draw.Color.white
green = Draw.Color.green_light
gray = Draw.Color.gray_20
time_diff = p.world.time_local_ms - o.state_last_update
if time_diff > 0:
white = Draw.Color.gray_40
green = Draw.Color.get(107, 139, 107)
gray = Draw.Color.gray_50
#orientation
if len(o.state_abs_pos)==3: | line_tip = o.state_abs_pos + (0.5*M.deg_cos(o.state_orientation),0.5*M.deg_sin(o.state_orientation),0) | 0 | 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 | 19,440 | indices = (im * (self.lattice.size(0) - 1)).clamp(0, self.lattice.size(0) - 1)
im_out = trilinear_interpolation(self.lattice, indices)
return im_out
@classmethod
def get_linear(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:
"""
Returns linear LUT. Has no effect: when applied, output matches input ([0, 1] range).
:param size: Size of the LUT.
:param lut_format: Format of the LUT.
"""
if lut_format == LUTFormat.CUBE_3D:
assert cls.__min_size <= size <= cls.__max_size, f"LUT size must be between {cls.__min_size} and {cls.__max_size}"
variant = LUTFormat.CUBE_3D
lattice = _generate_linear_cube_lut(size)
else:
raise Exception(f"Backpropagation not implemented for: {lut_format.name}")
return cls(size, lattice, variant)
@classmethod
def get_negative(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:
"""
Returns negative LUT. Output is inverted ([0, 1] range).
:param size: Size of the LUT.
:param lut_format: Format of the LUT.
"""
lut = cls.get_linear(size, lut_format)
lut.lattice = 1. - lut.lattice
return lut
@classmethod
def get_random(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:
"""
Returns random LUT. Everything mapped to random values ([0, 1] range).
:param size: Size of the LUT.
:param lut_format: Format of the LUT.
"""
lut = cls.get_linear(size, lut_format)
lut.lattice = torch.randn_like(lut.lattice)
return lut
@classmethod
def get_empty(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:
"""
Returns empty LUT. All values mapped to 0.
:param size: Size of the LUT.
:param lut_format: Format of the LUT.
"""
lut = cls.get_linear(size, lut_format)
lut.lattice = lut.lattice * 0.
return lut
def fit_to_image(self,
im_source:Union[torch.Tensor, ColorImage],
im_target:Union[torch.Tensor, ColorImage],
steps:int=500,
learning_rate:float=0.003,
strength:float=1.,
fit_height:int=512,
fit_width:int=512,
device:str='cuda',
context:callable=None
) -> bool:
"""
Perform gradient descent on the lattice, so that the appearance of the source image matches the target.
:param im_source: Source image tensor. Values must be in range [0, 1].
:type im_source: torch.Tensor | ColorImage
:param im_target: Target image tensor.
:type im_target: torch.Tensor | ColorImage
:param steps: Number of optimization steps.
:param learning_rate: Learning rate for gradient descent.
:param strength: Strength of the effect in range [0, 1].
:param fit_height: Image tensors will be interpolated to this height for evaluation.
:param fit_width: Image tensors will be interpolated to this width for evaluation.
:param device: Device for gradient descent (if None will use input tensor device).
:return: True when completed
"""
assert 0. <= strength <= 1., "strength must be in range [0, 1]"
im_source = im_source.clone()
device = torch.device(device.strip().lower()) if device is not None else im_source.device
im_source = F.interpolate(
im_source.unsqueeze(0),
size=[fit_height, fit_width],
mode='bicubic',
align_corners=False).squeeze(0).clamp(0.,1.).to(device)
im_target = F.interpolate(
im_target.unsqueeze(0),
size=[fit_height, fit_width],
mode='bicubic',
align_corners=False).squeeze(0).clamp(0.,1.).to(device)
__ctx = context if context is not None and callable(context) else nullcontext
with __ctx() as ctx:
cb_callable = hasattr(ctx, 'update_fit_status') and callable(ctx.update_fit_status)
cb = ctx.update_fit_status if cb_callable else lambda a, b, c, d: None
if self.lut_format == LUTFormat.CUBE_3D:
lut = torch.nn.Parameter(self.lattice)
lut.requires_grad_()
optimizer = optim.Adam([lut], lr=learning_rate)
indices = (im_source * (lut.size(0) - 1)).clamp(0, lut.size(0) - 1).to(device)
area = fit_height * fit_height
fm_mean_scale = area
fm_p2_scale = area / 32.
fm_p3_scale = area / 64.
selfsim_scale = area
sat_scale = area # lut optimization goes a bit wild with this
for step in range(steps):
t_source = trilinear_interpolation(lut.to(device), indices).to(device)
loss = 0.
# Main feature loss
| 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
__min_size, __max_size = 4, 512
def __init__(self, size:int, lattice:torch.Tensor=None, lut_format:LUTFormat=LUTFormat.CUBE_3D):
assert self.__min_size <= size <= self.__max_size, f"LUT size must be between {self.__min_size} and {self.__max_size}"
self.size == size
self.lattice = lattice if lattice is not None else _generate_linear_cube_lut(size)
self.lut_format = lut_format
@classmethod
def load(cls, fp:str, lut_format:LUTFormat=LUTFormat.UNKNOWN) -> LookupTable:
"""
Load LUT from file.
:param fp: File path.
:param lut_format: Format of the LUT.
"""
fp = os.path.realpath(fp)
fn, fnext = os.path.splitext(fp)
variant = lut_format if lut_format > LUTFormat.UNKNOWN else _infer_lut_file_format(fnext)
assert variant > LUTFormat.UNKNOWN, "Unrecognized LUT format"
lattice = load_lut(fp, variant)
return cls(lattice.size(0), lattice, variant)
def save(self, fp:str, lut_format:LUTFormat=LUTFormat.UNKNOWN):
"""
Save LUT to file.
.. warning::
This will overwrite existing files.
:param fp: File path.
:param lut_format: Format of the LUT.
"""
fp = os.path.realpath(fp)
fn, fnext = os.path.splitext(fp)
variant = lut_format if lut_format > LUTFormat.UNKNOWN else _infer_lut_file_format(fnext) or self.variant
assert variant > LUTFormat.UNKNOWN, "Unrecognized LUT format"
lattice = save_lut(self.lattice, fp, variant)
return True
def apply(self, im:Union[torch.Tensor, ColorImage]) -> torch.Tensor:
"""
Apply LUT to image tensor.
:param im: Input image tensor
:type im: torch.Tensor | ColorImage
:return: Image tensor with LUT applied
"""
assert self.lut_format > LUTFormat.UNKNOWN and self.lattice != None, "No LUT has been loaded"
assert im.size(0) == 3, "Image should have three color channels (RGB)"
assert self.lattice.size(-1) == 3, "Cube LUT should have three color channels"
indices = (im * (self.lattice.size(0) - 1)).clamp(0, self.lattice.size(0) - 1)
im_out = trilinear_interpolation(self.lattice, indices)
return im_out
@classmethod
def get_linear(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:
"""
Returns linear LUT. Has no effect: when applied, output matches input ([0, 1] range).
:param size: Size of the LUT.
:param lut_format: Format of the LUT.
"""
if lut_format == LUTFormat.CUBE_3D:
assert cls.__min_size <= size <= cls.__max_size, f"LUT size must be between {cls.__min_size} and {cls.__max_size}"
variant = LUTFormat.CUBE_3D
lattice = _generate_linear_cube_lut(size)
else:
raise Exception(f"Backpropagation not implemented for: {lut_format.name}")
return cls(size, lattice, variant)
@classmethod
def get_negative(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:
"""
Returns negative LUT. Output is inverted ([0, 1] range).
:param size: Size of the LUT.
:param lut_format: Format of the LUT.
"""
lut = cls.get_linear(size, lut_format)
lut.lattice = 1. - lut.lattice
return lut
@classmethod
def get_random(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:
"""
Returns random LUT. Everything mapped to random values ([0, 1] range).
:param size: Size of the LUT.
:param lut_format: Format of the LUT.
"""
lut = cls.get_linear(size, lut_format)
lut.lattice = torch.randn_like(lut.lattice)
return lut
@classmethod
def get_empty(cls, size:int=32, lut_format:LUTFormat=LUTFormat.CUBE_3D) -> LookupTable:
"""
Returns empty LUT. All values mapped to 0.
:param size: Size of the LUT.
:param lut_format: Format of the LUT.
"""
lut = cls.get_linear(size, lut_format)
lut.lattice = lut.lattice * 0.
return lut
def fit_to_image(self,
im_source:Union[torch.Tensor, ColorImage],
im_target:Union[torch.Tensor, ColorImage],
steps:int=500,
learning_rate:float=0.003,
strength:float=1.,
fit_height:int=512,
fit_width:int=512,
device:str='cuda',
context:callable=None
) -> bool:
"""
Perform gradient descent on the lattice, so that the appearance of the source image matches the target.
:param im_source: Source image tensor. Values must be in range [0, 1].
:type im_source: torch.Tensor | ColorImage
:param im_target: Target image tensor.
:type im_target: torch.Tensor | ColorImage
:param steps: Number of optimization steps.
:param learning_rate: Learning rate for gradient descent.
:param strength: Strength of the effect in range [0, 1].
:param fit_height: Image tensors will be interpolated to this height for evaluation.
:param fit_width: Image tensors will be interpolated to this width for evaluation.
:param device: Device for gradient descent (if None will use input tensor device).
:return: True when completed
"""
assert 0. <= strength <= 1., "strength must be in range [0, 1]"
im_source = im_source.clone()
device = torch.device(device.strip().lower()) if device is not None else im_source.device
im_source = F.interpolate(
im_source.unsqueeze(0),
size=[fit_height, fit_width],
mode='bicubic',
align_corners=False).squeeze(0).clamp(0.,1.).to(device)
im_target = F.interpolate(
im_target.unsqueeze(0),
size=[fit_height, fit_width],
mode='bicubic',
align_corners=False).squeeze(0).clamp(0.,1.).to(device)
__ctx = context if context is not None and callable(context) else nullcontext
with __ctx() as ctx:
cb_callable = hasattr(ctx, 'update_fit_status') and callable(ctx.update_fit_status)
cb = ctx.update_fit_status if cb_callable else lambda a, b, c, d: None
if self.lut_format == LUTFormat.CUBE_3D:
lut = torch.nn.Parameter(self.lattice)
lut.requires_grad_()
optimizer = optim.Adam([lut], lr=learning_rate)
indices = (im_source * (lut.size(0) - 1)).clamp(0, lut.size(0) - 1).to(device)
area = fit_height * fit_height
fm_mean_scale = area
fm_p2_scale = area / 32.
fm_p3_scale = area / 64.
selfsim_scale = area
sat_scale = area # lut optimization goes a bit wild with this
for step in range(steps):
t_source = trilinear_interpolation(lut.to(device), indices).to(device)
loss = 0.
# Main feature loss | feat_source_mean, feat_source_p2, feat_source_p3 = feature_moments_calculation(t_source.view(1,3,-1)) | 8 | 2023-12-15 15:39:08+00:00 | 24k |
Azure-Samples/functions-python-web-crawler | .venv/Lib/site-packages/urllib3/connectionpool.py | [
{
"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": "HTTPHeaderDict",
"path": ".venv/Lib/site-packages/urllib3/_collections.py",
"... | 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 import Literal
from ._base_connection import BaseHTTPConnection, BaseHTTPSConnection | 20,866 | 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}
| 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): | 2 | 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,678 |
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:
| # -*- 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) | 5 | 2023-10-25 02:50:01+00:00 | 24k |
EulerSearch/embedding_studio | embedding_studio/embeddings/training/embeddings_finetuner.py | [
{
"identifier": "QueryRetriever",
"path": "embedding_studio/embeddings/data/clickstream/query_retriever.py",
"snippet": "class QueryRetriever(object):\n \"\"\"As we can't exactly predict a schema of storing queries:\n 1. As text exceptly in clickstream service\n 2. As ID of a record with a text... | import logging
import numpy as np
import pytorch_lightning as pl
import torch
from collections import defaultdict
from typing import Callable, List, Optional, Tuple, Union
from datasets import DatasetDict
from torch import FloatTensor, Tensor
from torch.optim import SGD, Optimizer
from torch.optim.lr_scheduler import LRScheduler, StepLR
from embedding_studio.embeddings.data.clickstream.query_retriever import (
QueryRetriever,
)
from embedding_studio.embeddings.data.clickstream.raw_session import (
ClickstreamSession,
)
from embedding_studio.embeddings.features.event_confidences import (
dummy_confidences,
)
from embedding_studio.embeddings.features.extractor import (
COSINE_SIMILARITY,
FeaturesExtractor,
)
from embedding_studio.embeddings.features.session_features import (
SessionFeatures,
)
from embedding_studio.embeddings.losses.ranking_loss_interface import (
RankingLossInterface,
)
from embedding_studio.embeddings.metrics.distance_shift import DistanceShift
from embedding_studio.embeddings.metrics.metric import MetricCalculator
from embedding_studio.embeddings.models.interface import (
EmbeddingsModelInterface,
)
from embedding_studio.workers.fine_tuning.experiments.experiments_tracker import (
ExperimentsManager,
)
from embedding_studio.workers.fine_tuning.experiments.finetuning_params import (
FineTuningParams,
)
from embedding_studio.workers.fine_tuning.experiments.finetuning_settings import (
FineTuningSettings,
)
from embedding_studio.workers.fine_tuning.experiments.metrics_accumulator import (
MetricValue,
) | 16,773 | if not isinstance(fine_tuning_params, FineTuningParams):
raise TypeError(
"fine_tuning_params must be an instance of FineTuningParams"
)
if not isinstance(tracker, ExperimentsManager):
raise TypeError(
"tracker must be an instance of ExperimentsManager"
)
if not isinstance(fine_tuning_params, FineTuningParams):
raise TypeError(
"fine_tuning_params must be an instance of FineTuningParams"
)
super(EmbeddingsFineTuner, self).__init__()
self.features_extractor = FeaturesExtractor(
model,
ranker,
is_similarity,
fine_tuning_params.not_irrelevant_only,
fine_tuning_params.negative_downsampling,
fine_tuning_params.min_abs_difference_threshold,
fine_tuning_params.max_abs_difference_threshold,
confidence_calculator,
)
self.items_storages = items_storages
self.query_retriever = query_retriever
if not metric_calculators:
logger.debug(
"metric_calculators list is empty - DistanceShift metric will be used by default."
)
self.calculators = (
metric_calculators
if metric_calculators is not None
else [DistanceShift()]
)
self.loss_func = loss_func
self.loss_func.set_margin(fine_tuning_params.margin)
self.fine_tuning_params = fine_tuning_params
self.tracker = tracker
self.step_size = step_size
self.gamma = gamma
self._validation_metrics = defaultdict(list)
# Fix layers
self.features_extractor.model.fix_item_model(
fine_tuning_params.num_fixed_layers
)
self.features_extractor.model.fix_query_model(
fine_tuning_params.num_fixed_layers
)
self.automatic_optimization = False
def preprocess_sessions(self, clickstream_dataset: DatasetDict):
for key in clickstream_dataset.keys():
item_storage = self.items_storages[key]
logger.info(
f"Calculate ranks for {key} not irrelevant clickstream sessions"
)
for session in clickstream_dataset[key].not_irrelevant:
unique_values = set(session.ranks.values())
if len(unique_values) == 0 or None in unique_values:
session.ranks = self.features_extractor.calculate_ranks(
session, item_storage, self.query_retriever
)
logger.info(
f"Calculate ranks for {key} irrelevant clickstream sessions"
)
for session in clickstream_dataset[key].irrelevant:
unique_values = set(session.ranks.values())
if len(unique_values) == 0 or None in unique_values:
session.ranks = self.features_extractor.calculate_ranks(
session, item_storage, self.query_retriever
)
# Standart LightningModule methods to be overrided to be used in PytorchLightning Trainer
# 1. Configure optimizers and schedulers
def configure_optimizers(
self,
) -> Tuple[List[Optimizer], List[LRScheduler]]:
if not (isinstance(self.step_size, int) and self.step_size > 0):
raise ValueError("step_size must be a positive integer")
if not (isinstance(self.gamma, float) and 0 < self.gamma < 1):
raise ValueError("gamma must be a float in the range (0, 1)")
items_optimizer: SGD = SGD(
self.features_extractor.model.get_items_model_params(),
lr=self.fine_tuning_params.items_lr,
weight_decay=self.fine_tuning_params.items_weight_decay,
)
items_scheduler: StepLR = StepLR(
items_optimizer, step_size=self.step_size, gamma=self.gamma
)
if self.features_extractor.model.same_query_and_items:
return [items_optimizer], [items_scheduler]
query_optimizer: SGD = SGD(
self.features_extractor.model.get_query_model_params(),
lr=self.fine_tuning_params.query_lr,
weight_decay=self.fine_tuning_params.query_weight_decay,
)
query_scheduler: StepLR = torch.optim.lr_scheduler.StepLR(
query_optimizer, step_size=self.step_size, gamma=self.gamma
)
return [items_optimizer, query_optimizer], [
items_scheduler,
query_scheduler,
]
# 2. Training step code with one batch
def training_step(
self,
|
logger = logging.getLogger(__name__)
class EmbeddingsFineTuner(pl.LightningModule):
def __init__(
self,
model: EmbeddingsModelInterface,
items_storages: DatasetDict,
query_retriever: QueryRetriever,
loss_func: RankingLossInterface,
fine_tuning_params: FineTuningParams,
tracker: ExperimentsManager,
metric_calculators: Optional[List[MetricCalculator]] = None,
ranker: Callable[
[FloatTensor, FloatTensor], FloatTensor
] = COSINE_SIMILARITY,
is_similarity: bool = True,
confidence_calculator: Callable = dummy_confidences,
step_size: int = 500,
gamma: float = 0.9,
):
"""This is a class, that represents embeddings fine-tuning logic,
designed in the way to be use PytorchLightning Trainer.
:param model: embedding model itself
:param items_storages: items storage related to a given iteration, as a datasetdict with train and test keys
:param query_retriever: object to get item related to query, that can be used in "forward"
:param loss_func: loss object for a ranking task
:param fine_tuning_params: hyper params of fine-tuning task
:param tracker: experiment management object
:param metric_calculators: list of trackable metrics calculators (default: None)
by default_params only DistanceShift metric
:param ranker: ranking function (query, items) -> ranks (defult: cosine similarity)
:param is_similarity: is ranking function similarity like or distance (default: True)
:param confidence_calculator: function to calculate results confidences (default: dummy_confidences)
:param step_size: optimizer steps (default: 500)
:param gamma: optimizers gamma (default: 0.9)
"""
if not isinstance(model, EmbeddingsModelInterface):
raise TypeError(
"model must be an instance of EmbeddingsModelInterface"
)
if not isinstance(items_storages, DatasetDict):
raise TypeError("items_storages must be a DatasetDict")
if not isinstance(query_retriever, QueryRetriever):
raise TypeError(
"query_retriever must be an instance of QueryRetriever"
)
if not isinstance(loss_func, RankingLossInterface):
raise TypeError(
"loss_func must be an instance of RankingLossInterface"
)
if not isinstance(fine_tuning_params, FineTuningParams):
raise TypeError(
"fine_tuning_params must be an instance of FineTuningParams"
)
if not isinstance(tracker, ExperimentsManager):
raise TypeError(
"tracker must be an instance of ExperimentsManager"
)
if not isinstance(fine_tuning_params, FineTuningParams):
raise TypeError(
"fine_tuning_params must be an instance of FineTuningParams"
)
super(EmbeddingsFineTuner, self).__init__()
self.features_extractor = FeaturesExtractor(
model,
ranker,
is_similarity,
fine_tuning_params.not_irrelevant_only,
fine_tuning_params.negative_downsampling,
fine_tuning_params.min_abs_difference_threshold,
fine_tuning_params.max_abs_difference_threshold,
confidence_calculator,
)
self.items_storages = items_storages
self.query_retriever = query_retriever
if not metric_calculators:
logger.debug(
"metric_calculators list is empty - DistanceShift metric will be used by default."
)
self.calculators = (
metric_calculators
if metric_calculators is not None
else [DistanceShift()]
)
self.loss_func = loss_func
self.loss_func.set_margin(fine_tuning_params.margin)
self.fine_tuning_params = fine_tuning_params
self.tracker = tracker
self.step_size = step_size
self.gamma = gamma
self._validation_metrics = defaultdict(list)
# Fix layers
self.features_extractor.model.fix_item_model(
fine_tuning_params.num_fixed_layers
)
self.features_extractor.model.fix_query_model(
fine_tuning_params.num_fixed_layers
)
self.automatic_optimization = False
def preprocess_sessions(self, clickstream_dataset: DatasetDict):
for key in clickstream_dataset.keys():
item_storage = self.items_storages[key]
logger.info(
f"Calculate ranks for {key} not irrelevant clickstream sessions"
)
for session in clickstream_dataset[key].not_irrelevant:
unique_values = set(session.ranks.values())
if len(unique_values) == 0 or None in unique_values:
session.ranks = self.features_extractor.calculate_ranks(
session, item_storage, self.query_retriever
)
logger.info(
f"Calculate ranks for {key} irrelevant clickstream sessions"
)
for session in clickstream_dataset[key].irrelevant:
unique_values = set(session.ranks.values())
if len(unique_values) == 0 or None in unique_values:
session.ranks = self.features_extractor.calculate_ranks(
session, item_storage, self.query_retriever
)
# Standart LightningModule methods to be overrided to be used in PytorchLightning Trainer
# 1. Configure optimizers and schedulers
def configure_optimizers(
self,
) -> Tuple[List[Optimizer], List[LRScheduler]]:
if not (isinstance(self.step_size, int) and self.step_size > 0):
raise ValueError("step_size must be a positive integer")
if not (isinstance(self.gamma, float) and 0 < self.gamma < 1):
raise ValueError("gamma must be a float in the range (0, 1)")
items_optimizer: SGD = SGD(
self.features_extractor.model.get_items_model_params(),
lr=self.fine_tuning_params.items_lr,
weight_decay=self.fine_tuning_params.items_weight_decay,
)
items_scheduler: StepLR = StepLR(
items_optimizer, step_size=self.step_size, gamma=self.gamma
)
if self.features_extractor.model.same_query_and_items:
return [items_optimizer], [items_scheduler]
query_optimizer: SGD = SGD(
self.features_extractor.model.get_query_model_params(),
lr=self.fine_tuning_params.query_lr,
weight_decay=self.fine_tuning_params.query_weight_decay,
)
query_scheduler: StepLR = torch.optim.lr_scheduler.StepLR(
query_optimizer, step_size=self.step_size, gamma=self.gamma
)
return [items_optimizer, query_optimizer], [
items_scheduler,
query_scheduler,
]
# 2. Training step code with one batch
def training_step(
self, | batch: List[Tuple[ClickstreamSession, ClickstreamSession]], | 1 | 2023-10-31 00:33:13+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 | 17,997 | # 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():
| # 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( | 2 | 2023-10-30 20:43:43+00:00 | 24k |
masked-spacetime-hashing/msth | nerfstudio/models/tensorf.py | [
{
"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... | from dataclasses import dataclass, field
from typing import Dict, List, Tuple, Type
from torch.nn import Parameter
from torchmetrics import PeakSignalNoiseRatio
from torchmetrics.functional import structural_similarity_index_measure
from torchmetrics.image.lpip import LearnedPerceptualImagePatchSimilarity
from typing_extensions import Literal
from nerfstudio.cameras.rays import RayBundle
from nerfstudio.configs.config_utils import to_immutable_dict
from nerfstudio.engine.callbacks import (
TrainingCallback,
TrainingCallbackAttributes,
TrainingCallbackLocation,
)
from nerfstudio.field_components.encodings import (
NeRFEncoding,
TensorCPEncoding,
TensorVMEncoding,
TriplaneEncoding,
)
from nerfstudio.field_components.field_heads import FieldHeadNames
from nerfstudio.fields.tensorf_field import TensoRFField
from nerfstudio.model_components.losses import MSELoss
from nerfstudio.model_components.ray_samplers import PDFSampler, UniformSampler
from nerfstudio.model_components.renderers import (
AccumulationRenderer,
DepthRenderer,
RGBRenderer,
)
from nerfstudio.model_components.scene_colliders import AABBBoxCollider
from nerfstudio.models.base_model import Model, ModelConfig
from nerfstudio.utils import colormaps, colors, misc
import numpy as np
import torch | 15,552 | np.exp(
np.linspace(
np.log(config.init_resolution),
np.log(config.final_resolution),
len(config.upsampling_iters) + 1,
)
)
)
.astype("int")
.tolist()[1:]
)
super().__init__(config=config, **kwargs)
def get_training_callbacks(
self, training_callback_attributes: TrainingCallbackAttributes
) -> List[TrainingCallback]:
# the callback that we want to run every X iterations after the training iteration
def reinitialize_optimizer(
self, training_callback_attributes: TrainingCallbackAttributes, step: int # pylint: disable=unused-argument
):
index = self.upsampling_iters.index(step)
resolution = self.upsampling_steps[index]
# upsample the position and direction grids
self.field.density_encoding.upsample_grid(resolution)
self.field.color_encoding.upsample_grid(resolution)
# reinitialize the encodings optimizer
optimizers_config = training_callback_attributes.optimizers.config
enc = training_callback_attributes.pipeline.get_param_groups()["encodings"]
lr_init = optimizers_config["encodings"]["optimizer"].lr
training_callback_attributes.optimizers.optimizers["encodings"] = optimizers_config["encodings"][
"optimizer"
].setup(params=enc)
if optimizers_config["encodings"]["scheduler"]:
training_callback_attributes.optimizers.schedulers["encodings"] = (
optimizers_config["encodings"]["scheduler"]
.setup()
.get_scheduler(
optimizer=training_callback_attributes.optimizers.optimizers["encodings"], lr_init=lr_init
)
)
callbacks = [
TrainingCallback(
where_to_run=[TrainingCallbackLocation.AFTER_TRAIN_ITERATION],
iters=self.upsampling_iters,
func=reinitialize_optimizer,
args=[self, training_callback_attributes],
)
]
return callbacks
def update_to_step(self, step: int) -> None:
if step < self.upsampling_iters[0]:
return
new_iters = list(self.upsampling_iters) + [step + 1]
new_iters.sort()
index = new_iters.index(step + 1)
new_grid_resolution = self.upsampling_steps[index - 1]
self.field.density_encoding.upsample_grid(new_grid_resolution) # type: ignore
self.field.color_encoding.upsample_grid(new_grid_resolution) # type: ignore
def populate_modules(self):
"""Set the fields and modules"""
super().populate_modules()
# setting up fields
if self.config.tensorf_encoding == "vm":
density_encoding = TensorVMEncoding(
resolution=self.init_resolution,
num_components=self.num_den_components,
)
color_encoding = TensorVMEncoding(
resolution=self.init_resolution,
num_components=self.num_color_components,
)
elif self.config.tensorf_encoding == "cp":
density_encoding = TensorCPEncoding(
resolution=self.init_resolution,
num_components=self.num_den_components,
)
color_encoding = TensorCPEncoding(
resolution=self.init_resolution,
num_components=self.num_color_components,
)
elif self.config.tensorf_encoding == "triplane":
density_encoding = TriplaneEncoding(
resolution=self.init_resolution,
num_components=self.num_den_components,
)
color_encoding = TriplaneEncoding(
resolution=self.init_resolution,
num_components=self.num_color_components,
)
else:
raise ValueError(f"Encoding {self.config.tensorf_encoding} not supported")
feature_encoding = NeRFEncoding(in_dim=self.appearance_dim, num_frequencies=2, min_freq_exp=0, max_freq_exp=2)
direction_encoding = NeRFEncoding(in_dim=3, num_frequencies=2, min_freq_exp=0, max_freq_exp=2)
self.field = TensoRFField(
self.scene_box.aabb,
feature_encoding=feature_encoding,
direction_encoding=direction_encoding,
density_encoding=density_encoding,
color_encoding=color_encoding,
appearance_dim=self.appearance_dim,
head_mlp_num_layers=2,
head_mlp_layer_width=128,
use_sh=False,
)
# samplers
self.sampler_uniform = UniformSampler(num_samples=self.config.num_samples, single_jitter=True)
| # 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.
"""
TensorRF implementation.
"""
from __future__ import annotations
@dataclass
class TensoRFModelConfig(ModelConfig):
"""TensoRF model config"""
_target: Type = field(default_factory=lambda: TensoRFModel)
"""target class to instantiate"""
init_resolution: int = 128
"""initial render resolution"""
final_resolution: int = 300
"""final render resolution"""
upsampling_iters: Tuple[int, ...] = (2000, 3000, 4000, 5500, 7000)
"""specifies a list of iteration step numbers to perform upsampling"""
loss_coefficients: Dict[str, float] = to_immutable_dict({"rgb_loss": 1.0})
"""Loss specific weights."""
num_samples: int = 256
"""Number of samples in field evaluation"""
num_den_components: int = 16
"""Number of components in density encoding"""
num_color_components: int = 48
"""Number of components in color encoding"""
appearance_dim: int = 27
"""Number of channels for color encoding"""
tensorf_encoding: Literal["triplane", "vm", "cp"] = "vm"
class TensoRFModel(Model):
"""TensoRF Model
Args:
config: TensoRF configuration to instantiate model
"""
def __init__(
self,
config: TensoRFModelConfig,
**kwargs,
) -> None:
self.init_resolution = config.init_resolution
self.upsampling_iters = config.upsampling_iters
self.num_den_components = config.num_den_components
self.num_color_components = config.num_color_components
self.appearance_dim = config.appearance_dim
self.upsampling_steps = (
np.round(
np.exp(
np.linspace(
np.log(config.init_resolution),
np.log(config.final_resolution),
len(config.upsampling_iters) + 1,
)
)
)
.astype("int")
.tolist()[1:]
)
super().__init__(config=config, **kwargs)
def get_training_callbacks(
self, training_callback_attributes: TrainingCallbackAttributes
) -> List[TrainingCallback]:
# the callback that we want to run every X iterations after the training iteration
def reinitialize_optimizer(
self, training_callback_attributes: TrainingCallbackAttributes, step: int # pylint: disable=unused-argument
):
index = self.upsampling_iters.index(step)
resolution = self.upsampling_steps[index]
# upsample the position and direction grids
self.field.density_encoding.upsample_grid(resolution)
self.field.color_encoding.upsample_grid(resolution)
# reinitialize the encodings optimizer
optimizers_config = training_callback_attributes.optimizers.config
enc = training_callback_attributes.pipeline.get_param_groups()["encodings"]
lr_init = optimizers_config["encodings"]["optimizer"].lr
training_callback_attributes.optimizers.optimizers["encodings"] = optimizers_config["encodings"][
"optimizer"
].setup(params=enc)
if optimizers_config["encodings"]["scheduler"]:
training_callback_attributes.optimizers.schedulers["encodings"] = (
optimizers_config["encodings"]["scheduler"]
.setup()
.get_scheduler(
optimizer=training_callback_attributes.optimizers.optimizers["encodings"], lr_init=lr_init
)
)
callbacks = [
TrainingCallback(
where_to_run=[TrainingCallbackLocation.AFTER_TRAIN_ITERATION],
iters=self.upsampling_iters,
func=reinitialize_optimizer,
args=[self, training_callback_attributes],
)
]
return callbacks
def update_to_step(self, step: int) -> None:
if step < self.upsampling_iters[0]:
return
new_iters = list(self.upsampling_iters) + [step + 1]
new_iters.sort()
index = new_iters.index(step + 1)
new_grid_resolution = self.upsampling_steps[index - 1]
self.field.density_encoding.upsample_grid(new_grid_resolution) # type: ignore
self.field.color_encoding.upsample_grid(new_grid_resolution) # type: ignore
def populate_modules(self):
"""Set the fields and modules"""
super().populate_modules()
# setting up fields
if self.config.tensorf_encoding == "vm":
density_encoding = TensorVMEncoding(
resolution=self.init_resolution,
num_components=self.num_den_components,
)
color_encoding = TensorVMEncoding(
resolution=self.init_resolution,
num_components=self.num_color_components,
)
elif self.config.tensorf_encoding == "cp":
density_encoding = TensorCPEncoding(
resolution=self.init_resolution,
num_components=self.num_den_components,
)
color_encoding = TensorCPEncoding(
resolution=self.init_resolution,
num_components=self.num_color_components,
)
elif self.config.tensorf_encoding == "triplane":
density_encoding = TriplaneEncoding(
resolution=self.init_resolution,
num_components=self.num_den_components,
)
color_encoding = TriplaneEncoding(
resolution=self.init_resolution,
num_components=self.num_color_components,
)
else:
raise ValueError(f"Encoding {self.config.tensorf_encoding} not supported")
feature_encoding = NeRFEncoding(in_dim=self.appearance_dim, num_frequencies=2, min_freq_exp=0, max_freq_exp=2)
direction_encoding = NeRFEncoding(in_dim=3, num_frequencies=2, min_freq_exp=0, max_freq_exp=2)
self.field = TensoRFField(
self.scene_box.aabb,
feature_encoding=feature_encoding,
direction_encoding=direction_encoding,
density_encoding=density_encoding,
color_encoding=color_encoding,
appearance_dim=self.appearance_dim,
head_mlp_num_layers=2,
head_mlp_layer_width=128,
use_sh=False,
)
# samplers
self.sampler_uniform = UniformSampler(num_samples=self.config.num_samples, single_jitter=True) | self.sampler_pdf = PDFSampler(num_samples=self.config.num_samples // 2, single_jitter=True) | 12 | 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 | 19,488 |
PROCESS_FUNC = {
"QM9": ProcessedQM9,
"DoubleQM9": ProcessedDoubleQM9,
"TripleQM9": ProcessedTripleQM9,
|
PROCESS_FUNC = {
"QM9": ProcessedQM9,
"DoubleQM9": ProcessedDoubleQM9,
"TripleQM9": ProcessedTripleQM9, | "TS1x": ProcessedTS1x, | 3 | 2023-10-30 02:53:38+00:00 | 24k |
nv-tlabs/pacer | pacer/env/tasks/humanoid_amp.py | [
{
"identifier": "MotionLib",
"path": "pacer/utils/motion_lib.py",
"snippet": "class MotionLib():\n def __init__(self, motion_file, dof_body_ids, dof_offsets, key_body_ids,\n device):\n self._dof_body_ids = dof_body_ids\n self._dof_offsets = dof_offsets\n self._num... | from ast import Try
from enum import Enum
from matplotlib.pyplot import flag
from torch import Tensor
from typing import Dict, Optional
from isaacgym import gymapi
from isaacgym import gymtorch
from env.tasks.humanoid import Humanoid, dof_to_obs, remove_base_rot, dof_to_obs_smpl
from env.util import gym_util
from pacer.utils.motion_lib import MotionLib
from pacer.utils.motion_lib_smpl import MotionLib as MotionLibSMPL
from isaacgym.torch_utils import *
from utils import torch_utils
from uhc.smpllib.smpl_parser import (
SMPL_Parser,
SMPLH_Parser,
SMPLX_Parser,
)
from pacer.utils.flags import flags
from poselib.poselib.skeleton.skeleton3d import SkeletonMotion, SkeletonState
from poselib.poselib.visualization.common import plot_skeleton_motion_interactive
import glob
import os
import sys
import pdb
import os.path as osp
import numpy as np
import torch
import gc | 15,851 | # Copyright (c) 2023, 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.
sys.path.append(os.getcwd())
HACK_MOTION_SYNC = False
# HACK_MOTION_SYNC = True
HACK_CONSISTENCY_TEST = False
HACK_OUTPUT_MOTION = False
HACK_OUTPUT_MOTION_ALL = False
class HumanoidAMP(Humanoid):
class StateInit(Enum):
Default = 0
Start = 1
Random = 2
Hybrid = 3
def __init__(self, cfg, sim_params, physics_engine, device_type, device_id,
headless):
# jp hack
if (HACK_MOTION_SYNC or HACK_CONSISTENCY_TEST):
control_freq_inv = cfg["env"]["controlFrequencyInv"]
self._motion_sync_dt = control_freq_inv * sim_params.dt
cfg["env"]["controlFrequencyInv"] = 1
cfg["env"]["pdControl"] = False
state_init = cfg["env"]["stateInit"]
self._state_init = HumanoidAMP.StateInit[state_init]
self._hybrid_init_prob = cfg["env"]["hybridInitProb"]
self._num_amp_obs_steps = cfg["env"]["numAMPObsSteps"]
self._amp_root_height_obs = cfg["env"].get("ampRootHeightObs", False)
assert (self._num_amp_obs_steps >= 2)
if ("enableHistObs" in cfg["env"]):
self._enable_hist_obs = cfg["env"]["enableHistObs"]
else:
self._enable_hist_obs = False
self._reset_default_env_ids = []
self._reset_ref_env_ids = []
self._state_reset_happened = False
super().__init__(cfg=cfg,
sim_params=sim_params,
physics_engine=physics_engine,
device_type=device_type,
device_id=device_id,
headless=headless)
self._motion_start_times = torch.zeros(self.num_envs).to(self.device)
self._sampled_motion_ids = torch.zeros(self.num_envs).long().to(self.device)
motion_file = cfg['env']['motion_file']
self._load_motion(motion_file)
self._amp_obs_buf = torch.zeros(
(self.num_envs, self._num_amp_obs_steps,
self._num_amp_obs_per_step),
device=self.device,
dtype=torch.float)
self._curr_amp_obs_buf = self._amp_obs_buf[:, 0]
self._hist_amp_obs_buf = self._amp_obs_buf[:, 1:]
self._amp_obs_demo_buf = None
data_dir = "data/smpl"
self.smpl_parser_n = SMPL_Parser(model_path=data_dir,
gender="neutral").to(self.device)
self.smpl_parser_m = SMPL_Parser(model_path=data_dir,
gender="male").to(self.device)
self.smpl_parser_f = SMPL_Parser(model_path=data_dir,
gender="female").to(self.device)
self.start = True # camera flag
self.ref_motion_cache = {}
return
def resample_motions(self):
# self.gym.destroy_sim(self.sim)
# del self.sim
# if not self.headless:
# self.gym.destroy_viewer(self.viewer)
# self.create_sim()
# self.gym.prepare_sim(self.sim)
# self.create_viewer()
# self._setup_tensors()
print("Partial solution, only resample motions...")
self._motion_lib.load_motions(skeleton_trees = self.skeleton_trees, limb_weights = self.humanoid_limb_and_weights.cpu(), gender_betas = self.humanoid_betas.cpu()) # For now, only need to sample motions since there are only 400 hmanoids
# self.reset()
# torch.cuda.empty_cache()
# gc.collect()
def pre_physics_step(self, actions):
if (HACK_MOTION_SYNC or HACK_CONSISTENCY_TEST):
actions *= 0
| # Copyright (c) 2023, 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.
sys.path.append(os.getcwd())
HACK_MOTION_SYNC = False
# HACK_MOTION_SYNC = True
HACK_CONSISTENCY_TEST = False
HACK_OUTPUT_MOTION = False
HACK_OUTPUT_MOTION_ALL = False
class HumanoidAMP(Humanoid):
class StateInit(Enum):
Default = 0
Start = 1
Random = 2
Hybrid = 3
def __init__(self, cfg, sim_params, physics_engine, device_type, device_id,
headless):
# jp hack
if (HACK_MOTION_SYNC or HACK_CONSISTENCY_TEST):
control_freq_inv = cfg["env"]["controlFrequencyInv"]
self._motion_sync_dt = control_freq_inv * sim_params.dt
cfg["env"]["controlFrequencyInv"] = 1
cfg["env"]["pdControl"] = False
state_init = cfg["env"]["stateInit"]
self._state_init = HumanoidAMP.StateInit[state_init]
self._hybrid_init_prob = cfg["env"]["hybridInitProb"]
self._num_amp_obs_steps = cfg["env"]["numAMPObsSteps"]
self._amp_root_height_obs = cfg["env"].get("ampRootHeightObs", False)
assert (self._num_amp_obs_steps >= 2)
if ("enableHistObs" in cfg["env"]):
self._enable_hist_obs = cfg["env"]["enableHistObs"]
else:
self._enable_hist_obs = False
self._reset_default_env_ids = []
self._reset_ref_env_ids = []
self._state_reset_happened = False
super().__init__(cfg=cfg,
sim_params=sim_params,
physics_engine=physics_engine,
device_type=device_type,
device_id=device_id,
headless=headless)
self._motion_start_times = torch.zeros(self.num_envs).to(self.device)
self._sampled_motion_ids = torch.zeros(self.num_envs).long().to(self.device)
motion_file = cfg['env']['motion_file']
self._load_motion(motion_file)
self._amp_obs_buf = torch.zeros(
(self.num_envs, self._num_amp_obs_steps,
self._num_amp_obs_per_step),
device=self.device,
dtype=torch.float)
self._curr_amp_obs_buf = self._amp_obs_buf[:, 0]
self._hist_amp_obs_buf = self._amp_obs_buf[:, 1:]
self._amp_obs_demo_buf = None
data_dir = "data/smpl"
self.smpl_parser_n = SMPL_Parser(model_path=data_dir,
gender="neutral").to(self.device)
self.smpl_parser_m = SMPL_Parser(model_path=data_dir,
gender="male").to(self.device)
self.smpl_parser_f = SMPL_Parser(model_path=data_dir,
gender="female").to(self.device)
self.start = True # camera flag
self.ref_motion_cache = {}
return
def resample_motions(self):
# self.gym.destroy_sim(self.sim)
# del self.sim
# if not self.headless:
# self.gym.destroy_viewer(self.viewer)
# self.create_sim()
# self.gym.prepare_sim(self.sim)
# self.create_viewer()
# self._setup_tensors()
print("Partial solution, only resample motions...")
self._motion_lib.load_motions(skeleton_trees = self.skeleton_trees, limb_weights = self.humanoid_limb_and_weights.cpu(), gender_betas = self.humanoid_betas.cpu()) # For now, only need to sample motions since there are only 400 hmanoids
# self.reset()
# torch.cuda.empty_cache()
# gc.collect()
def pre_physics_step(self, actions):
if (HACK_MOTION_SYNC or HACK_CONSISTENCY_TEST):
actions *= 0
| if flags.debug: | 5 | 2023-10-31 20:47:12+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 | 17,931 | def test_gets_loss_and_correct_activations(
self,
full_activation_store: ActivationStore,
autoencoder_model: SparseAutoencoder,
) -> None:
"""Test it gets loss and also returns the input activations."""
resampler = ActivationResampler(
n_components=DEFAULT_N_COMPONENTS,
n_learned_features=DEFAULT_N_LEARNED_FEATURES,
resample_dataset_size=DEFAULT_N_ACTIVATIONS_STORE,
)
loss, input_activations = resampler.compute_loss_and_get_activations(
store=full_activation_store,
autoencoder=autoencoder_model,
loss_fn=L2ReconstructionLoss(),
train_batch_size=DEFAULT_N_ACTIVATIONS_STORE,
)
assert isinstance(loss, Tensor)
assert isinstance(input_activations, Tensor)
# Check that the activations are the same as the input data
assert torch.equal(input_activations, full_activation_store._data) # type: ignore # noqa: SLF001
def test_more_items_than_in_store_error(
self,
full_activation_store: ActivationStore,
autoencoder_model: SparseAutoencoder,
) -> None:
"""Test that an error is raised if there are more items than in the store."""
with pytest.raises(
ValueError,
match=r"Cannot get \d+ items from the store, as only \d+ were available.",
):
ActivationResampler(
resample_dataset_size=DEFAULT_N_ACTIVATIONS_STORE + 1,
n_learned_features=DEFAULT_N_LEARNED_FEATURES,
).compute_loss_and_get_activations(
store=full_activation_store,
autoencoder=autoencoder_model,
loss_fn=L2ReconstructionLoss(),
train_batch_size=DEFAULT_N_ACTIVATIONS_STORE + 1,
)
class TestAssignSamplingProbabilities:
"""Test the assign sampling probabilities method."""
@pytest.mark.parametrize(
("loss"),
[
(torch.tensor([1.0, 2.0, 3.0])),
(torch.tensor([2.0, 3.0, 5.0])),
(torch.tensor([0.0, 100.0])),
],
)
def test_assign_sampling_probabilities(self, loss: Tensor) -> None:
"""Test that sampling probabilities are correctly assigned based on loss."""
probabilities = ActivationResampler.assign_sampling_probabilities(loss)
# Compare against non-vectorized implementation
squared_loss = [batch_item_loss.item() ** 2 for batch_item_loss in loss]
sum_squared = sum(squared_loss)
proportions = [item / sum_squared for item in squared_loss]
expected_probabilities = torch.tensor(proportions)
assert torch.allclose(
probabilities, expected_probabilities, atol=1e-4
), f"Expected probabilities {expected_probabilities} but got {probabilities}"
class TestSampleInput:
"""Tests for sample_input."""
def test_distribution(self) -> None:
"""Test that sample approximately matches a multinomial distribution."""
torch.manual_seed(0)
probabilities = torch.tensor([0.1, 0.2, 0.7])
results = [0, 0, 0]
for _ in range(10_000):
input_activations = torch.tensor([[0.0, 0], [1, 1], [2, 2]])
sampled_input = ActivationResampler.sample_input(probabilities, input_activations, [1])
# Get the input activation index (the first element is also the index)
sampled_activation_idx = sampled_input[0][0, 0].item()
results[int(sampled_activation_idx)] += 1
resulting_probabilities = torch.tensor([item / sum(results) for item in results])
assert torch.allclose(
resulting_probabilities, probabilities, atol=1e-2
), f"Expected probabilities {probabilities} but got {resulting_probabilities}"
def test_zero_probabilities(self) -> None:
"""Test where there are no dead neurons."""
probabilities = torch.tensor([[0.0], [0.0], [1.0]])
input_activations = torch.tensor([[[0.0, 0]], [[1, 1]], [[2, 2]]])
sampled_input = ActivationResampler.sample_input(probabilities, input_activations, [0])
assert sampled_input[0].shape == (0, 2), "Should return an empty tensor"
def test_sample_input_raises_value_error(self) -> None:
"""Test that ValueError is raised on length miss-match."""
probabilities = torch.tensor([0.1, 0.2, 0.7])
input_activations = torch.tensor([[1.0, 2], [3, 4], [5, 6]])
n_samples = [4] # More than the number of input activations
with pytest.raises(
ValueError, match=r"Cannot sample \d+ inputs from \d+ input activations."
):
ActivationResampler.sample_input(probabilities, input_activations, n_samples)
class TestRenormalizeAndScale:
"""Tests for renormalize_and_scale."""
@staticmethod
def calculate_expected_output(
| """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(
n_input_features=DEFAULT_N_INPUT_FEATURES,
n_learned_features=DEFAULT_N_LEARNED_FEATURES,
n_components=DEFAULT_N_COMPONENTS,
)
)
@pytest.fixture()
def loss_fn() -> LossReducer:
"""Loss function fixture."""
return LossReducer(LearnedActivationsL1Loss(0.01), L2ReconstructionLoss())
@pytest.fixture()
def activation_resampler_single_item_triggers() -> ActivationResampler:
"""Activation resampler where any call to step will result in resampling."""
return ActivationResampler(
n_activations_activity_collate=1,
n_learned_features=DEFAULT_N_LEARNED_FEATURES,
resample_dataset_size=1,
resample_interval=1,
threshold_is_dead_portion_fires=0.0,
)
class TestInit:
"""Tests for the activation resampler initialisation."""
@pytest.mark.parametrize(
("resample_interval", "n_steps_collate", "expected_window_start"),
[(100, 50, 50), (100, 100, 0)],
)
def test_neuron_activity_window_start(
self, resample_interval: int, n_steps_collate: int, expected_window_start: int
) -> None:
"""Test the neuron activity window start is set correctly."""
resampler = ActivationResampler(
n_learned_features=10,
resample_interval=resample_interval,
n_activations_activity_collate=n_steps_collate,
)
assert resampler.neuron_activity_window_start == expected_window_start
class TestComputeLossAndGetActivations:
"""Tests for compute_loss_and_get_activations."""
def test_gets_loss_and_correct_activations(
self,
full_activation_store: ActivationStore,
autoencoder_model: SparseAutoencoder,
) -> None:
"""Test it gets loss and also returns the input activations."""
resampler = ActivationResampler(
n_components=DEFAULT_N_COMPONENTS,
n_learned_features=DEFAULT_N_LEARNED_FEATURES,
resample_dataset_size=DEFAULT_N_ACTIVATIONS_STORE,
)
loss, input_activations = resampler.compute_loss_and_get_activations(
store=full_activation_store,
autoencoder=autoencoder_model,
loss_fn=L2ReconstructionLoss(),
train_batch_size=DEFAULT_N_ACTIVATIONS_STORE,
)
assert isinstance(loss, Tensor)
assert isinstance(input_activations, Tensor)
# Check that the activations are the same as the input data
assert torch.equal(input_activations, full_activation_store._data) # type: ignore # noqa: SLF001
def test_more_items_than_in_store_error(
self,
full_activation_store: ActivationStore,
autoencoder_model: SparseAutoencoder,
) -> None:
"""Test that an error is raised if there are more items than in the store."""
with pytest.raises(
ValueError,
match=r"Cannot get \d+ items from the store, as only \d+ were available.",
):
ActivationResampler(
resample_dataset_size=DEFAULT_N_ACTIVATIONS_STORE + 1,
n_learned_features=DEFAULT_N_LEARNED_FEATURES,
).compute_loss_and_get_activations(
store=full_activation_store,
autoencoder=autoencoder_model,
loss_fn=L2ReconstructionLoss(),
train_batch_size=DEFAULT_N_ACTIVATIONS_STORE + 1,
)
class TestAssignSamplingProbabilities:
"""Test the assign sampling probabilities method."""
@pytest.mark.parametrize(
("loss"),
[
(torch.tensor([1.0, 2.0, 3.0])),
(torch.tensor([2.0, 3.0, 5.0])),
(torch.tensor([0.0, 100.0])),
],
)
def test_assign_sampling_probabilities(self, loss: Tensor) -> None:
"""Test that sampling probabilities are correctly assigned based on loss."""
probabilities = ActivationResampler.assign_sampling_probabilities(loss)
# Compare against non-vectorized implementation
squared_loss = [batch_item_loss.item() ** 2 for batch_item_loss in loss]
sum_squared = sum(squared_loss)
proportions = [item / sum_squared for item in squared_loss]
expected_probabilities = torch.tensor(proportions)
assert torch.allclose(
probabilities, expected_probabilities, atol=1e-4
), f"Expected probabilities {expected_probabilities} but got {probabilities}"
class TestSampleInput:
"""Tests for sample_input."""
def test_distribution(self) -> None:
"""Test that sample approximately matches a multinomial distribution."""
torch.manual_seed(0)
probabilities = torch.tensor([0.1, 0.2, 0.7])
results = [0, 0, 0]
for _ in range(10_000):
input_activations = torch.tensor([[0.0, 0], [1, 1], [2, 2]])
sampled_input = ActivationResampler.sample_input(probabilities, input_activations, [1])
# Get the input activation index (the first element is also the index)
sampled_activation_idx = sampled_input[0][0, 0].item()
results[int(sampled_activation_idx)] += 1
resulting_probabilities = torch.tensor([item / sum(results) for item in results])
assert torch.allclose(
resulting_probabilities, probabilities, atol=1e-2
), f"Expected probabilities {probabilities} but got {resulting_probabilities}"
def test_zero_probabilities(self) -> None:
"""Test where there are no dead neurons."""
probabilities = torch.tensor([[0.0], [0.0], [1.0]])
input_activations = torch.tensor([[[0.0, 0]], [[1, 1]], [[2, 2]]])
sampled_input = ActivationResampler.sample_input(probabilities, input_activations, [0])
assert sampled_input[0].shape == (0, 2), "Should return an empty tensor"
def test_sample_input_raises_value_error(self) -> None:
"""Test that ValueError is raised on length miss-match."""
probabilities = torch.tensor([0.1, 0.2, 0.7])
input_activations = torch.tensor([[1.0, 2], [3, 4], [5, 6]])
n_samples = [4] # More than the number of input activations
with pytest.raises(
ValueError, match=r"Cannot sample \d+ inputs from \d+ input activations."
):
ActivationResampler.sample_input(probabilities, input_activations, n_samples)
class TestRenormalizeAndScale:
"""Tests for renormalize_and_scale."""
@staticmethod
def calculate_expected_output( | sampled_input: Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)], | 8 | 2023-10-27 07:37:15+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.