SYMBOL INDEX (1654 symbols across 163 files)

FILE: CogVideo/finetune/models/attention.py
  function _chunked_feed_forward (line 29) | def _chunked_feed_forward(ff: nn.Module, hidden_states: torch.Tensor, ch...
  class GatedSelfAttentionDense (line 45) | class GatedSelfAttentionDense(nn.Module):
    method __init__ (line 56) | def __init__(self, query_dim: int, context_dim: int, n_heads: int, d_h...
    method forward (line 73) | def forward(self, x: torch.Tensor, objs: torch.Tensor) -> torch.Tensor:
  class JointTransformerBlock (line 87) | class JointTransformerBlock(nn.Module):
    method __init__ (line 101) | def __init__(
    method set_chunk_feed_forward (line 183) | def set_chunk_feed_forward(self, chunk_size: Optional[int], dim: int =...
    method forward (line 188) | def forward(
  class BasicTransformerBlock (line 252) | class BasicTransformerBlock(nn.Module):
    method __init__ (line 287) | def __init__(
    method set_chunk_feed_forward (line 455) | def set_chunk_feed_forward(self, chunk_size: Optional[int], dim: int =...
    method forward (line 460) | def forward(
  class LuminaFeedForward (line 583) | class LuminaFeedForward(nn.Module):
    method __init__ (line 598) | def __init__(
    method forward (line 629) | def forward(self, x):
  class TemporalBasicTransformerBlock (line 634) | class TemporalBasicTransformerBlock(nn.Module):
    method __init__ (line 646) | def __init__(
    method set_chunk_feed_forward (line 699) | def set_chunk_feed_forward(self, chunk_size: Optional[int], **kwargs):
    method forward (line 705) | def forward(
  class SkipFFTransformerBlock (line 763) | class SkipFFTransformerBlock(nn.Module):
    method __init__ (line 764) | def __init__(
    method forward (line 806) | def forward(self, hidden_states, encoder_hidden_states, cross_attentio...
  class FreeNoiseTransformerBlock (line 836) | class FreeNoiseTransformerBlock(nn.Module):
    method __init__ (line 891) | def __init__(
    method _get_frame_indices (line 1005) | def _get_frame_indices(self, num_frames: int) -> List[Tuple[int, int]]:
    method _get_frame_weights (line 1013) | def _get_frame_weights(self, num_frames: int, weighting_scheme: str = ...
    method set_free_noise_properties (line 1045) | def set_free_noise_properties(
    method set_chunk_feed_forward (line 1052) | def set_chunk_feed_forward(self, chunk_size: Optional[int], dim: int =...
    method forward (line 1057) | def forward(
  class FeedForward (line 1183) | class FeedForward(nn.Module):
    method __init__ (line 1197) | def __init__(
    method forward (line 1235) | def forward(self, hidden_states: torch.Tensor, *args, **kwargs) -> tor...

FILE: CogVideo/finetune/models/attention_processor.py
  class Attention (line 41) | class Attention(nn.Module):
    method __init__ (line 96) | def __init__(
    method set_use_npu_flash_attention (line 271) | def set_use_npu_flash_attention(self, use_npu_flash_attention: bool) -...
    method set_use_memory_efficient_attention_xformers (line 288) | def set_use_memory_efficient_attention_xformers(
    method set_attention_slice (line 395) | def set_attention_slice(self, slice_size: int) -> None:
    method set_processor (line 423) | def set_processor(self, processor: "AttnProcessor") -> None:
    method get_processor (line 443) | def get_processor(self, return_deprecated_lora: bool = False) -> "Atte...
    method forward (line 457) | def forward(
    method batch_to_head_dim (line 503) | def batch_to_head_dim(self, tensor: torch.Tensor) -> torch.Tensor:
    method head_to_batch_dim (line 520) | def head_to_batch_dim(self, tensor: torch.Tensor, out_dim: int = 3) ->...
    method get_attention_scores (line 547) | def get_attention_scores(
    method prepare_attention_mask (line 594) | def prepare_attention_mask(
    method norm_encoder_hidden_states (line 641) | def norm_encoder_hidden_states(self, encoder_hidden_states: torch.Tens...
    method fuse_projections (line 671) | def fuse_projections(self, fuse=True):
  class AttnProcessor (line 720) | class AttnProcessor:
    method __call__ (line 725) | def __call__(
  class CustomDiffusionAttnProcessor (line 792) | class CustomDiffusionAttnProcessor(nn.Module):
    method __init__ (line 811) | def __init__(
    method __call__ (line 837) | def __call__(
  class AttnAddedKVProcessor (line 896) | class AttnAddedKVProcessor:
    method __call__ (line 902) | def __call__(
  class AttnAddedKVProcessor2_0 (line 963) | class AttnAddedKVProcessor2_0:
    method __init__ (line 969) | def __init__(self):
    method __call__ (line 975) | def __call__(
  class JointAttnProcessor2_0 (line 1039) | class JointAttnProcessor2_0:
    method __init__ (line 1042) | def __init__(self):
    method __call__ (line 1046) | def __call__(
  class PAGJointAttnProcessor2_0 (line 1125) | class PAGJointAttnProcessor2_0:
    method __init__ (line 1128) | def __init__(self):
    method __call__ (line 1134) | def __call__(
  class PAGCFGJointAttnProcessor2_0 (line 1280) | class PAGCFGJointAttnProcessor2_0:
    method __init__ (line 1283) | def __init__(self):
    method __call__ (line 1289) | def __call__(
  class FusedJointAttnProcessor2_0 (line 1445) | class FusedJointAttnProcessor2_0:
    method __init__ (line 1448) | def __init__(self):
    method __call__ (line 1452) | def __call__(
  class AuraFlowAttnProcessor2_0 (line 1524) | class AuraFlowAttnProcessor2_0:
    method __init__ (line 1527) | def __init__(self):
    method __call__ (line 1533) | def __call__(
  class FusedAuraFlowAttnProcessor2_0 (line 1617) | class FusedAuraFlowAttnProcessor2_0:
    method __init__ (line 1620) | def __init__(self):
    method __call__ (line 1626) | def __call__(
  class FluxAttnProcessor2_0 (line 1714) | class FluxAttnProcessor2_0:
    method __init__ (line 1717) | def __init__(self):
    method __call__ (line 1721) | def __call__(
  class FusedFluxAttnProcessor2_0 (line 1802) | class FusedFluxAttnProcessor2_0:
    method __init__ (line 1805) | def __init__(self):
    method __call__ (line 1811) | def __call__(
  class CogVideoXAttnProcessor2_0 (line 1896) | class CogVideoXAttnProcessor2_0:
    method __init__ (line 1902) | def __init__(self):
    method __call__ (line 1906) | def __call__(
  class FusedCogVideoXAttnProcessor2_0 (line 1985) | class FusedCogVideoXAttnProcessor2_0:
    method __init__ (line 1991) | def __init__(self):
    method __call__ (line 1995) | def __call__(
  class XFormersAttnAddedKVProcessor (line 2056) | class XFormersAttnAddedKVProcessor:
    method __init__ (line 2068) | def __init__(self, attention_op: Optional[Callable] = None):
    method __call__ (line 2071) | def __call__(
  class XFormersAttnProcessor (line 2127) | class XFormersAttnProcessor:
    method __init__ (line 2139) | def __init__(self, attention_op: Optional[Callable] = None):
    method __call__ (line 2142) | def __call__(
  class AttnProcessorNPU (line 2221) | class AttnProcessorNPU:
    method __init__ (line 2229) | def __init__(self):
    method __call__ (line 2233) | def __call__(
  class AttnProcessor2_0 (line 2330) | class AttnProcessor2_0:
    method __init__ (line 2335) | def __init__(self):
    method __call__ (line 2339) | def __call__(
  class StableAudioAttnProcessor2_0 (line 2424) | class StableAudioAttnProcessor2_0:
    method __init__ (line 2430) | def __init__(self):
    method apply_partial_rotary_emb (line 2436) | def apply_partial_rotary_emb(
    method __call__ (line 2451) | def __call__(
  class HunyuanAttnProcessor2_0 (line 2555) | class HunyuanAttnProcessor2_0:
    method __init__ (line 2561) | def __init__(self):
    method __call__ (line 2565) | def __call__(
  class FusedHunyuanAttnProcessor2_0 (line 2653) | class FusedHunyuanAttnProcessor2_0:
    method __init__ (line 2660) | def __init__(self):
    method __call__ (line 2666) | def __call__(
  class PAGHunyuanAttnProcessor2_0 (line 2756) | class PAGHunyuanAttnProcessor2_0:
    method __init__ (line 2763) | def __init__(self):
    method __call__ (line 2769) | def __call__(
  class PAGCFGHunyuanAttnProcessor2_0 (line 2879) | class PAGCFGHunyuanAttnProcessor2_0:
    method __init__ (line 2886) | def __init__(self):
    method __call__ (line 2892) | def __call__(
  class LuminaAttnProcessor2_0 (line 3003) | class LuminaAttnProcessor2_0:
    method __init__ (line 3009) | def __init__(self):
    method __call__ (line 3013) | def __call__(
  class FusedAttnProcessor2_0 (line 3099) | class FusedAttnProcessor2_0:
    method __init__ (line 3112) | def __init__(self):
    method __call__ (line 3118) | def __call__(
  class CustomDiffusionXFormersAttnProcessor (line 3205) | class CustomDiffusionXFormersAttnProcessor(nn.Module):
    method __init__ (line 3228) | def __init__(
    method __call__ (line 3256) | def __call__(
  class CustomDiffusionAttnProcessor2_0 (line 3321) | class CustomDiffusionAttnProcessor2_0(nn.Module):
    method __init__ (line 3341) | def __init__(
    method __call__ (line 3367) | def __call__(
  class SlicedAttnProcessor (line 3435) | class SlicedAttnProcessor:
    method __init__ (line 3445) | def __init__(self, slice_size: int):
    method __call__ (line 3448) | def __call__(
  class SlicedAttnAddedKVProcessor (line 3522) | class SlicedAttnAddedKVProcessor:
    method __init__ (line 3532) | def __init__(self, slice_size):
    method __call__ (line 3535) | def __call__(
  class SpatialNorm (line 3614) | class SpatialNorm(nn.Module):
    method __init__ (line 3625) | def __init__(
    method forward (line 3635) | def forward(self, f: torch.Tensor, zq: torch.Tensor) -> torch.Tensor:
  class IPAdapterAttnProcessor (line 3643) | class IPAdapterAttnProcessor(nn.Module):
    method __init__ (line 3658) | def __init__(self, hidden_size, cross_attention_dim=None, num_tokens=(...
    method __call__ (line 3681) | def __call__(
  class IPAdapterAttnProcessor2_0 (line 3841) | class IPAdapterAttnProcessor2_0(torch.nn.Module):
    method __init__ (line 3856) | def __init__(self, hidden_size, cross_attention_dim=None, num_tokens=(...
    method __call__ (line 3884) | def __call__(
  class PAGIdentitySelfAttnProcessor2_0 (line 4071) | class PAGIdentitySelfAttnProcessor2_0:
    method __init__ (line 4077) | def __init__(self):
    method __call__ (line 4083) | def __call__(
  class PAGCFGIdentitySelfAttnProcessor2_0 (line 4170) | class PAGCFGIdentitySelfAttnProcessor2_0:
    method __init__ (line 4176) | def __init__(self):
    method __call__ (line 4182) | def __call__(
  class LoRAAttnProcessor (line 4273) | class LoRAAttnProcessor:
    method __init__ (line 4274) | def __init__(self):
  class LoRAAttnProcessor2_0 (line 4278) | class LoRAAttnProcessor2_0:
    method __init__ (line 4279) | def __init__(self):
  class LoRAXFormersAttnProcessor (line 4283) | class LoRAXFormersAttnProcessor:
    method __init__ (line 4284) | def __init__(self):
  class LoRAAttnAddedKVProcessor (line 4288) | class LoRAAttnAddedKVProcessor:
    method __init__ (line 4289) | def __init__(self):
  class FluxSingleAttnProcessor2_0 (line 4293) | class FluxSingleAttnProcessor2_0(FluxAttnProcessor2_0):
    method __init__ (line 4298) | def __init__(self):

FILE: CogVideo/finetune/models/cogvideox_transformer_3d.py
  class CogVideoXBlock (line 36) | class CogVideoXBlock(nn.Module):
    method __init__ (line 71) | def __init__(
    method forward (line 134) | def forward(
  class CogVideoXTransformer3DModel (line 204) | class CogVideoXTransformer3DModel(ModelMixin, ConfigMixin, PeftAdapterMi...
    method __init__ (line 261) | def __init__(
    method _set_gradient_checkpointing (line 356) | def _set_gradient_checkpointing(self, module, value=False):
    method attn_processors (line 361) | def attn_processors(self) -> Dict[str, AttentionProcessor]:
    method set_attn_processor (line 385) | def set_attn_processor(self, processor: Union[AttentionProcessor, Dict...
    method fuse_qkv_projections (line 420) | def fuse_qkv_projections(self):
    method unfuse_qkv_projections (line 446) | def unfuse_qkv_projections(self):
    method forward (line 459) | def forward(

FILE: CogVideo/finetune/models/embeddings.py
  function get_timestep_embedding (line 29) | def get_timestep_embedding(
  function get_3d_sincos_pos_embed (line 83) | def get_3d_sincos_pos_embed(
  function get_2d_sincos_pos_embed (line 130) | def get_2d_sincos_pos_embed(
  function get_2d_sincos_pos_embed_from_grid (line 152) | def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
  function get_1d_sincos_pos_embed_from_grid (line 164) | def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
  class PatchEmbed (line 185) | class PatchEmbed(nn.Module):
    method __init__ (line 188) | def __init__(
    method cropped_pos_embed (line 239) | def cropped_pos_embed(self, height, width):
    method forward (line 262) | def forward(self, latent):
  class LuminaPatchEmbed (line 293) | class LuminaPatchEmbed(nn.Module):
    method __init__ (line 296) | def __init__(self, patch_size=2, in_channels=4, embed_dim=768, bias=Tr...
    method forward (line 305) | def forward(self, x, freqs_cis):
  class CogVideoXPatchEmbed (line 339) | class CogVideoXPatchEmbed(nn.Module):
    method __init__ (line 340) | def __init__(
    method _get_positional_embeddings (line 381) | def _get_positional_embeddings(self, sample_height: int, sample_width:...
    method forward (line 402) | def forward(self, empty_text_embeds: torch.Tensor, text_embeds: torch....
  class CogView3PlusPatchEmbed (line 455) | class CogView3PlusPatchEmbed(nn.Module):
    method __init__ (line 456) | def __init__(
    method forward (line 480) | def forward(self, hidden_states: torch.Tensor, encoder_hidden_states: ...
  function get_3d_rotary_pos_embed (line 509) | def get_3d_rotary_pos_embed(
  function get_2d_rotary_pos_embed (line 577) | def get_2d_rotary_pos_embed(embed_dim, crops_coords, grid_size, use_real...
  function get_2d_rotary_pos_embed_from_grid (line 605) | def get_2d_rotary_pos_embed_from_grid(embed_dim, grid, use_real=False):
  function get_2d_rotary_pos_embed_lumina (line 625) | def get_2d_rotary_pos_embed_lumina(embed_dim, len_h, len_w, linear_facto...
  function get_1d_rotary_pos_embed (line 641) | def get_1d_rotary_pos_embed(
  function apply_rotary_emb (line 707) | def apply_rotary_emb(
  class FluxPosEmbed (line 756) | class FluxPosEmbed(nn.Module):
    method __init__ (line 758) | def __init__(self, theta: int, axes_dim: List[int]):
    method forward (line 763) | def forward(self, ids: torch.Tensor) -> torch.Tensor:
  class TimestepEmbedding (line 781) | class TimestepEmbedding(nn.Module):
    method __init__ (line 782) | def __init__(
    method forward (line 814) | def forward(self, sample, condition=None):
  class Timesteps (line 829) | class Timesteps(nn.Module):
    method __init__ (line 830) | def __init__(self, num_channels: int, flip_sin_to_cos: bool, downscale...
    method forward (line 837) | def forward(self, timesteps):
  class GaussianFourierProjection (line 848) | class GaussianFourierProjection(nn.Module):
    method __init__ (line 851) | def __init__(
    method forward (line 866) | def forward(self, x):
  class SinusoidalPositionalEmbedding (line 879) | class SinusoidalPositionalEmbedding(nn.Module):
    method __init__ (line 891) | def __init__(self, embed_dim: int, max_seq_length: int = 32):
    method forward (line 900) | def forward(self, x):
  class ImagePositionalEmbeddings (line 906) | class ImagePositionalEmbeddings(nn.Module):
    method __init__ (line 930) | def __init__(
    method forward (line 948) | def forward(self, index):
  class LabelEmbedding (line 971) | class LabelEmbedding(nn.Module):
    method __init__ (line 981) | def __init__(self, num_classes, hidden_size, dropout_prob):
    method token_drop (line 988) | def token_drop(self, labels, force_drop_ids=None):
    method forward (line 999) | def forward(self, labels: torch.LongTensor, force_drop_ids=None):
  class TextImageProjection (line 1007) | class TextImageProjection(nn.Module):
    method __init__ (line 1008) | def __init__(
    method forward (line 1021) | def forward(self, text_embeds: torch.Tensor, image_embeds: torch.Tensor):
  class ImageProjection (line 1034) | class ImageProjection(nn.Module):
    method __init__ (line 1035) | def __init__(
    method forward (line 1047) | def forward(self, image_embeds: torch.Tensor):
  class IPAdapterFullImageProjection (line 1057) | class IPAdapterFullImageProjection(nn.Module):
    method __init__ (line 1058) | def __init__(self, image_embed_dim=1024, cross_attention_dim=1024):
    method forward (line 1065) | def forward(self, image_embeds: torch.Tensor):
  class IPAdapterFaceIDImageProjection (line 1069) | class IPAdapterFaceIDImageProjection(nn.Module):
    method __init__ (line 1070) | def __init__(self, image_embed_dim=1024, cross_attention_dim=1024, mul...
    method forward (line 1079) | def forward(self, image_embeds: torch.Tensor):
  class CombinedTimestepLabelEmbeddings (line 1085) | class CombinedTimestepLabelEmbeddings(nn.Module):
    method __init__ (line 1086) | def __init__(self, num_classes, embedding_dim, class_dropout_prob=0.1):
    method forward (line 1093) | def forward(self, timestep, class_labels, hidden_dtype=None):
  class CombinedTimestepTextProjEmbeddings (line 1104) | class CombinedTimestepTextProjEmbeddings(nn.Module):
    method __init__ (line 1105) | def __init__(self, embedding_dim, pooled_projection_dim):
    method forward (line 1112) | def forward(self, timestep, pooled_projection):
  class CombinedTimestepGuidanceTextProjEmbeddings (line 1123) | class CombinedTimestepGuidanceTextProjEmbeddings(nn.Module):
    method __init__ (line 1124) | def __init__(self, embedding_dim, pooled_projection_dim):
    method forward (line 1132) | def forward(self, timestep, guidance, pooled_projection):
  class CogView3CombinedTimestepSizeEmbeddings (line 1147) | class CogView3CombinedTimestepSizeEmbeddings(nn.Module):
    method __init__ (line 1148) | def __init__(self, embedding_dim: int, condition_dim: int, pooled_proj...
    method forward (line 1156) | def forward(
  class HunyuanDiTAttentionPool (line 1180) | class HunyuanDiTAttentionPool(nn.Module):
    method __init__ (line 1183) | def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, o...
    method forward (line 1192) | def forward(self, x):
  class HunyuanCombinedTimestepTextSizeStyleEmbedding (line 1220) | class HunyuanCombinedTimestepTextSizeStyleEmbedding(nn.Module):
    method __init__ (line 1221) | def __init__(
    method forward (line 1255) | def forward(self, timestep, encoder_hidden_states, image_meta_size, st...
  class LuminaCombinedTimestepCaptionEmbedding (line 1281) | class LuminaCombinedTimestepCaptionEmbedding(nn.Module):
    method __init__ (line 1282) | def __init__(self, hidden_size=4096, cross_attention_dim=2048, frequen...
    method forward (line 1299) | def forward(self, timestep, caption_feat, caption_mask):
  class TextTimeEmbedding (line 1315) | class TextTimeEmbedding(nn.Module):
    method __init__ (line 1316) | def __init__(self, encoder_dim: int, time_embed_dim: int, num_heads: i...
    method forward (line 1323) | def forward(self, hidden_states):
  class TextImageTimeEmbedding (line 1331) | class TextImageTimeEmbedding(nn.Module):
    method __init__ (line 1332) | def __init__(self, text_embed_dim: int = 768, image_embed_dim: int = 7...
    method forward (line 1338) | def forward(self, text_embeds: torch.Tensor, image_embeds: torch.Tensor):
  class ImageTimeEmbedding (line 1349) | class ImageTimeEmbedding(nn.Module):
    method __init__ (line 1350) | def __init__(self, image_embed_dim: int = 768, time_embed_dim: int = 1...
    method forward (line 1355) | def forward(self, image_embeds: torch.Tensor):
  class ImageHintTimeEmbedding (line 1362) | class ImageHintTimeEmbedding(nn.Module):
    method __init__ (line 1363) | def __init__(self, image_embed_dim: int = 768, time_embed_dim: int = 1...
    method forward (line 1385) | def forward(self, image_embeds: torch.Tensor, hint: torch.Tensor):
  class AttentionPooling (line 1393) | class AttentionPooling(nn.Module):
    method __init__ (line 1396) | def __init__(self, num_heads, embed_dim, dtype=None):
    method forward (line 1406) | def forward(self, x):
  function get_fourier_embeds_from_boundingbox (line 1443) | def get_fourier_embeds_from_boundingbox(embed_dim, box):
  class GLIGENTextBoundingboxProjection (line 1464) | class GLIGENTextBoundingboxProjection(nn.Module):
    method __init__ (line 1465) | def __init__(self, positive_len, out_dim, feature_type="text-only", fo...
    method forward (line 1506) | def forward(
  class PixArtAlphaCombinedTimestepSizeEmbeddings (line 1557) | class PixArtAlphaCombinedTimestepSizeEmbeddings(nn.Module):
    method __init__ (line 1565) | def __init__(self, embedding_dim, size_emb_dim, use_additional_conditi...
    method forward (line 1578) | def forward(self, timestep, resolution, aspect_ratio, batch_size, hidd...
  class PixArtAlphaTextProjection (line 1594) | class PixArtAlphaTextProjection(nn.Module):
    method __init__ (line 1601) | def __init__(self, in_features, hidden_size, out_features=None, act_fn...
    method forward (line 1616) | def forward(self, caption):
  class IPAdapterPlusImageProjectionBlock (line 1623) | class IPAdapterPlusImageProjectionBlock(nn.Module):
    method __init__ (line 1624) | def __init__(
    method forward (line 1647) | def forward(self, x, latents, residual):
  class IPAdapterPlusImageProjection (line 1656) | class IPAdapterPlusImageProjection(nn.Module):
    method __init__ (line 1672) | def __init__(
    method forward (line 1695) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class IPAdapterFaceIDPlusImageProjection (line 1715) | class IPAdapterFaceIDPlusImageProjection(nn.Module):
    method __init__ (line 1732) | def __init__(
    method forward (line 1767) | def forward(self, id_embeds: torch.Tensor) -> torch.Tensor:
  class MultiIPAdapterImageProjection (line 1795) | class MultiIPAdapterImageProjection(nn.Module):
    method __init__ (line 1796) | def __init__(self, IPAdapterImageProjectionLayers: Union[List[nn.Modul...
    method forward (line 1800) | def forward(self, image_embeds: List[torch.Tensor]):

FILE: CogVideo/finetune/models/pipeline_cogvideox.py
  function get_resize_crop_region_for_grid (line 68) | def get_resize_crop_region_for_grid(src, tgt_width, tgt_height):
  function retrieve_timesteps (line 87) | def retrieve_timesteps(
  class CogVideoXPipeline (line 146) | class CogVideoXPipeline(DiffusionPipeline, CogVideoXLoraLoaderMixin):
    method __init__ (line 178) | def __init__(
    method _get_t5_prompt_embeds (line 203) | def _get_t5_prompt_embeds(
    method encode_prompt (line 248) | def encode_prompt(
    method prepare_latents (line 329) | def prepare_latents(
    method decode_latents (line 355) | def decode_latents(self, latents: torch.Tensor) -> torch.Tensor:
    method prepare_extra_step_kwargs (line 363) | def prepare_extra_step_kwargs(self, generator, eta):
    method check_inputs (line 381) | def check_inputs(
    method fuse_qkv_projections (line 432) | def fuse_qkv_projections(self) -> None:
    method unfuse_qkv_projections (line 437) | def unfuse_qkv_projections(self) -> None:
    method _prepare_rotary_positional_embeddings (line 445) | def _prepare_rotary_positional_embeddings(
    method guidance_scale (line 472) | def guidance_scale(self):
    method num_timesteps (line 476) | def num_timesteps(self):
    method attention_kwargs (line 480) | def attention_kwargs(self):
    method interrupt (line 484) | def interrupt(self):
    method __call__ (line 489) | def __call__(

FILE: CogVideo/finetune/models/pipeline_output.py
  class CogVideoXPipelineOutput (line 9) | class CogVideoXPipelineOutput(BaseOutput):

FILE: CogVideo/finetune/models/utils.py
  function lora_state_dict (line 55) | def lora_state_dict(

FILE: CogVideo/finetune/train_cogvideox_injector.py
  function get_args (line 59) | def get_args():
  function parse_matrix (line 412) | def parse_matrix(matrix_str):
  class VideoDataset (line 420) | class VideoDataset(Dataset):
    method __init__ (line 421) | def __init__(
    method __len__ (line 537) | def __len__(self):
    method save_images2video (line 540) | def save_images2video(self, images, video_name):
    method __getitem__ (line 564) | def __getitem__(self, idx):
    method load_sceneposes (line 671) | def load_sceneposes(self, objs_file, obj_idx, obj_transl):
  function save_model_card (line 683) | def save_model_card(
  function log_validation (line 763) | def log_validation(
  function _get_t5_prompt_embeds (line 828) | def _get_t5_prompt_embeds(
  function encode_prompt (line 868) | def encode_prompt(
  function compute_prompt_embeddings (line 892) | def compute_prompt_embeddings(
  function prepare_rotary_positional_embeddings (line 919) | def prepare_rotary_positional_embeddings(
  function get_optimizer (line 948) | def get_optimizer(args, params_to_optimize, use_deepspeed: bool = False):
  function main (line 1029) | def main(args):

FILE: CogVideo/finetune/train_cogvideox_lora.py
  function get_args (line 56) | def get_args():
  function parse_matrix (line 393) | def parse_matrix(matrix_str):
  class VideoDataset (line 401) | class VideoDataset(Dataset):
    method __init__ (line 402) | def __init__(
    method __len__ (line 518) | def __len__(self):
    method save_images2video (line 521) | def save_images2video(self, images, video_name):
    method __getitem__ (line 545) | def __getitem__(self, idx):
    method load_sceneposes (line 650) | def load_sceneposes(self, objs_file, obj_idx, obj_transl):
  function save_model_card (line 662) | def save_model_card(
  function log_validation (line 742) | def log_validation(
  function _get_t5_prompt_embeds (line 807) | def _get_t5_prompt_embeds(
  function encode_prompt (line 845) | def encode_prompt(
  function compute_prompt_embeddings (line 869) | def compute_prompt_embeddings(
  function prepare_rotary_positional_embeddings (line 896) | def prepare_rotary_positional_embeddings(
  function get_optimizer (line 925) | def get_optimizer(args, params_to_optimize, use_deepspeed: bool = False):
  function main (line 1007) | def main(args):

FILE: CogVideo/inference/3dtrajmaster_inference.py
  function parse_matrix (line 32) | def parse_matrix(matrix_str):
  function load_sceneposes (line 40) | def load_sceneposes(objs_file, obj_idx, obj_transl):
  function get_pose_embeds (line 51) | def get_pose_embeds(scene, video_name, instance_data_root, locations_inf...
  function init_cam_poses (line 90) | def init_cam_poses(instance_data_root):
  function generate_video (line 104) | def generate_video(

FILE: CogVideo/tools/caption/video_caption.py
  function load_video (line 20) | def load_video(video_data, strategy='chat'):
  function predict (line 64) | def predict(prompt, video_data, temperature):
  function test (line 99) | def test():

FILE: CogVideo/tools/convert_weight_sat2hf.py
  function reassign_query_key_value_inplace (line 35) | def reassign_query_key_value_inplace(key: str, state_dict: Dict[str, Any]):
  function reassign_query_key_layernorm_inplace (line 46) | def reassign_query_key_layernorm_inplace(key: str, state_dict: Dict[str,...
  function reassign_adaln_norm_inplace (line 57) | def reassign_adaln_norm_inplace(key: str, state_dict: Dict[str, Any]):
  function remove_keys_inplace (line 73) | def remove_keys_inplace(key: str, state_dict: Dict[str, Any]):
  function replace_up_keys_inplace (line 77) | def replace_up_keys_inplace(key: str, state_dict: Dict[str, Any]):
  function get_state_dict (line 140) | def get_state_dict(saved_dict: Dict[str, Any]) -> Dict[str, Any]:
  function update_state_dict_inplace (line 151) | def update_state_dict_inplace(state_dict: Dict[str, Any], old_key: str, ...
  function convert_transformer (line 155) | def convert_transformer(
  function convert_vae (line 189) | def convert_vae(ckpt_path: str, scaling_factor: float, dtype: torch.dtype):
  function get_args (line 209) | def get_args():

FILE: CogVideo/tools/export_sat_lora_weight.py
  function get_state_dict (line 8) | def get_state_dict(saved_dict: Dict[str, Any]) -> Dict[str, Any]:
  function export_lora_weight (line 38) | def export_lora_weight(ckpt_path,lora_save_directory):
  function get_args (line 71) | def get_args():

FILE: CogVideo/tools/llm_flux_cogvideox/gradio_page.py
  function generate_caption (line 81) | def generate_caption(prompt):
  function generate_image (line 101) | def generate_image(caption, progress=gr.Progress(track_tqdm=True)):
  function generate_video (line 112) | def generate_video(
  function save_video (line 134) | def save_video(tensor):
  function convert_to_gif (line 142) | def convert_to_gif(video_path):
  function delete_old_files (line 151) | def delete_old_files():

FILE: CogVideo/tools/llm_flux_cogvideox/llm_flux_cogvideox.py
  function get_args (line 62) | def get_args():
  function reset_memory (line 142) | def reset_memory():
  function main (line 150) | def main(args: Dict[str, Any]) -> None:

FILE: CogVideo/tools/load_cogvideox_lora.py
  function get_args (line 32) | def get_args():

FILE: CogVideo/tools/parallel_inference/parallel_inference_xdit.py
  function main (line 42) | def main():

FILE: CogVideo/tools/replicate/predict_i2v.py
  function download_weights (line 26) | def download_weights(url, dest):
  class Predictor (line 34) | class Predictor(BasePredictor):
    method setup (line 35) | def setup(self) -> None:
    method predict (line 49) | def predict(

FILE: CogVideo/tools/replicate/predict_t2v.py
  function download_weights (line 26) | def download_weights(url, dest):
  class Predictor (line 34) | class Predictor(BasePredictor):
    method setup (line 35) | def setup(self) -> None:
    method predict (line 50) | def predict(

FILE: dataset/utils.py
  function get_camera_frustum (line 28) | def get_camera_frustum(img_size, K, W2C, frustum_length=0.5, color=[0., ...
  function frustums2lineset (line 55) | def frustums2lineset(frustums):
  function visualize_cameras (line 73) | def visualize_cameras(colored_camera_dicts, sphere_radius, camera_size=0...
  function parse_matrix (line 110) | def parse_matrix(matrix_str):
  function load_sceneposes (line 118) | def load_sceneposes(objs_file, obj_idx, obj_transl):
  function save_images2video (line 129) | def save_images2video(images, video_name, fps):
  function normalize (line 154) | def normalize(x):
  function viewmatrix (line 157) | def viewmatrix(z, up, pos):
  function matrix_to_euler_angles (line 165) | def matrix_to_euler_angles(matrix):
  function eul2rot (line 180) | def eul2rot(theta) :
  function extract_location_rotation (line 188) | def extract_location_rotation(data):
  function get_cam_points_vis (line 200) | def get_cam_points_vis(W, H, intrinsics, ext_pose, color,frustum_length):
  function batch_axis_angle_to_rotation_matrix (line 212) | def batch_axis_angle_to_rotation_matrix(r_batch):

FILE: eval/GVHMR/hmr4d/__init__.py
  function os_chdir_to_proj_root (line 7) | def os_chdir_to_proj_root():

FILE: eval/GVHMR/hmr4d/build_gvhmr.py
  function build_gvhmr_demo (line 7) | def build_gvhmr_demo():

FILE: eval/GVHMR/hmr4d/configs/__init__.py
  function register_store_gvhmr (line 14) | def register_store_gvhmr():
  function parse_args_to_cfg (line 19) | def parse_args_to_cfg():

FILE: eval/GVHMR/hmr4d/datamodule/mocap_trainX_testY.py
  function collate_fn (line 17) | def collate_fn(batch):
  class DataModule (line 33) | class DataModule(pl.LightningDataModule):
    method __init__ (line 34) | def __init__(self, dataset_opts: DictConfig, loader_opts: DictConfig, ...
    method train_dataloader (line 82) | def train_dataloader(self):
    method val_dataloader (line 96) | def val_dataloader(self):
    method test_dataloader (line 114) | def test_dataloader(self):

FILE: eval/GVHMR/hmr4d/dataset/bedlam/bedlam.py
  class BedlamDatasetV2 (line 22) | class BedlamDatasetV2(ImgfeatMotionDatasetBase):
    method __init__ (line 30) | def __init__(
    method _load_dataset (line 50) | def _load_dataset(self):
    method _get_idx2meta (line 80) | def _get_idx2meta(self):
    method _load_data (line 85) | def _load_data(self, idx):
    method _process_data (line 128) | def _process_data(self, data, idx):

FILE: eval/GVHMR/hmr4d/dataset/bedlam/utils.py
  function mid2vname (line 8) | def mid2vname(mid):
  function mid2featname (line 18) | def mid2featname(mid):
  function featname2mid (line 28) | def featname2mid(featname):
  function load_vname2lwh (line 38) | def load_vname2lwh():

FILE: eval/GVHMR/hmr4d/dataset/emdb/emdb_motion_test.py
  class EmdbSmplFullSeqDataset (line 21) | class EmdbSmplFullSeqDataset(data.Dataset):
    method __init__ (line 22) | def __init__(self, split=1, flip_test=False):
    method __len__ (line 52) | def __len__(self):
    method _load_data (line 55) | def _load_data(self, idx):
    method _process_data (line 136) | def _process_data(self, data):
    method __getitem__ (line 141) | def __getitem__(self, idx):

FILE: eval/GVHMR/hmr4d/dataset/emdb/utils.py
  function name_to_subfolder (line 10) | def name_to_subfolder(name):
  function name_to_local_pkl_path (line 14) | def name_to_local_pkl_path(name):
  function load_raw_pkl (line 18) | def load_raw_pkl(fp):
  function load_pkl (line 24) | def load_pkl(fp):
  function _check_annot (line 103) | def _check_annot(emdb_raw_dir=Path("inputs/EMDB/EMDB")):
  function _check_length (line 110) | def _check_length(emdb_raw_dir=Path("inputs/EMDB/EMDB"), emdb_hmr4d_supp...

FILE: eval/GVHMR/hmr4d/dataset/h36m/h36m.py
  class H36mSmplDataset (line 23) | class H36mSmplDataset(ImgfeatMotionDatasetBase):
    method __init__ (line 24) | def __init__(
    method _load_dataset (line 43) | def _load_dataset(self):
    method _get_idx2meta (line 69) | def _get_idx2meta(self):
    method _load_data (line 82) | def _load_data(self, idx):
    method _process_data (line 119) | def _process_data(self, data, idx):

FILE: eval/GVHMR/hmr4d/dataset/h36m/utils.py
  function get_vid (line 13) | def get_vid(pkl_path, cam_id):
  function get_raw_pkl_paths (line 20) | def get_raw_pkl_paths(h36m_raw_root):
  function get_cam_KRts (line 31) | def get_cam_KRts():
  function parse_raw_pkl (line 60) | def parse_raw_pkl(pkl_path, to_50hz=True):

FILE: eval/GVHMR/hmr4d/dataset/imgfeat_motion/base_dataset.py
  class ImgfeatMotionDatasetBase (line 8) | class ImgfeatMotionDatasetBase(data.Dataset):
    method __init__ (line 9) | def __init__(self):
    method __len__ (line 14) | def __len__(self):
    method _load_dataset (line 17) | def _load_dataset(self):
    method _get_idx2meta (line 20) | def _get_idx2meta(self):
    method _load_data (line 23) | def _load_data(self, idx):
    method _process_data (line 26) | def _process_data(self, data, idx):
    method __getitem__ (line 29) | def __getitem__(self, idx):

FILE: eval/GVHMR/hmr4d/dataset/pure_motion/amass.py
  class AmassDataset (line 16) | class AmassDataset(BaseDataset):
    method __init__ (line 17) | def __init__(
    method _load_dataset (line 34) | def _load_dataset(self):
    method _get_idx2meta (line 54) | def _get_idx2meta(self):
    method _load_data (line 76) | def _load_data(self, idx):

FILE: eval/GVHMR/hmr4d/dataset/pure_motion/base_dataset.py
  class BaseDataset (line 16) | class BaseDataset(Dataset):
    method __init__ (line 17) | def __init__(self, cam_augmentation, limit_size=None):
    method _load_dataset (line 27) | def _load_dataset(self):
    method _get_idx2meta (line 30) | def _get_idx2meta(self):
    method __len__ (line 34) | def __len__(self):
    method _load_data (line 39) | def _load_data(self, idx):
    method _process_data (line 42) | def _process_data(self, data, idx):
    method __getitem__ (line 179) | def __getitem__(self, idx):

FILE: eval/GVHMR/hmr4d/dataset/pure_motion/cam_traj_utils.py
  function noisy_interpolation (line 21) | def noisy_interpolation(x, length, step_noise_perc=0.2):
  function noisy_impluse_interpolation (line 44) | def noisy_impluse_interpolation(data1, data2, step_noise_perc=0.2):
  function create_camera (line 62) | def create_camera(w_root, cfg):
  function create_rotation_move (line 113) | def create_rotation_move(R, length, r_xyz_w_std=[np.pi / 8, np.pi / 4, n...
  function create_translation_move (line 134) | def create_translation_move(R_w2c, t_w2c, length, t_xyz_w_std=[1.0, 0.25...
  class CameraAugmentorV11 (line 151) | class CameraAugmentorV11:
    method __init__ (line 191) | def __init__(self):
    method create_rotation_track (line 196) | def create_rotation_track(self, cam_mat, root, rx_factor=1.0, ry_facto...
    method create_translation_track (line 220) | def create_translation_track(self, cam_mat, root, t_factor=1.0, tz_bia...
    method add_stepnoise (line 242) | def add_stepnoise(self, R, T):
    method __call__ (line 333) | def __call__(self, w_j3d, length=120):

FILE: eval/GVHMR/hmr4d/dataset/pure_motion/utils.py
  function aa_to_r6d (line 12) | def aa_to_r6d(x):
  function r6d_to_aa (line 16) | def r6d_to_aa(x):
  function interpolate_smpl_params (line 20) | def interpolate_smpl_params(smpl_params, tgt_len):
  function rotate_around_axis (line 51) | def rotate_around_axis(global_orient, transl, axis="y"):
  function augment_betas (line 63) | def augment_betas(betas, std=0.1):

FILE: eval/GVHMR/hmr4d/dataset/rich/rich_motion_test.py
  class RichSmplFullSeqDataset (line 35) | class RichSmplFullSeqDataset(data.Dataset):
    method __init__ (line 36) | def __init__(self, vid_presets=None):
    method __len__ (line 68) | def __len__(self):
    method _load_data (line 71) | def _load_data(self, idx):
    method _process_data (line 120) | def _process_data(self, data):
    method __getitem__ (line 167) | def __getitem__(self, idx):
  function select_subset (line 173) | def select_subset(labels, vid_presets):

FILE: eval/GVHMR/hmr4d/dataset/rich/rich_utils.py
  function sample_idx2meta (line 12) | def sample_idx2meta(idx2meta, sample_interval):
  function remove_bbx_invisible_frame (line 27) | def remove_bbx_invisible_frame(idx2meta, img2gtbbx):
  function remove_extra_rules (line 44) | def remove_extra_rules(idx2meta):
  function compute_bbx (line 53) | def compute_bbx(dataset, data):
  function get_2d (line 82) | def get_2d(dataset, data):
  function squared_crop_and_resize (line 95) | def squared_crop_and_resize(dataset, img, bbx_lurb, dst_size=224, state=...
  function get_augmented_square_bbx (line 124) | def get_augmented_square_bbx(bbx_lurb, per_shift=0.1, per_zoomout=0.2, b...
  function get_squared_bbx_region_and_resize (line 152) | def get_squared_bbx_region_and_resize(frames, bbx_xys, dst_size=224):
  function extract_cam_xml (line 182) | def extract_cam_xml(xml_path="", dtype=torch.float32):
  function get_cam2params (line 198) | def get_cam2params(scene_info_root=None):
  function get_w2az_sahmr (line 223) | def get_w2az_sahmr():
  function has_multi_persons (line 235) | def has_multi_persons(seq_name):
  function parse_seqname_info (line 243) | def parse_seqname_info(skip_multi_persons=True):
  function get_seqnames_of_split (line 269) | def get_seqnames_of_split(splits=["train"], skip_multi_persons=True):
  function get_seqname_to_imgrange (line 284) | def get_seqname_to_imgrange():
  function get_img_key (line 306) | def get_img_key(seq_name, cam_id, f_id):
  function get_seq_cam_fn (line 312) | def get_seq_cam_fn(img_root, seq_name, cam_id):
  function get_img_fn (line 322) | def get_img_fn(img_root, seq_name, cam_id, f_id):
  function get_cam_key_wham_vid (line 336) | def get_cam_key_wham_vid(vid):
  function get_K_wham_vid (line 344) | def get_K_wham_vid(vid):
  class RichVid2Tc2az (line 351) | class RichVid2Tc2az:
    method __init__ (line 352) | def __init__(self) -> None:
    method __call__ (line 358) | def __call__(self, vid):
    method get_T_w2az (line 366) | def get_T_w2az(self, vid):

FILE: eval/GVHMR/hmr4d/dataset/threedpw/threedpw_motion_test.py
  class ThreedpwSmplFullSeqDataset (line 17) | class ThreedpwSmplFullSeqDataset(data.Dataset):
    method __init__ (line 18) | def __init__(self, flip_test=False, skip_invalid=False):
    method __len__ (line 42) | def __len__(self):
    method _load_data (line 45) | def _load_data(self, idx):
    method _process_data (line 118) | def _process_data(self, data):
    method __getitem__ (line 137) | def __getitem__(self, idx):

FILE: eval/GVHMR/hmr4d/dataset/threedpw/threedpw_motion_train.py
  class ThreedpwSmplDataset (line 20) | class ThreedpwSmplDataset(ImgfeatMotionDatasetBase):
    method __init__ (line 21) | def __init__(self):
    method _load_dataset (line 31) | def _load_dataset(self):
    method _get_idx2meta (line 47) | def _get_idx2meta(self):
    method _load_data (line 64) | def _load_data(self, idx):
    method _process_data (line 98) | def _process_data(self, data, idx):

FILE: eval/GVHMR/hmr4d/dataset/threedpw/utils.py
  function read_raw_pkl (line 12) | def read_raw_pkl(pkl_path):
  function load_and_convert_wham_pth (line 48) | def load_and_convert_wham_pth(pth):
  function na_cam_param_to_K_fullimg (line 77) | def na_cam_param_to_K_fullimg(cam_param):

FILE: eval/GVHMR/hmr4d/model/common_utils/scheduler.py
  class WarmupMultiStepLR (line 5) | class WarmupMultiStepLR(torch.optim.lr_scheduler.LRScheduler):
    method __init__ (line 6) | def __init__(self, optimizer, milestones, warmup=0, gamma=0.1, last_ep...
    method get_lr (line 14) | def get_lr(self):

FILE: eval/GVHMR/hmr4d/model/common_utils/scheduler_cfg.py
  function epoch_half_by (line 10) | def epoch_half_by(milestones=[100, 200, 300]):
  function warmup_epoch_half_by (line 31) | def warmup_epoch_half_by(warmup=10, milestones=[100, 200, 300]):

FILE: eval/GVHMR/hmr4d/model/gvhmr/callbacks/metric_3dpw.py
  class MetricMocap (line 19) | class MetricMocap(pl.Callback):
    method __init__ (line 20) | def __init__(self):
    method on_predict_batch_end (line 46) | def on_predict_batch_end(self, trainer, pl_module, outputs, batch, bat...
    method on_predict_epoch_end (line 136) | def on_predict_epoch_end(self, trainer, pl_module):

FILE: eval/GVHMR/hmr4d/model/gvhmr/callbacks/metric_emdb.py
  class MetricMocap (line 32) | class MetricMocap(pl.Callback):
    method __init__ (line 33) | def __init__(self, emdb_split=1):
    method on_predict_batch_end (line 76) | def on_predict_batch_end(self, trainer, pl_module, outputs, batch, bat...
    method on_predict_epoch_end (line 267) | def on_predict_epoch_end(self, trainer, pl_module):

FILE: eval/GVHMR/hmr4d/model/gvhmr/callbacks/metric_rich.py
  class MetricMocap (line 36) | class MetricMocap(pl.Callback):
    method __init__ (line 37) | def __init__(self):
    method on_predict_batch_end (line 81) | def on_predict_batch_end(self, trainer, pl_module, outputs, batch, bat...
    method on_predict_epoch_end (line 339) | def on_predict_epoch_end(self, trainer, pl_module):

FILE: eval/GVHMR/hmr4d/model/gvhmr/gvhmr_pl.py
  class GvhmrPL (line 29) | class GvhmrPL(pl.LightningModule):
    method __init__ (line 30) | def __init__(
    method training_step (line 51) | def training_step(self, batch, batch_idx):
    method validation_step (line 158) | def validation_step(self, batch, batch_idx, dataloader_idx=0):
    method configure_optimizers (line 277) | def configure_optimizers(self):
    method on_save_checkpoint (line 292) | def on_save_checkpoint(self, checkpoint) -> None:
    method load_pretrained_model (line 299) | def load_pretrained_model(self, ckpt_path):

FILE: eval/GVHMR/hmr4d/model/gvhmr/gvhmr_pl_demo.py
  class DemoPL (line 10) | class DemoPL(pl.LightningModule):
    method __init__ (line 11) | def __init__(self, pipeline):
    method predict (line 16) | def predict(self, data, static_cam=False):
    method load_pretrained_model (line 48) | def load_pretrained_model(self, ckpt_path):

FILE: eval/GVHMR/hmr4d/model/gvhmr/pipeline/gvhmr_pipeline.py
  class Pipeline (line 35) | class Pipeline(nn.Module):
    method __init__ (line 36) | def __init__(self, args, args_denoiser3d, **kwargs):
    method forward (line 54) | def forward(self, inputs, train=False, postproc=False, static_cam=False):
  function randomly_set_null_condition (line 138) | def randomly_set_null_condition(f_condition, uncond_prob=0.1):
  function compute_extra_incam_loss (line 150) | def compute_extra_incam_loss(inputs, outputs, ppl):
  function compute_extra_global_loss (line 279) | def compute_extra_global_loss(inputs, outputs, ppl):
  function get_smpl_params_w_Rt_v2 (line 322) | def get_smpl_params_w_Rt_v2(

FILE: eval/GVHMR/hmr4d/model/gvhmr/utils/endecoder.py
  class EnDecoder (line 20) | class EnDecoder(nn.Module):
    method __init__ (line 21) | def __init__(self, stats_name="DEFAULT_01", noise_pose_k=10):
    method get_noisyobs (line 38) | def get_noisyobs(self, data, return_type="r6d"):
    method normalize_body_pose_r6d (line 57) | def normalize_body_pose_r6d(self, body_pose_r6d):
    method fk_v2 (line 66) | def fk_v2(self, body_pose, betas, global_orient=None, transl=None, get...
    method get_local_pos (line 96) | def get_local_pos(self, betas):
    method encode (line 102) | def encode(self, inputs):
    method encode_translw (line 139) | def encode_translw(self, inputs):
    method decode_translw (line 158) | def decode_translw(self, x_norm):
    method decode (line 161) | def decode(self, x_norm):

FILE: eval/GVHMR/hmr4d/model/gvhmr/utils/postprocess.py
  function pp_static_joint (line 20) | def pp_static_joint(outputs, endecoder: EnDecoder):
  function pp_static_joint_cam (line 62) | def pp_static_joint_cam(outputs, endecoder: EnDecoder):
  function process_ik (line 122) | def process_ik(outputs, endecoder):

FILE: eval/GVHMR/hmr4d/model/gvhmr/utils/stats_compose.py
  function compose (line 190) | def compose(targets, sources):

FILE: eval/GVHMR/hmr4d/network/base_arch/embeddings/rotary_embedding.py
  function rotate_half (line 7) | def rotate_half(x):
  function apply_rotary_emb (line 15) | def apply_rotary_emb(freqs, t, start_index=0, scale=1.0, seq_dim=-2):
  function get_encoding (line 32) | def get_encoding(d_model, max_seq_len=4096):
  class ROPE (line 41) | class ROPE(nn.Module):
    method __init__ (line 44) | def __init__(self, d_model, max_seq_len=4096):
    method rotate_queries_or_keys (line 53) | def rotate_queries_or_keys(self, x):

FILE: eval/GVHMR/hmr4d/network/base_arch/transformer/encoder_rope.py
  class RoPEAttention (line 11) | class RoPEAttention(nn.Module):
    method __init__ (line 12) | def __init__(self, embed_dim, num_heads, dropout=0.1):
    method forward (line 26) | def forward(self, x, attn_mask=None, key_padding_mask=None):
  class EncoderRoPEBlock (line 56) | class EncoderRoPEBlock(nn.Module):
    method __init__ (line 57) | def __init__(self, hidden_size, num_heads, mlp_ratio=4.0, dropout=0.1,...
    method forward (line 73) | def forward(self, x, attn_mask=None, tgt_key_padding_mask=None):
    method _sa_block (line 80) | def _sa_block(self, x, attn_mask=None, key_padding_mask=None):

FILE: eval/GVHMR/hmr4d/network/base_arch/transformer/layer.py
  function zero_module (line 6) | def zero_module(module):

FILE: eval/GVHMR/hmr4d/network/gvhmr/relative_transformer.py
  class NetworkEncoderRoPE (line 14) | class NetworkEncoderRoPE(nn.Module):
    method __init__ (line 15) | def __init__(
    method _build_condition_embedder (line 87) | def _build_condition_embedder(self):
    method forward (line 109) | def forward(self, length, obs=None, f_cliffcam=None, f_cam_angvel=None...

FILE: eval/GVHMR/hmr4d/network/hmr2/__init__.py
  function load_hmr2 (line 10) | def load_hmr2(checkpoint_path=HMR2A_CKPT):

FILE: eval/GVHMR/hmr4d/network/hmr2/components/pose_transformer.py
  function exists (line 17) | def exists(val):
  function default (line 21) | def default(val, d):
  class PreNorm (line 27) | class PreNorm(nn.Module):
    method __init__ (line 28) | def __init__(self, dim: int, fn: Callable, norm: str = "layer", norm_c...
    method forward (line 33) | def forward(self, x: torch.Tensor, *args, **kwargs):
  class FeedForward (line 40) | class FeedForward(nn.Module):
    method __init__ (line 41) | def __init__(self, dim, hidden_dim, dropout=0.0):
    method forward (line 51) | def forward(self, x):
  class Attention (line 55) | class Attention(nn.Module):
    method __init__ (line 56) | def __init__(self, dim, heads=8, dim_head=64, dropout=0.0):
    method forward (line 75) | def forward(self, x):
  class CrossAttention (line 89) | class CrossAttention(nn.Module):
    method __init__ (line 90) | def __init__(self, dim, context_dim=None, heads=8, dim_head=64, dropou...
    method forward (line 111) | def forward(self, x, context=None):
  class Transformer (line 127) | class Transformer(nn.Module):
    method __init__ (line 128) | def __init__(
    method forward (line 153) | def forward(self, x: torch.Tensor, *args):
  class TransformerCrossAttn (line 160) | class TransformerCrossAttn(nn.Module):
    method __init__ (line 161) | def __init__(
    method forward (line 191) | def forward(self, x: torch.Tensor, *args, context=None, context_list=N...
  class DropTokenDropout (line 204) | class DropTokenDropout(nn.Module):
    method __init__ (line 205) | def __init__(self, p: float = 0.1):
    method forward (line 213) | def forward(self, x: torch.Tensor):
  class ZeroTokenDropout (line 223) | class ZeroTokenDropout(nn.Module):
    method __init__ (line 224) | def __init__(self, p: float = 0.1):
    method forward (line 232) | def forward(self, x: torch.Tensor):
  class TransformerEncoder (line 241) | class TransformerEncoder(nn.Module):
    method __init__ (line 242) | def __init__(
    method forward (line 283) | def forward(self, inp: torch.Tensor, *args, **kwargs):
  class TransformerDecoder (line 301) | class TransformerDecoder(nn.Module):
    method __init__ (line 302) | def __init__(
    method forward (line 349) | def forward(self, inp: torch.Tensor, *args, context=None, context_list...

FILE: eval/GVHMR/hmr4d/network/hmr2/components/t_cond_mlp.py
  class AdaptiveLayerNorm1D (line 7) | class AdaptiveLayerNorm1D(torch.nn.Module):
    method __init__ (line 8) | def __init__(self, data_dim: int, norm_cond_dim: int):
    method forward (line 21) | def forward(self, x: torch.Tensor, t: torch.Tensor) -> torch.Tensor:
  class SequentialCond (line 36) | class SequentialCond(torch.nn.Sequential):
    method forward (line 37) | def forward(self, input, *args, **kwargs):
  function normalization_layer (line 48) | def normalization_layer(norm: Optional[str], dim: int, norm_cond_dim: in...
  function linear_norm_activ_dropout (line 62) | def linear_norm_activ_dropout(
  function create_simple_mlp (line 81) | def create_simple_mlp(
  class ResidualMLPBlock (line 104) | class ResidualMLPBlock(torch.nn.Module):
    method __init__ (line 105) | def __init__(
    method forward (line 135) | def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
  class ResidualMLP (line 139) | class ResidualMLP(torch.nn.Module):
    method __init__ (line 140) | def __init__(
    method forward (line 176) | def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
  class FrequencyEmbedder (line 180) | class FrequencyEmbedder(torch.nn.Module):
    method __init__ (line 181) | def __init__(self, num_frequencies, max_freq_log2):
    method forward (line 186) | def forward(self, x):

FILE: eval/GVHMR/hmr4d/network/hmr2/configs/__init__.py
  function to_lower (line 10) | def to_lower(x: Dict) -> Dict:
  function default_config (line 71) | def default_config() -> CN:
  function dataset_config (line 80) | def dataset_config(name="datasets_tar.yaml") -> CN:
  function dataset_eval_config (line 93) | def dataset_eval_config() -> CN:
  function get_config (line 97) | def get_config(config_file: str, merge: bool = True) -> CN:

FILE: eval/GVHMR/hmr4d/network/hmr2/hmr2.py
  class HMR2 (line 11) | class HMR2(pl.LightningModule):
    method __init__ (line 12) | def __init__(self, cfg: CfgNode):
    method forward (line 29) | def forward(self, batch, feat_mode=True):

FILE: eval/GVHMR/hmr4d/network/hmr2/smpl_head.py
  class SMPLTransformerDecoderHead (line 11) | class SMPLTransformerDecoderHead(nn.Module):
    method __init__ (line 14) | def __init__(self, cfg):
    method forward (line 48) | def forward(self, x, only_return_token_out=False):

FILE: eval/GVHMR/hmr4d/network/hmr2/utils/geometry.py
  function aa_to_rotmat (line 6) | def aa_to_rotmat(theta: torch.Tensor):
  function quat_to_rotmat (line 25) | def quat_to_rotmat(quat: torch.Tensor) -> torch.Tensor:
  function rot6d_to_rotmat (line 60) | def rot6d_to_rotmat(x: torch.Tensor) -> torch.Tensor:
  function perspective_projection (line 78) | def perspective_projection(

FILE: eval/GVHMR/hmr4d/network/hmr2/utils/preproc.py
  function expand_to_aspect_ratio (line 10) | def expand_to_aspect_ratio(input_shape, target_aspect_ratio=[192, 256]):
  function crop_and_resize (line 32) | def crop_and_resize(img, bbx_xy, bbx_s, dst_size=256, enlarge_ratio=1.2):

FILE: eval/GVHMR/hmr4d/network/hmr2/utils/smpl_wrapper.py
  class SMPL (line 10) | class SMPL(smplx.SMPLLayer):
    method __init__ (line 11) | def __init__(self, *args, joint_regressor_extra: Optional[str] = None,...
    method forward (line 29) | def forward(self, *args, **kwargs) -> SMPLOutput:

FILE: eval/GVHMR/hmr4d/network/hmr2/vit.py
  function vit (line 12) | def vit(cfg):
  function get_abs_pos (line 26) | def get_abs_pos(abs_pos, h, w, ori_h, ori_w, has_cls_token=True):
  class DropPath (line 59) | class DropPath(nn.Module):
    method __init__ (line 62) | def __init__(self, drop_prob=None):
    method forward (line 66) | def forward(self, x):
    method extra_repr (line 69) | def extra_repr(self):
  class Mlp (line 72) | class Mlp(nn.Module):
    method __init__ (line 73) | def __init__(self, in_features, hidden_features=None, out_features=Non...
    method forward (line 82) | def forward(self, x):
  class Attention (line 89) | class Attention(nn.Module):
    method __init__ (line 90) | def __init__(
    method forward (line 110) | def forward(self, x):
  class Block (line 128) | class Block(nn.Module):
    method __init__ (line 130) | def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_sc...
    method forward (line 148) | def forward(self, x):
  class PatchEmbed (line 154) | class PatchEmbed(nn.Module):
    method __init__ (line 157) | def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=...
    method forward (line 170) | def forward(self, x, **kwargs):
  class HybridEmbed (line 179) | class HybridEmbed(nn.Module):
    method __init__ (line 183) | def __init__(self, backbone, img_size=224, feature_size=None, in_chans...
    method forward (line 204) | def forward(self, x):
  class ViT (line 211) | class ViT(nn.Module):
    method __init__ (line 213) | def __init__(self,
    method _freeze_stages (line 259) | def _freeze_stages(self):
    method init_weights (line 296) | def init_weights(self):
    method get_num_layers (line 313) | def get_num_layers(self):
    method no_weight_decay (line 317) | def no_weight_decay(self):
    method forward_features (line 320) | def forward_features(self, x):
    method forward (line 341) | def forward(self, x):
    method train (line 345) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/body_model/body_model.py
  class BodyModel (line 12) | class BodyModel(nn.Module):
    method __init__ (line 18) | def __init__(self,
    method forward (line 77) | def forward(self, root_orient=None, pose_body=None, pose_hand=None, po...
    method forward_motion (line 119) | def forward_motion(self, **kwargs):

FILE: eval/GVHMR/hmr4d/utils/body_model/body_model_smplh.py
  class BodyModelSMPLH (line 15) | class BodyModelSMPLH(nn.Module):
    method __init__ (line 18) | def __init__(self, model_path, **kwargs):
    method forward (line 37) | def forward(
    method get_skeleton (line 95) | def get_skeleton(self, betas):

FILE: eval/GVHMR/hmr4d/utils/body_model/body_model_smplx.py
  class BodyModelSMPLX (line 19) | class BodyModelSMPLX(nn.Module):
    method __init__ (line 22) | def __init__(self, model_path, **kwargs):
    method forward (line 39) | def forward(
    method get_skeleton (line 119) | def get_skeleton(self, betas):
    method forward_bfc (line 124) | def forward_bfc(self, **kwargs):

FILE: eval/GVHMR/hmr4d/utils/body_model/min_lbs.py
  class MinimalLBS (line 10) | class MinimalLBS(nn.Module):
    method __init__ (line 11) | def __init__(self, sp_ids, bm_dir='models/smplh', num_betas=16, model_...
    method load_struct_on_sp (line 20) | def load_struct_on_sp(self, bm_path, prefix='m'):
    method forward (line 51) | def forward(self, root_orient=None, pose_body=None, trans=None, betas=...

FILE: eval/GVHMR/hmr4d/utils/body_model/smpl_lite.py
  class SmplLite (line 16) | class SmplLite(nn.Module):
    method __init__ (line 17) | def __init__(
    method register_smpl_buffers (line 39) | def register_smpl_buffers(self, data_struct, num_betas):
    method register_fast_skeleton_computing_buffers (line 66) | def register_fast_skeleton_computing_buffers(self):
    method get_skeleton (line 73) | def get_skeleton(self, betas):
    method forward (line 76) | def forward(
  class SmplxLiteJ24 (line 119) | class SmplxLiteJ24(SmplLite):
    method __init__ (line 120) | def __init__(self, **kwargs):
    method forward (line 138) | def forward(self, body_pose, betas, global_orient, transl):

FILE: eval/GVHMR/hmr4d/utils/body_model/smplx_lite.py
  class SmplxLite (line 14) | class SmplxLite(nn.Module):
    method __init__ (line 15) | def __init__(
    method register_smpl_buffers (line 50) | def register_smpl_buffers(self, data_struct, num_betas):
    method register_smplh_buffers (line 77) | def register_smplh_buffers(self, data_struct, num_pca_comps, flat_hand...
    method register_smplx_buffers (line 93) | def register_smplx_buffers(self, data_struct):
    method register_fast_skeleton_computing_buffers (line 98) | def register_fast_skeleton_computing_buffers(self):
    method get_skeleton (line 105) | def get_skeleton(self, betas):
    method forward (line 108) | def forward(
  class SmplxLiteCoco17 (line 165) | class SmplxLiteCoco17(SmplxLite):
    method __init__ (line 168) | def __init__(self, **kwargs):
    method forward (line 188) | def forward(self, body_pose, betas, global_orient, transl):
  class SmplxLiteV437Coco17 (line 196) | class SmplxLiteV437Coco17(SmplxLite):
    method __init__ (line 197) | def __init__(self, **kwargs):
    method forward (line 222) | def forward(self, body_pose, betas, global_orient, transl):
  class SmplxLiteSmplN24 (line 236) | class SmplxLiteSmplN24(SmplxLite):
    method __init__ (line 239) | def __init__(self, **kwargs):
    method forward (line 259) | def forward(self, body_pose, betas, global_orient, transl):
  function batch_rigid_transform_v2 (line 267) | def batch_rigid_transform_v2(rot_mats, joints, parents):
  function sync_time (line 300) | def sync_time():

FILE: eval/GVHMR/hmr4d/utils/body_model/utils.py
  function smpl_to_openpose (line 120) | def smpl_to_openpose(model_type='smplx', use_hands=True, use_face=True,

FILE: eval/GVHMR/hmr4d/utils/callbacks/prog_bar.py
  function format_num (line 21) | def format_num(n):
  function convert_kwargs_to_str (line 27) | def convert_kwargs_to_str(**kwargs):
  function convert_t_to_str (line 47) | def convert_t_to_str(t):
  class MyTQDMProgressBar (line 58) | class MyTQDMProgressBar(TQDMProgressBar, pl.Callback):
    method init_train_tqdm (line 59) | def init_train_tqdm(self):
    method on_train_batch_end (line 72) | def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch...
  class ProgressReporter (line 95) | class ProgressReporter(ProgressBar, pl.Callback):
    method __init__ (line 96) | def __init__(
    method disable (line 115) | def disable(self):
    method setup (line 118) | def setup(self, trainer: pl.Trainer, pl_module: pl.LightningModule, st...
    method print (line 136) | def print(self, *args: Any, **kwargs: Any) -> None:
    method get_metrics (line 139) | def get_metrics(self, trainer: pl.Trainer, pl_module: pl.LightningModu...
    method _should_update (line 145) | def _should_update(self, n_finished: int, total: int) -> bool:
    method on_train_epoch_start (line 157) | def on_train_epoch_start(self, trainer: "pl.Trainer", *_: Any) -> None:
    method on_train_batch_end (line 165) | def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch...
    method on_train_epoch_end (line 218) | def on_train_epoch_end(self, trainer: pl.Trainer, pl_module: pl.Lightn...
    method on_validation_epoch_start (line 245) | def on_validation_epoch_start(self, trainer, pl_module):
    method on_validation_batch_end (line 249) | def on_validation_batch_end(self, trainer, pl_module, outputs, batch, ...
    method on_validation_epoch_end (line 272) | def on_validation_epoch_end(self, trainer: pl.Trainer, pl_module: pl.L...
  class EmojiProgressReporter (line 277) | class EmojiProgressReporter(ProgressBar, pl.Callback):
    method __init__ (line 278) | def __init__(
    method disable (line 297) | def disable(self):
    method setup (line 300) | def setup(self, trainer: pl.Trainer, pl_module: pl.LightningModule, st...
    method print (line 312) | def print(self, *args: Any, **kwargs: Any):
    method get_metrics (line 315) | def get_metrics(self, trainer: pl.Trainer, pl_module: pl.LightningModu...
    method _should_log_batch (line 321) | def _should_log_batch(self, n: int) -> bool:
    method _should_log_epoch (line 330) | def _should_log_epoch(self, n: int) -> bool:
    method timestamp_delta_to_str (line 336) | def timestamp_delta_to_str(self, timestamp_delta: float):
    method on_train_batch_start (line 357) | def on_train_batch_start(self, trainer: pl.Trainer, pl_module: pl.Ligh...
    method on_train_batch_end (line 364) | def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch...
    method on_train_epoch_start (line 391) | def on_train_epoch_start(self, trainer: pl.Trainer, pl_module: pl.Ligh...
    method on_train_epoch_end (line 399) | def on_train_epoch_end(self, trainer: pl.Trainer, pl_module: pl.Lightn...

FILE: eval/GVHMR/hmr4d/utils/callbacks/simple_ckpt_saver.py
  class SimpleCkptSaver (line 11) | class SimpleCkptSaver(Checkpoint):
    method __init__ (line 17) | def __init__(
    method on_train_epoch_end (line 40) | def on_train_epoch_end(self, trainer, pl_module):

FILE: eval/GVHMR/hmr4d/utils/callbacks/train_speed_timer.py
  class TrainSpeedTimer (line 9) | class TrainSpeedTimer(pl.Callback):
    method __init__ (line 10) | def __init__(self, N_avg=5):
    method on_train_batch_start (line 25) | def on_train_batch_start(self, trainer, pl_module, batch, batch_idx):
    method on_train_batch_end (line 43) | def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch...
    method on_train_epoch_end (line 60) | def on_train_epoch_end(self, trainer, pl_module):

FILE: eval/GVHMR/hmr4d/utils/comm/gather.py
  function get_world_size (line 22) | def get_world_size() -> int:
  function get_rank (line 30) | def get_rank() -> int:
  function get_local_rank (line 38) | def get_local_rank() -> int:
  function get_local_size (line 51) | def get_local_size() -> int:
  function is_main_process (line 64) | def is_main_process() -> bool:
  function synchronize (line 68) | def synchronize():
  function _get_global_gloo_group (line 84) | def _get_global_gloo_group():
  function _serialize_to_tensor (line 95) | def _serialize_to_tensor(data, group):
  function _pad_to_largest_tensor (line 113) | def _pad_to_largest_tensor(tensor, group):
  function all_gather (line 137) | def all_gather(data, group=None):
  function gather (line 173) | def gather(data, dst=0, group=None):
  function shared_random_seed (line 214) | def shared_random_seed():
  function reduce_dict (line 228) | def reduce_dict(input_dict, average=True):

FILE: eval/GVHMR/hmr4d/utils/eval/eval_utils.py
  function compute_camcoord_metrics (line 6) | def compute_camcoord_metrics(batch, pelvis_idxs=[1, 2], fps=30, mask=None):
  function compute_global_metrics (line 60) | def compute_global_metrics(batch, mask=None):
  function compute_camcoord_perjoint_metrics (line 138) | def compute_camcoord_perjoint_metrics(batch, pelvis_idxs=[1, 2]):
  function compute_jpe (line 176) | def compute_jpe(S1, S2):
  function compute_perjoint_jpe (line 180) | def compute_perjoint_jpe(S1, S2):
  function batch_align_by_pelvis (line 184) | def batch_align_by_pelvis(data_list, pelvis_idxs=[1, 2]):
  function batch_compute_similarity_transform_torch (line 206) | def batch_compute_similarity_transform_torch(S1, S2):
  function compute_error_accel (line 260) | def compute_error_accel(joints_gt, joints_pred, valid_mask=None, fps=None):
  function compute_rte (line 294) | def compute_rte(target_trans, pred_trans):
  function compute_jitter (line 313) | def compute_jitter(joints, fps=30):
  function compute_foot_sliding (line 329) | def compute_foot_sliding(target_verts, pred_verts, thr=1e-2):
  function convert_joints22_to_24 (line 357) | def convert_joints22_to_24(joints22, ratio2220=0.3438, ratio2321=0.3345):
  function align_pcl (line 365) | def align_pcl(Y, X, weight=None, fixed_scale=False):
  function global_align_joints (line 413) | def global_align_joints(gt_joints, pred_joints):
  function first_align_joints (line 423) | def first_align_joints(gt_joints, pred_joints):
  function rearrange_by_mask (line 435) | def rearrange_by_mask(x, mask):
  function as_np_array (line 451) | def as_np_array(d):

FILE: eval/GVHMR/hmr4d/utils/geo/augment_noisy_pose.py
  function gaussian_augment (line 11) | def gaussian_augment(body_pose, std_angle=10.0, to_R=True):
  function get_jitter (line 53) | def get_jitter(shape=(8, 120), s_jittering=5e-2):
  function get_jitter_cuda (line 65) | def get_jitter_cuda(shape=(8, 120), s_jittering=5e-2):
  function get_lfhp (line 73) | def get_lfhp(shape=(8, 120), s_peak=3e-1, s_peak_mask=5e-3):
  function get_lfhp_cuda (line 87) | def get_lfhp_cuda(shape=(8, 120), s_peak=3e-1, s_peak_mask=5e-3):
  function get_bias (line 101) | def get_bias(shape=(8, 120), s_bias=1e-1):
  function get_bias_cuda (line 109) | def get_bias_cuda(shape=(8, 120), s_bias=1e-1):
  function get_wham_aug_kp3d (line 119) | def get_wham_aug_kp3d(shape=(8, 120)):
  function get_visible_mask (line 125) | def get_visible_mask(shape=(8, 120), s_mask=0.03):
  function get_invisible_legs_mask (line 144) | def get_invisible_legs_mask(shape, s_mask=0.03):
  function randomly_occlude_lower_half (line 159) | def randomly_occlude_lower_half(i_x2d, s_mask=0.03):
  function randomly_modify_hands_legs (line 182) | def randomly_modify_hands_legs(j3d):

FILE: eval/GVHMR/hmr4d/utils/geo/flip_utils.py
  function flip_heatmap_coco17 (line 5) | def flip_heatmap_coco17(output_flipped):
  function flip_bbx_xys (line 22) | def flip_bbx_xys(bbx_xys, w):
  function flip_kp2d_coco17 (line 31) | def flip_kp2d_coco17(kp2d, w):
  function flip_smplx_params (line 40) | def flip_smplx_params(smplx_params):
  function avg_smplx_aa (line 69) | def avg_smplx_aa(aa1, aa2):

FILE: eval/GVHMR/hmr4d/utils/geo/hmr_cam.py
  function estimate_focal_length (line 6) | def estimate_focal_length(img_w, img_h):
  function estimate_K (line 10) | def estimate_K(img_w, img_h):
  function convert_K_to_K4 (line 20) | def convert_K_to_K4(K):
  function convert_f_to_K (line 25) | def convert_f_to_K(focal_length, img_w, img_h):
  function resize_K (line 34) | def resize_K(K, f=0.5):
  function create_camera_sensor (line 40) | def create_camera_sensor(width=None, height=None, f_fullframe=None):
  function convert_xys_to_cliff_cam_wham (line 72) | def convert_xys_to_cliff_cam_wham(xys, res):
  function compute_bbox_info_bedlam (line 103) | def compute_bbox_info_bedlam(bbx_xys, K_fullimg):
  function compute_transl_full_cam (line 124) | def compute_transl_full_cam(pred_cam, bbx_xys, K_fullimg):
  function get_a_pred_cam (line 139) | def get_a_pred_cam(transl, bbx_xys, K_fullimg):
  function project_to_bi01 (line 156) | def project_to_bi01(points, bbx_xys, K_fullimg):
  function perspective_projection (line 169) | def perspective_projection(points, K):
  function normalize_kp2d (line 180) | def normalize_kp2d(obs_kp2d, bbx_xys, clamp_scale_min=False):
  function get_bbx_xys (line 210) | def get_bbx_xys(i_j2d, bbx_ratio=[192, 256], do_augment=False, base_enla...
  function safely_render_x3d_K (line 254) | def safely_render_x3d_K(x3d, K_fullimg, thr):
  function get_bbx_xys_from_xyxy (line 285) | def get_bbx_xys_from_xyxy(bbx_xyxy, base_enlarge=1.2):
  function bbx_xyxy_from_x (line 298) | def bbx_xyxy_from_x(p2d):
  function bbx_xyxy_from_masked_x (line 316) | def bbx_xyxy_from_masked_x(p2d, mask):
  function bbx_xyxy_ratio (line 349) | def bbx_xyxy_ratio(xyxy1, xyxy2):
  function get_mesh_in_fov_category (line 365) | def get_mesh_in_fov_category(mask):
  function get_infov_mask (line 385) | def get_infov_mask(p2d, w_real, h_real):

FILE: eval/GVHMR/hmr4d/utils/geo/hmr_global.py
  function get_R_c2gv (line 7) | def get_R_c2gv(R_w2c, axis_gravity_in_w=[0, 0, -1]):
  function get_tgtcoord_rootparam (line 40) | def get_tgtcoord_rootparam(global_orient, transl, gravity_vec=None, tgt_...
  function get_c_rootparam (line 79) | def get_c_rootparam(global_orient, transl, T_w2c, offset):
  function get_T_w2c_from_wcparams (line 105) | def get_T_w2c_from_wcparams(global_orient_w, transl_w, global_orient_c, ...
  function get_local_transl_vel (line 132) | def get_local_transl_vel(transl, global_orient):
  function rollout_local_transl_vel (line 151) | def rollout_local_transl_vel(local_transl_vel, global_orient, transl_0=N...
  function get_local_transl_vel_alignhead (line 174) | def get_local_transl_vel_alignhead(transl, global_orient):
  function rollout_local_transl_vel_alignhead (line 189) | def rollout_local_transl_vel_alignhead(local_transl_vel_alignhead, globa...
  function get_local_transl_vel_alignhead_absy (line 204) | def get_local_transl_vel_alignhead_absy(transl, global_orient):
  function rollout_local_transl_vel_alignhead_absy (line 224) | def rollout_local_transl_vel_alignhead_absy(local_transl_vel_alignhead_a...
  function get_local_transl_vel_alignhead_absgy (line 254) | def get_local_transl_vel_alignhead_absgy(transl, global_orient):
  function rollout_local_transl_vel_alignhead_absgy (line 274) | def rollout_local_transl_vel_alignhead_absgy(local_transl_vel_alignhead_...
  function rollout_vel (line 312) | def rollout_vel(vel, transl_0=None):
  function get_static_joint_mask (line 331) | def get_static_joint_mask(w_j3d, vel_thr=0.25, smooth=False, repeat_last...

FILE: eval/GVHMR/hmr4d/utils/geo/quaternion.py
  function qinv (line 20) | def qinv(q):
  function qinv_np (line 27) | def qinv_np(q):
  function qnormalize (line 32) | def qnormalize(q):
  function qmul (line 37) | def qmul(q, r):
  function qrot (line 58) | def qrot(q, v):
  function qeuler (line 80) | def qeuler(q, order, epsilon=0, deg=True):
  function qmul_np (line 133) | def qmul_np(q, r):
  function qrot_np (line 139) | def qrot_np(q, v):
  function qeuler_np (line 145) | def qeuler_np(q, order, epsilon=0, use_gpu=False):
  function qfix (line 154) | def qfix(q):
  function euler2quat (line 174) | def euler2quat(e, order, deg=True):
  function expmap_to_quaternion (line 219) | def expmap_to_quaternion(e):
  function euler_to_quaternion (line 238) | def euler_to_quaternion(e, order):
  function quaternion_to_matrix (line 279) | def quaternion_to_matrix(quaternions):
  function quaternion_to_matrix_np (line 308) | def quaternion_to_matrix_np(quaternions):
  function quaternion_to_cont6d_np (line 313) | def quaternion_to_cont6d_np(quaternions):
  function quaternion_to_cont6d (line 319) | def quaternion_to_cont6d(quaternions):
  function cont6d_to_matrix (line 325) | def cont6d_to_matrix(cont6d):
  function cont6d_to_matrix_np (line 344) | def cont6d_to_matrix_np(cont6d):
  function qpow (line 349) | def qpow(q0, t, dtype=torch.float):
  function qslerp (line 376) | def qslerp(q0, q1, t):
  function qbetween (line 393) | def qbetween(v0, v1):
  function qbetween_np (line 417) | def qbetween_np(v0, v1):
  function lerp (line 429) | def lerp(p0, p1, t):

FILE: eval/GVHMR/hmr4d/utils/geo/transforms.py
  function axis_rotate_to_matrix (line 4) | def axis_rotate_to_matrix(angle, axis="x"):

FILE: eval/GVHMR/hmr4d/utils/geo_transform.py
  function homo_points (line 15) | def homo_points(points):
  function apply_Ts_on_seq_points (line 24) | def apply_Ts_on_seq_points(points, Ts):
  function apply_T_on_points (line 36) | def apply_T_on_points(points, T):
  function T_transforms_points (line 47) | def T_transforms_points(T, points, pattern):
  function project_p2d (line 56) | def project_p2d(points, K=None, is_pinhole=True):
  function gen_uv_from_HW (line 83) | def gen_uv_from_HW(H, W, device="cpu"):
  function unproject_p2d (line 96) | def unproject_p2d(uv, z, K):
  function cvt_p2d_from_i_to_c (line 108) | def cvt_p2d_from_i_to_c(uv, K):
  function cvt_to_bi01_p2d (line 122) | def cvt_to_bi01_p2d(p2d, bbx_lurb):
  function cvt_from_bi01_p2d (line 135) | def cvt_from_bi01_p2d(bi01_p2d, bbx_lurb):
  function cvt_p2d_from_bi01_to_c (line 151) | def cvt_p2d_from_bi01_to_c(bi01, bbxs_lurb, Ks):
  function cvt_p2d_from_pm1_to_i (line 165) | def cvt_p2d_from_pm1_to_i(p2d_pm1, bbx_xys):
  function uv2l_index (line 176) | def uv2l_index(uv, W):
  function l2uv_index (line 180) | def l2uv_index(l, W):
  function transform_mat (line 186) | def transform_mat(R, t):
  function axis_angle_to_matrix_exp_map (line 200) | def axis_angle_to_matrix_exp_map(aa):
  function matrix_to_axis_angle_log_map (line 212) | def matrix_to_axis_angle_log_map(R):
  function matrix_to_axis_angle (line 224) | def matrix_to_axis_angle(R):
  function ransac_PnP (line 234) | def ransac_PnP(K, pts_2d, pts_3d, err_thr=10):
  function ransac_PnP_batch (line 260) | def ransac_PnP_batch(K_raw, pts_2d, pts_3d, err_thr=10):
  function triangulate_point (line 271) | def triangulate_point(Ts_w2c, c_p2d, **kwargs):
  function triangulate_point_ortho (line 278) | def triangulate_point_ortho(Ts_w2c, c_p2d, **kwargs):
  function get_nearby_points (line 285) | def get_nearby_points(points, query_verts, padding=0.0, p=1):
  function unproj_bbx_to_fst (line 303) | def unproj_bbx_to_fst(bbx_lurb, K, near_z=0.5, far_z=12.5):
  function convert_bbx_xys_to_lurb (line 314) | def convert_bbx_xys_to_lurb(bbx_xys):
  function convert_lurb_to_bbx_xys (line 324) | def convert_lurb_to_bbx_xys(bbx_lurb):
  function compute_T_ayf2az (line 336) | def compute_T_ayf2az(joints, inverse=False):
  function compute_T_ayfz2ay (line 371) | def compute_T_ayfz2ay(joints, inverse=False):
  function compute_T_ay2ayrot (line 407) | def compute_T_ay2ayrot(joints):
  function compute_root_quaternion_ay (line 428) | def compute_root_quaternion_ay(joints):
  function similarity_transform_batch (line 463) | def similarity_transform_batch(S1, S2):
  function kabsch_algorithm_batch (line 520) | def kabsch_algorithm_batch(X1, X2):
  function compute_cam_angvel (line 567) | def compute_cam_angvel(R_w2c, padding_last=True):
  function ransac_gravity_vec (line 579) | def ransac_gravity_vec(xyz, num_iterations=100, threshold=0.05, verbose=...
  function sequence_best_cammat (line 612) | def sequence_best_cammat(w_j3d, c_j3d, cam_rot):
  function get_sequence_cammat (line 641) | def get_sequence_cammat(w_j3d, c_j3d, cam_rot):
  function ransac_vec (line 656) | def ransac_vec(vel, min_multiply=20, verbose=False):

FILE: eval/GVHMR/hmr4d/utils/ik/ccd_ik.py
  class CCD_IK (line 19) | class CCD_IK:
    method __init__ (line 20) | def __init__(
    method is_converged (line 64) | def is_converged(self):
    method solve (line 72) | def solve(self):
    method optimize (line 80) | def optimize(self, i):
    method get_weight (line 147) | def get_weight(self, i):

FILE: eval/GVHMR/hmr4d/utils/kpts/kp2d_utils.py
  function _taylor (line 10) | def _taylor(heatmap, coord):
  function _get_max_preds (line 44) | def _get_max_preds(heatmaps):
  function post_dark_udp (line 78) | def post_dark_udp(coords, batch_heatmaps, kernel=3):
  function _gaussian_blur (line 140) | def _gaussian_blur(heatmaps, kernel=11):
  function keypoints_from_heatmaps (line 181) | def keypoints_from_heatmaps(
  function transform_preds (line 328) | def transform_preds(coords, center, scale, output_size, use_udp=False):

FILE: eval/GVHMR/hmr4d/utils/matrix.py
  function identity_mat (line 12) | def identity_mat(x=None, device="cpu", is_numpy=False):
  function vec2mat (line 35) | def vec2mat(vec):
  function mat2vec (line 69) | def mat2vec(mat):
  function vec2mat_batch (line 93) | def vec2mat_batch(vec):
  function rotmat2tan_norm (line 128) | def rotmat2tan_norm(mat):
  function mat2tan_norm (line 158) | def mat2tan_norm(mat):
  function rotmat2tan_norm (line 171) | def rotmat2tan_norm(mat):
  function tan_norm2rotmat (line 203) | def tan_norm2rotmat(tan_norm):
  function rotmat332vec_batch (line 234) | def rotmat332vec_batch(mat):
  function rotmat2vec_batch (line 257) | def rotmat2vec_batch(mat):
  function mat2vec_batch (line 280) | def mat2vec_batch(mat):
  function mat2pose_batch (line 304) | def mat2pose_batch(mat, returnvel=True):
  function get_mat_BinA (line 335) | def get_mat_BinA(matCtoA, matCtoB):
  function get_mat_BtoA (line 359) | def get_mat_BtoA(matA, matB):
  function get_mat_BfromA (line 382) | def get_mat_BfromA(matA, matBtoA):
  function get_relative_position_to (line 398) | def get_relative_position_to(pos, mat):
  function get_rotation (line 423) | def get_rotation(mat):
  function set_rotation (line 435) | def set_rotation(mat, rotmat):
  function set_position (line 448) | def set_position(mat, pos):
  function get_position (line 461) | def get_position(mat):
  function get_position_from (line 473) | def get_position_from(pos, mat):
  function get_position_from_rotmat (line 494) | def get_position_from_rotmat(pos, mat):
  function get_relative_direction_to (line 513) | def get_relative_direction_to(dir, mat):
  function get_direction_from (line 542) | def get_direction_from(dir, mat):
  function get_coord_vis (line 564) | def get_coord_vis(pos, rot_mat, scale=1.0):
  function project_vec (line 571) | def project_vec(vec):
  function xz2xyz (line 594) | def xz2xyz(vec):
  function normalized (line 609) | def normalized(vec):
  function normalized_matrix (line 620) | def normalized_matrix(mat):
  function get_rot_mat_from_forward (line 642) | def get_rot_mat_from_forward(forward):
  function get_rot_mat_from_forward_up (line 674) | def get_rot_mat_from_forward_up(forward, up):
  function get_rot_mat_from_pose_vec (line 703) | def get_rot_mat_from_pose_vec(vec):
  function get_TRS (line 717) | def get_TRS(rot_mat, pos):
  function xzvec2mat (line 742) | def xzvec2mat(vec):
  function distance (line 770) | def distance(vec1, vec2):
  function get_relative_pose_from_vec (line 774) | def get_relative_pose_from_vec(pose, root, N):
  function get_forward_from_pos (line 787) | def get_forward_from_pos(pos):
  function project_point_along_ray (line 808) | def project_point_along_ray(p, ray, keepnorm=False):
  function solve_point_along_ray_with_constraint (line 829) | def solve_point_along_ray_with_constraint(c, ray, p, constraint="x"):
  function calc_cosine (line 855) | def calc_cosine(vec1, vec2, return_angle=False):
  function quat_xyzw2wxyz (line 881) | def quat_xyzw2wxyz(quat):
  function quat_wxyz2xyzw (line 886) | def quat_wxyz2xyzw(quat):
  function quat_mul (line 891) | def quat_mul(a, b):
  function quat_pos (line 906) | def quat_pos(x):
  function quat_abs (line 916) | def quat_abs(x):
  function quat_unit (line 924) | def quat_unit(x):
  function quat_conjugate (line 932) | def quat_conjugate(x):
  function quat_real (line 939) | def quat_real(x):
  function quat_imaginary (line 946) | def quat_imaginary(x):
  function quat_norm_check (line 953) | def quat_norm_check(x):
  function quat_normalize (line 963) | def quat_normalize(q):
  function quat_from_xyz (line 971) | def quat_from_xyz(xyz):
  function quat_identity (line 980) | def quat_identity(shape: List[int]):
  function tgm_quat_from_angle_axis (line 990) | def tgm_quat_from_angle_axis(angle, axis, degree: bool = False):
  function quat_from_rotation_matrix (line 1013) | def quat_from_rotation_matrix(m):
  function quat_mul_norm (line 1062) | def quat_mul_norm(x, y):
  function quat_rotate (line 1070) | def quat_rotate(rot, vec):
  function quat_inverse (line 1078) | def quat_inverse(x):
  function quat_identity_like (line 1085) | def quat_identity_like(x):
  function quat_angle_axis (line 1092) | def quat_angle_axis(x):
  function quat_yaw_rotation (line 1104) | def quat_yaw_rotation(x, z_up: bool = True):
  function transform_from_rotation_translation (line 1124) | def transform_from_rotation_translation(r: Optional[torch.Tensor] = None...
  function transform_identity (line 1137) | def transform_identity(shape: List[int]):
  function transform_rotation (line 1146) | def transform_rotation(x):
  function transform_translation (line 1151) | def transform_translation(x):
  function transform_inverse (line 1156) | def transform_inverse(x):
  function transform_identity_like (line 1164) | def transform_identity_like(x):
  function transform_mul (line 1171) | def transform_mul(x, y):
  function transform_apply (line 1182) | def transform_apply(rot, vec):
  function rot_matrix_det (line 1190) | def rot_matrix_det(x):
  function rot_matrix_integrity_check (line 1204) | def rot_matrix_integrity_check(x):
  function rot_matrix_from_quaternion (line 1218) | def rot_matrix_from_quaternion(q):
  function euclidean_to_rotation_matrix (line 1245) | def euclidean_to_rotation_matrix(x):
  function euclidean_integrity_check (line 1252) | def euclidean_integrity_check(x):
  function euclidean_translation (line 1258) | def euclidean_translation(x):
  function euclidean_inverse (line 1265) | def euclidean_inverse(x):
  function euclidean_to_transform (line 1276) | def euclidean_to_transform(transformation_matrix):
  function to_torch (line 1286) | def to_torch(x, dtype=torch.float, device="cuda:0", requires_grad=False):
  function quat_mul (line 1290) | def quat_mul(a, b):
  function normalize (line 1313) | def normalize(x, eps: float = 1e-9):
  function quat_apply (line 1317) | def quat_apply(a, b):
  function quat_rotate (line 1326) | def quat_rotate(q, v):
  function quat_rotate_inverse (line 1336) | def quat_rotate_inverse(q, v):
  function quat_conjugate (line 1346) | def quat_conjugate(a):
  function quat_unit (line 1352) | def quat_unit(a):
  function quat_from_angle_axis (line 1356) | def quat_from_angle_axis(angle, axis):
  function normalize_angle (line 1363) | def normalize_angle(x):
  function tf_inverse (line 1367) | def tf_inverse(q, t):
  function tf_apply (line 1372) | def tf_apply(q, t, v):
  function tf_vector (line 1376) | def tf_vector(q, v):
  function tf_combine (line 1380) | def tf_combine(q1, t1, q2, t2):
  function get_basis_vector (line 1384) | def get_basis_vector(q, v):
  function get_axis_params (line 1388) | def get_axis_params(value, axis_idx, x_value=0.0, dtype=float, n_dims=3):
  function copysign (line 1398) | def copysign(a, b):
  function get_euler_xyz (line 1404) | def get_euler_xyz(q):
  function quat_from_euler_xyz (line 1423) | def quat_from_euler_xyz(roll, pitch, yaw):
  function torch_rand_float (line 1439) | def torch_rand_float(lower, upper, shape, device):
  function torch_random_dir_2 (line 1444) | def torch_random_dir_2(shape, device):
  function tensor_clamp (line 1450) | def tensor_clamp(t, min_t, max_t):
  function scale (line 1454) | def scale(x, lower, upper):
  function unscale (line 1458) | def unscale(x, lower, upper):
  function unscale_np (line 1462) | def unscale_np(x, lower, upper):
  function quat_to_angle_axis (line 1466) | def quat_to_angle_axis(q):
  function angle_axis_to_exp_map (line 1489) | def angle_axis_to_exp_map(angle, axis):
  function quat_to_exp_map (line 1497) | def quat_to_exp_map(q):
  function quat_to_tan_norm (line 1506) | def quat_to_tan_norm(q):
  function euler_xyz_to_exp_map (line 1521) | def euler_xyz_to_exp_map(roll, pitch, yaw):
  function exp_map_to_angle_axis (line 1528) | def exp_map_to_angle_axis(exp_map):
  function exp_map_to_quat (line 1547) | def exp_map_to_quat(exp_map):
  function slerp (line 1553) | def slerp(q0, q1, t):
  function calc_heading_vec (line 1577) | def calc_heading_vec(q, head_ind=0):
  function calc_heading (line 1589) | def calc_heading(q, head_ind=0, gravity_axis="z"):
  function calc_heading_quat (line 1611) | def calc_heading_quat(q, head_ind=0, gravity_axis="z"):
  function calc_heading_quat_inv (line 1630) | def calc_heading_quat_inv(q, head_ind=0):
  function forward_kinematics (line 1643) | def forward_kinematics(mat, parent):

FILE: eval/GVHMR/hmr4d/utils/net_utils.py
  function load_pretrained_model (line 11) | def load_pretrained_model(model, ckpt_path):
  function find_last_ckpt_path (line 25) | def find_last_ckpt_path(dirpath):
  function get_resume_ckpt_path (line 50) | def get_resume_ckpt_path(resume_mode, ckpt_dir=None):
  function select_state_dict_by_prefix (line 57) | def select_state_dict_by_prefix(state_dict, prefix, new_prefix=""):
  function detach_to_cpu (line 75) | def detach_to_cpu(in_dict):
  function to_cuda (line 79) | def to_cuda(data):
  function get_valid_mask (line 91) | def get_valid_mask(max_len, valid_len, device="cpu"):
  function length_to_mask (line 97) | def length_to_mask(lengths, max_len):
  function repeat_to_max_len (line 105) | def repeat_to_max_len(x, max_len, dim=0):
  function repeat_to_max_len_dict (line 120) | def repeat_to_max_len_dict(x_dict, max_len, dim=0):
  class Transpose (line 126) | class Transpose(nn.Module):
    method __init__ (line 127) | def __init__(self, dim1, dim2):
    method forward (line 132) | def forward(self, x):
  class GaussianSmooth (line 136) | class GaussianSmooth(nn.Module):
    method __init__ (line 137) | def __init__(self, sigma=3, dim=-1):
    method forward (line 144) | def forward(self, x):
  function gaussian_smooth (line 158) | def gaussian_smooth(x, sigma=3, dim=-1):
  function moving_average_smooth (line 173) | def moving_average_smooth(x, window_size=5, dim=-1):

FILE: eval/GVHMR/hmr4d/utils/preproc/slam.py
  class SLAMModel (line 18) | class SLAMModel(object):
    method __init__ (line 19) | def __init__(self, video_path, width, height, intrinsics=None, stride=...
    method track (line 41) | def track(self):
    method process (line 62) | def process(self):
  function video_stream (line 70) | def video_stream(queue, imagedir, intrinsics, stride, skip=0, resize=0.5):

FILE: eval/GVHMR/hmr4d/utils/preproc/tracker.py
  class Tracker (line 19) | class Tracker:
    method __init__ (line 20) | def __init__(self) -> None:
    method track (line 24) | def track(self, video_path):
    method sort_track_length (line 48) | def sort_track_length(track_history, video_path):
    method get_one_track (line 75) | def get_one_track(self, video_path):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitfeat_extractor.py
  function get_batch (line 13) | def get_batch(input_path, bbx_xys, img_ds=0.5, img_dst_size=256, path_ty...
  class Extractor (line 60) | class Extractor:
    method __init__ (line 61) | def __init__(self, tqdm_leave=True):
    method extract_video_features (line 65) | def extract_video_features(self, video_path, bbx_xys, img_ds=0.5):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose.py
  class VitPoseExtractor (line 13) | class VitPoseExtractor:
    method __init__ (line 14) | def __init__(self, tqdm_leave=True):
    method extract (line 23) | def extract(self, video_path, bbx_xys, img_ds=0.5):
  function get_heatmap_preds (line 75) | def get_heatmap_preds(heatmap, normalize_keypoints=True, thr=0.0, soft=F...
  function soft_patch_dx_dy (line 123) | def soft_patch_dx_dy(p):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/alexnet.py
  class AlexNet (line 9) | class AlexNet(BaseBackbone):
    method __init__ (line 20) | def __init__(self, num_classes=-1):
    method forward (line 49) | def forward(self, x):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/cpm.py
  class CpmBlock (line 15) | class CpmBlock(nn.Module):
    method __init__ (line 24) | def __init__(self,
    method forward (line 47) | def forward(self, x):
  class CPM (line 54) | class CPM(BaseBackbone):
    method __init__ (line 86) | def __init__(self,
    method init_weights (line 149) | def init_weights(self, pretrained=None):
    method forward (line 168) | def forward(self, x):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/hourglass.py
  class HourglassModule (line 15) | class HourglassModule(nn.Module):
    method __init__ (line 29) | def __init__(self,
    method forward (line 78) | def forward(self, x):
  class HourglassNet (line 89) | class HourglassNet(BaseBackbone):
    method __init__ (line 120) | def __init__(self,
    method init_weights (line 174) | def init_weights(self, pretrained=None):
    method forward (line 193) | def forward(self, x):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/hourglass_ae.py
  class HourglassAEModule (line 14) | class HourglassAEModule(nn.Module):
    method __init__ (line 26) | def __init__(self,
    method forward (line 58) | def forward(self, x):
  class HourglassAENet (line 70) | class HourglassAENet(BaseBackbone):
    method __init__ (line 102) | def __init__(self,
    method init_weights (line 175) | def init_weights(self, pretrained=None):
    method forward (line 194) | def forward(self, x):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/hrformer.py
  function nlc_to_nchw (line 18) | def nlc_to_nchw(x, hw_shape):
  function nchw_to_nlc (line 35) | def nchw_to_nlc(x):
  function build_drop_path (line 48) | def build_drop_path(drop_path_rate):
  class WindowMSA (line 53) | class WindowMSA(BaseModule):
    method __init__ (line 74) | def __init__(self,
    method init_weights (line 113) | def init_weights(self):
    method forward (line 116) | def forward(self, x, mask=None):
    method double_step_seq (line 157) | def double_step_seq(step1, len1, step2, len2):
  class LocalWindowSelfAttention (line 163) | class LocalWindowSelfAttention(BaseModule):
    method __init__ (line 188) | def __init__(self,
    method forward (line 215) | def forward(self, x, H, W, **kwargs):
  class CrossFFN (line 260) | class CrossFFN(BaseModule):
    method __init__ (line 277) | def __init__(self,
    method forward (line 310) | def forward(self, x, H, W):
  class HRFormerBlock (line 319) | class HRFormerBlock(BaseModule):
    method __init__ (line 342) | def __init__(self,
    method forward (line 380) | def forward(self, x):
    method extra_repr (line 391) | def extra_repr(self):
  class HRFomerModule (line 397) | class HRFomerModule(HRModule):
    method __init__ (line 430) | def __init__(self,
    method _make_one_branch (line 461) | def _make_one_branch(self,
    method _make_fuse_layers (line 504) | def _make_fuse_layers(self):
    method get_num_inchannels (line 574) | def get_num_inchannels(self):
  class HRFormer (line 580) | class HRFormer(HRNet):
    method __init__ (line 663) | def __init__(self,
    method _make_stage (line 701) | def _make_stage(self,

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/litehrnet.py
  class SpatialWeighting (line 21) | class SpatialWeighting(nn.Module):
    method __init__ (line 36) | def __init__(self,
    method forward (line 65) | def forward(self, x):
  class CrossResolutionWeighting (line 72) | class CrossResolutionWeighting(nn.Module):
    method __init__ (line 87) | def __init__(self,
    method forward (line 117) | def forward(self, x):
  class ConditionalChannelWeighting (line 131) | class ConditionalChannelWeighting(nn.Module):
    method __init__ (line 146) | def __init__(self,
    method forward (line 184) | def forward(self, x):
  class Stem (line 208) | class Stem(nn.Module):
    method __init__ (line 225) | def __init__(self,
    method forward (line 309) | def forward(self, x):
  class IterativeHead (line 333) | class IterativeHead(nn.Module):
    method __init__ (line 342) | def __init__(self, in_channels, norm_cfg=dict(type='BN')):
    method forward (line 375) | def forward(self, x):
  class ShuffleUnit (line 395) | class ShuffleUnit(nn.Module):
    method __init__ (line 412) | def __init__(self,
    method forward (line 489) | def forward(self, x):
  class LiteHRModule (line 510) | class LiteHRModule(nn.Module):
    method __init__ (line 531) | def __init__(
    method _check_branches (line 567) | def _check_branches(self, num_branches, in_channels):
    method _make_weighting_blocks (line 574) | def _make_weighting_blocks(self, num_blocks, reduce_ratio, stride=1):
    method _make_one_branch (line 589) | def _make_one_branch(self, branch_index, num_blocks, stride=1):
    method _make_naive_branches (line 614) | def _make_naive_branches(self, num_branches, num_blocks):
    method _make_fuse_layers (line 623) | def _make_fuse_layers(self):
    method forward (line 708) | def forward(self, x):
  class LiteHRNet (line 738) | class LiteHRNet(nn.Module):
    method __init__ (line 785) | def __init__(self,
    method _make_transition_layer (line 831) | def _make_transition_layer(self, num_channels_pre_layer,
    method _make_stage (line 899) | def _make_stage(self,
    method init_weights (line 935) | def init_weights(self, pretrained=None):
    method forward (line 954) | def forward(self, x):
    method train (line 978) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/mobilenet_v2.py
  class InvertedResidual (line 15) | class InvertedResidual(nn.Module):
    method __init__ (line 34) | def __init__(self,
    method forward (line 85) | def forward(self, x):
  class MobileNetV2 (line 101) | class MobileNetV2(BaseBackbone):
    method __init__ (line 130) | def __init__(self,
    method make_layer (line 204) | def make_layer(self, out_channels, num_blocks, stride, expand_ratio):
    method init_weights (line 232) | def init_weights(self, pretrained=None):
    method forward (line 245) | def forward(self, x):
    method _freeze_stages (line 259) | def _freeze_stages(self):
    method train (line 269) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/mobilenet_v3.py
  class MobileNetV3 (line 15) | class MobileNetV3(BaseBackbone):
    method __init__ (line 67) | def __init__(self,
    method _make_layer (line 112) | def _make_layer(self):
    method init_weights (line 144) | def init_weights(self, pretrained=None):
    method forward (line 157) | def forward(self, x):
    method _freeze_stages (line 172) | def _freeze_stages(self):
    method train (line 182) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/mspn.py
  class Bottleneck (line 18) | class Bottleneck(_Bottleneck):
    method __init__ (line 32) | def __init__(self, in_channels, out_channels, **kwargs):
  class DownsampleModule (line 36) | class DownsampleModule(nn.Module):
    method __init__ (line 51) | def __init__(self,
    method _make_layer (line 75) | def _make_layer(self, block, out_channels, blocks, stride=1):
    method forward (line 102) | def forward(self, x, skip1, skip2):
  class UpsampleUnit (line 116) | class UpsampleUnit(nn.Module):
    method __init__ (line 138) | def __init__(self,
    method forward (line 206) | def forward(self, x, up_x):
  class UpsampleModule (line 232) | class UpsampleModule(nn.Module):
    method __init__ (line 249) | def __init__(self,
    method forward (line 282) | def forward(self, x):
  class SingleStageNetwork (line 304) | class SingleStageNetwork(nn.Module):
    method __init__ (line 324) | def __init__(self,
    method forward (line 351) | def forward(self, x, skip1, skip2):
  class ResNetTop (line 358) | class ResNetTop(nn.Module):
    method __init__ (line 367) | def __init__(self, norm_cfg=dict(type='BN'), channels=64):
    method forward (line 381) | def forward(self, img):
  class MSPN (line 386) | class MSPN(BaseBackbone):
    method __init__ (line 421) | def __init__(self,
    method forward (line 459) | def forward(self, x):
    method init_weights (line 471) | def init_weights(self, pretrained=None):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/regnet.py
  class RegNet (line 14) | class RegNet(ResNet):
    method __init__ (line 88) | def __init__(self,
    method _make_stem_layer (line 197) | def _make_stem_layer(self, in_channels, base_channels):
    method generate_regnet (line 212) | def generate_regnet(initial_width,
    method quantize_float (line 244) | def quantize_float(number, divisor):
    method adjust_width_group (line 256) | def adjust_width_group(self, widths, bottleneck_ratio, groups):
    method get_stages_from_blocks (line 281) | def get_stages_from_blocks(self, widths):
    method forward (line 303) | def forward(self, x):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/resnest.py
  class RSoftmax (line 13) | class RSoftmax(nn.Module):
    method __init__ (line 21) | def __init__(self, radix, groups):
    method forward (line 26) | def forward(self, x):
  class SplitAttentionConv2d (line 37) | class SplitAttentionConv2d(nn.Module):
    method __init__ (line 56) | def __init__(self,
    method norm0 (line 97) | def norm0(self):
    method norm1 (line 101) | def norm1(self):
    method forward (line 104) | def forward(self, x):
  class Bottleneck (line 132) | class Bottleneck(_Bottleneck):
    method __init__ (line 162) | def __init__(self,
    method forward (line 225) | def forward(self, x):
  class ResNeSt (line 260) | class ResNeSt(ResNetV1d):
    method __init__ (line 315) | def __init__(self,
    method make_res_layer (line 330) | def make_res_layer(self, **kwargs):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/resnext.py
  class Bottleneck (line 9) | class Bottleneck(_Bottleneck):
    method __init__ (line 34) | def __init__(self,
  class ResNeXt (line 90) | class ResNeXt(ResNet):
    method __init__ (line 152) | def __init__(self, depth, groups=32, width_per_group=4, **kwargs):
    method make_res_layer (line 157) | def make_res_layer(self, **kwargs):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/rsn.py
  class RSB (line 14) | class RSB(nn.Module):
    method __init__ (line 35) | def __init__(self,
    method forward (line 90) | def forward(self, x):
  class Downsample_module (line 125) | class Downsample_module(nn.Module):
    method __init__ (line 143) | def __init__(self,
    method _make_layer (line 180) | def _make_layer(self,
    method forward (line 222) | def forward(self, x, skip1, skip2):
  class Upsample_unit (line 236) | class Upsample_unit(nn.Module):
    method __init__ (line 258) | def __init__(self,
    method forward (line 326) | def forward(self, x, up_x):
  class Upsample_module (line 352) | class Upsample_module(nn.Module):
    method __init__ (line 369) | def __init__(self,
    method forward (line 401) | def forward(self, x):
  class Single_stage_RSN (line 423) | class Single_stage_RSN(nn.Module):
    method __init__ (line 446) | def __init__(self,
    method forward (line 477) | def forward(self, x, skip1, skip2):
  class ResNet_top (line 484) | class ResNet_top(nn.Module):
    method __init__ (line 493) | def __init__(self, norm_cfg=dict(type='BN'), channels=64):
    method forward (line 507) | def forward(self, img):
  class RSN (line 512) | class RSN(BaseBackbone):
    method __init__ (line 549) | def __init__(self,
    method forward (line 592) | def forward(self, x):
    method init_weights (line 604) | def init_weights(self, pretrained=None):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/scnet.py
  class SCConv (line 14) | class SCConv(nn.Module):
    method __init__ (line 28) | def __init__(self,
    method forward (line 77) | def forward(self, x):
  class SCBottleneck (line 90) | class SCBottleneck(Bottleneck):
    method __init__ (line 100) | def __init__(self, in_channels, out_channels, **kwargs):
    method forward (line 153) | def forward(self, x):
  class SCNet (line 192) | class SCNet(ResNet):
    method __init__ (line 245) | def __init__(self, depth, **kwargs):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/seresnet.py
  class SEBottleneck (line 9) | class SEBottleneck(Bottleneck):
    method __init__ (line 18) | def __init__(self, in_channels, out_channels, se_ratio=16, **kwargs):
    method forward (line 22) | def forward(self, x):
  class SEResNet (line 58) | class SEResNet(ResNet):
    method __init__ (line 118) | def __init__(self, depth, se_ratio=16, **kwargs):
    method make_res_layer (line 124) | def make_res_layer(self, **kwargs):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/seresnext.py
  class SEBottleneck (line 10) | class SEBottleneck(_SEBottleneck):
    method __init__ (line 37) | def __init__(self,
  class SEResNeXt (line 95) | class SEResNeXt(SEResNet):
    method __init__ (line 158) | def __init__(self, depth, groups=32, width_per_group=4, **kwargs):
    method make_res_layer (line 163) | def make_res_layer(self, **kwargs):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/shufflenet_v1.py
  class ShuffleUnit (line 17) | class ShuffleUnit(nn.Module):
    method __init__ (line 47) | def __init__(self,
    method _add (line 117) | def _add(x, out):
    method _concat (line 122) | def _concat(x, out):
    method forward (line 126) | def forward(self, x):
  class ShuffleNetV1 (line 157) | class ShuffleNetV1(BaseBackbone):
    method __init__ (line 182) | def __init__(self,
    method _freeze_stages (line 250) | def _freeze_stages(self):
    method init_weights (line 260) | def init_weights(self, pretrained=None):
    method make_layer (line 280) | def make_layer(self, out_channels, num_blocks, first_block=False):
    method forward (line 309) | def forward(self, x):
    method train (line 323) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/shufflenet_v2.py
  class InvertedResidual (line 16) | class InvertedResidual(nn.Module):
    method __init__ (line 33) | def __init__(self,
    method forward (line 113) | def forward(self, x):
  class ShuffleNetV2 (line 135) | class ShuffleNetV2(BaseBackbone):
    method __init__ (line 158) | def __init__(self,
    method _make_layer (line 228) | def _make_layer(self, out_channels, num_blocks):
    method _freeze_stages (line 251) | def _freeze_stages(self):
    method init_weights (line 262) | def init_weights(self, pretrained=None):
    method forward (line 282) | def forward(self, x):
    method train (line 296) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/tcn.py
  class BasicTemporalBlock (line 13) | class BasicTemporalBlock(nn.Module):
    method __init__ (line 38) | def __init__(self,
    method forward (line 100) | def forward(self, x):
  class TCN (line 133) | class TCN(BaseBackbone):
    method __init__ (line 179) | def __init__(self,
    method forward (line 245) | def forward(self, x):
    method init_weights (line 259) | def init_weights(self, pretrained=None):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/test_torch.py
  class Net (line 6) | class Net(nn.Module):
    method __init__ (line 8) | def __init__(self):
    method forward (line 19) | def forward(self, x):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/utils/channel_shuffle.py
  function channel_shuffle (line 5) | def channel_shuffle(x, groups):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/utils/inverted_residual.py
  class InvertedResidual (line 11) | class InvertedResidual(nn.Module):
    method __init__ (line 41) | def __init__(self,
    method forward (line 104) | def forward(self, x):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/utils/make_divisible.py
  function make_divisible (line 2) | def make_divisible(value, divisor, min_value=None, min_ratio=0.9):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/utils/se_layer.py
  class SELayer (line 7) | class SELayer(nn.Module):
    method __init__ (line 24) | def __init__(self,
    method forward (line 50) | def forward(self, x):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/utils/utils.py
  function load_checkpoint (line 7) | def load_checkpoint(model,
  function get_state_dict (line 53) | def get_state_dict(filename, map_location='cpu'):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/vgg.py
  function make_vgg_layer (line 10) | def make_vgg_layer(in_channels,
  class VGG (line 39) | class VGG(BaseBackbone):
    method __init__ (line 77) | def __init__(self,
    method init_weights (line 148) | def init_weights(self, pretrained=None):
    method forward (line 159) | def forward(self, x):
    method _freeze_stages (line 177) | def _freeze_stages(self):
    method train (line 186) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/vipnas_mbv3.py
  class ViPNAS_MobileNetV3 (line 15) | class ViPNAS_MobileNetV3(BaseBackbone):
    method __init__ (line 45) | def __init__(self,
    method _make_layer (line 91) | def _make_layer(self):
    method init_weights (line 137) | def init_weights(self, pretrained=None):
    method forward (line 154) | def forward(self, x):
    method _freeze_stages (line 163) | def _freeze_stages(self):
    method train (line 173) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/vipnas_resnet.py
  class ViPNAS_Bottleneck (line 14) | class ViPNAS_Bottleneck(nn.Module):
    method __init__ (line 41) | def __init__(self,
    method norm1 (line 124) | def norm1(self):
    method norm2 (line 129) | def norm2(self):
    method norm3 (line 134) | def norm3(self):
    method forward (line 138) | def forward(self, x):
  function get_expansion (line 175) | def get_expansion(block, expansion=None):
  class ViPNAS_ResLayer (line 208) | class ViPNAS_ResLayer(nn.Sequential):
    method __init__ (line 238) | def __init__(self,
  class ViPNAS_ResNet (line 343) | class ViPNAS_ResNet(BaseBackbone):
    method __init__ (line 392) | def __init__(self,
    method make_res_layer (line 474) | def make_res_layer(self, **kwargs):
    method norm1 (line 479) | def norm1(self):
    method _make_stem_layer (line 483) | def _make_stem_layer(self, in_channels, stem_channels, kernel_size):
    method _freeze_stages (line 529) | def _freeze_stages(self):
    method init_weights (line 548) | def init_weights(self, pretrained=None):
    method forward (line 562) | def forward(self, x):
    method train (line 581) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/backbones/vit.py
  class DropPath (line 15) | class DropPath(nn.Module):
    method __init__ (line 18) | def __init__(self, drop_prob=None):
    method forward (line 22) | def forward(self, x):
    method extra_repr (line 25) | def extra_repr(self):
  class Mlp (line 28) | class Mlp(nn.Module):
    method __init__ (line 29) | def __init__(self, in_features, hidden_features=None, out_features=Non...
    method forward (line 38) | def forward(self, x):
  class Attention (line 45) | class Attention(nn.Module):
    method __init__ (line 46) | def __init__(
    method forward (line 66) | def forward(self, x):
  class Block (line 84) | class Block(nn.Module):
    method __init__ (line 86) | def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_sc...
    method forward (line 104) | def forward(self, x):
  class PatchEmbed (line 110) | class PatchEmbed(nn.Module):
    method __init__ (line 113) | def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=...
    method forward (line 126) | def forward(self, x, **kwargs):
  class HybridEmbed (line 135) | class HybridEmbed(nn.Module):
    method __init__ (line 139) | def __init__(self, backbone, img_size=224, feature_size=None, in_chans...
    method forward (line 160) | def forward(self, x):
  class ViT (line 168) | class ViT(nn.Module):
    method __init__ (line 170) | def __init__(self,
    method _freeze_stages (line 216) | def _freeze_stages(self):
    method init_weights (line 253) | def init_weights(self, pretrained=None):
    method get_num_layers (line 273) | def get_num_layers(self):
    method no_weight_decay (line 277) | def no_weight_decay(self):
    method forward_features (line 280) | def forward_features(self, x):
    method forward (line 301) | def forward(self, x):
    method train (line 305) | def train(self, mode=True):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/configs/coco/ViTPose_base_coco_256x192.py
  function make_cfg (line 165) | def make_cfg(model=model,data_cfg=data_cfg):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/deconv_head.py
  class DeconvHead (line 12) | class DeconvHead(nn.Module):
    method __init__ (line 40) | def __init__(self,
    method _init_inputs (line 129) | def _init_inputs(self, in_channels, in_index, input_transform):
    method _transform_inputs (line 169) | def _transform_inputs(self, inputs):
    method _make_deconv_layer (line 198) | def _make_deconv_layer(self, num_layers, num_filters, num_kernels):
    method _get_deconv_cfg (line 232) | def _get_deconv_cfg(deconv_kernel):
    method get_loss (line 248) | def get_loss(self, outputs, targets, masks):
    method forward (line 275) | def forward(self, x):
    method init_weights (line 284) | def init_weights(self):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/deeppose_regression_head.py
  class DeepposeRegressionHead (line 13) | class DeepposeRegressionHead(nn.Module):
    method __init__ (line 24) | def __init__(self,
    method forward (line 42) | def forward(self, x):
    method get_loss (line 48) | def get_loss(self, output, target, target_weight):
    method get_accuracy (line 69) | def get_accuracy(self, output, target, target_weight):
    method inference_model (line 97) | def inference_model(self, x, flip_pairs=None):
    method decode (line 117) | def decode(self, img_metas, output, **kwargs):
    method init_weights (line 175) | def init_weights(self):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/hmr_head.py
  class HMRMeshHead (line 12) | class HMRMeshHead(nn.Module):
    method __init__ (line 22) | def __init__(self, in_channels, smpl_mean_params=None, n_iter=3):
    method forward (line 58) | def forward(self, x):
    method init_weights (line 90) | def init_weights(self):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/interhand_3d_head.py
  class Heatmap3DHead (line 17) | class Heatmap3DHead(nn.Module):
    method __init__ (line 33) | def __init__(self,
    method _make_deconv_layer (line 117) | def _make_deconv_layer(self, num_layers, num_filters, num_kernels):
    method _get_deconv_cfg (line 151) | def _get_deconv_cfg(deconv_kernel):
    method forward (line 167) | def forward(self, x):
    method init_weights (line 176) | def init_weights(self):
  class Heatmap1DHead (line 190) | class Heatmap1DHead(nn.Module):
    method __init__ (line 200) | def __init__(self, in_channels=2048, heatmap_size=64, hidden_dims=(512...
    method soft_argmax_1d (line 209) | def soft_argmax_1d(self, heatmap1d):
    method _make_linear_layers (line 217) | def _make_linear_layers(self, feat_dims, relu_final=False):
    method forward (line 227) | def forward(self, x):
    method init_weights (line 233) | def init_weights(self):
  class MultilabelClassificationHead (line 240) | class MultilabelClassificationHead(nn.Module):
    method __init__ (line 250) | def __init__(self, in_channels=2048, num_labels=2, hidden_dims=(512, )):
    method _make_linear_layers (line 259) | def _make_linear_layers(self, feat_dims, relu_final=False):
    method forward (line 269) | def forward(self, x):
    method init_weights (line 274) | def init_weights(self):
  class Interhand3DHead (line 281) | class Interhand3DHead(nn.Module):
    method __init__ (line 300) | def __init__(self,
    method init_weights (line 327) | def init_weights(self):
    method get_loss (line 333) | def get_loss(self, output, target, target_weight):
    method get_accuracy (line 365) | def get_accuracy(self, output, target, target_weight):
    method forward (line 383) | def forward(self, x):
    method inference_model (line 394) | def inference_model(self, x, flip_pairs=None):
    method decode (line 443) | def decode(self, img_metas, output, **kwargs):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/temporal_regression_head.py
  class TemporalRegressionHead (line 13) | class TemporalRegressionHead(nn.Module):
    method __init__ (line 31) | def __init__(self,
    method _transform_inputs (line 63) | def _transform_inputs(x):
    method forward (line 80) | def forward(self, x):
    method get_loss (line 89) | def get_loss(self, output, target, target_weight):
    method get_accuracy (line 128) | def get_accuracy(self, output, target, target_weight, metas):
    method inference_model (line 202) | def inference_model(self, x, flip_pairs=None):
    method decode (line 225) | def decode(self, metas, output):
    method _denormalize_joints (line 265) | def _denormalize_joints(x, mean, std):
    method _restore_global_position (line 279) | def _restore_global_position(x, root_pos, root_idx=None):
    method _restore_root_target_weight (line 295) | def _restore_root_target_weight(target_weight, root_weight, root_idx=N...
    method init_weights (line 313) | def init_weights(self):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/topdown_heatmap_base_head.py
  class TopdownHeatmapBaseHead (line 10) | class TopdownHeatmapBaseHead(nn.Module):
    method get_loss (line 25) | def get_loss(self, **kwargs):
    method get_accuracy (line 29) | def get_accuracy(self, **kwargs):
    method forward (line 33) | def forward(self, **kwargs):
    method inference_model (line 37) | def inference_model(self, **kwargs):
    method decode (line 40) | def decode(self, img_metas, output, **kwargs):
    method _get_deconv_cfg (line 106) | def _get_deconv_cfg(deconv_kernel):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/topdown_heatmap_multi_stage_head.py
  class TopdownHeatmapMultiStageHead (line 18) | class TopdownHeatmapMultiStageHead(TopdownHeatmapBaseHead):
    method __init__ (line 38) | def __init__(self,
    method get_loss (line 109) | def get_loss(self, output, target, target_weight):
    method get_accuracy (line 150) | def get_accuracy(self, output, target, target_weight):
    method forward (line 177) | def forward(self, x):
    method inference_model (line 191) | def inference_model(self, x, flip_pairs=None):
    method _make_deconv_layer (line 220) | def _make_deconv_layer(self, num_layers, num_filters, num_kernels):
    method init_weights (line 253) | def init_weights(self):
  class PredictHeatmap (line 265) | class PredictHeatmap(nn.Module):
    method __init__ (line 277) | def __init__(self,
    method forward (line 311) | def forward(self, feature):
  class PRM (line 320) | class PRM(nn.Module):
    method __init__ (line 333) | def __init__(self, out_channels, norm_cfg=dict(type='BN')):
    method forward (line 374) | def forward(self, x):
  class TopdownHeatmapMSMUHead (line 391) | class TopdownHeatmapMSMUHead(TopdownHeatmapBaseHead):
    method __init__ (line 408) | def __init__(self,
    method get_loss (line 446) | def get_loss(self, output, target, target_weight):
    method get_accuracy (line 488) | def get_accuracy(self, output, target, target_weight):
    method forward (line 518) | def forward(self, x):
    method inference_model (line 538) | def inference_model(self, x, flip_pairs=None):
    method init_weights (line 564) | def init_weights(self):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/topdown_heatmap_simple_head.py
  function build_conv_layer (line 15) | def build_conv_layer(cfg, *args, **kwargs) -> nn.Module:
  function build_upsample_layer (line 37) | def build_upsample_layer(cfg, *args, **kwargs) -> nn.Module:
  class TopdownHeatmapSimpleHead (line 58) | class TopdownHeatmapSimpleHead(TopdownHeatmapBaseHead):
    method __init__ (line 90) | def __init__(self,
    method get_loss (line 188) | def get_loss(self, output, target, target_weight):
    method get_accuracy (line 212) | def get_accuracy(self, output, target, target_weight):
    method forward (line 239) | def forward(self, x):
    method inference_model (line 246) | def inference_model(self, x, flip_pairs=None):
    method _init_inputs (line 271) | def _init_inputs(self, in_channels, in_index, input_transform):
    method _transform_inputs (line 311) | def _transform_inputs(self, inputs):
    method _make_deconv_layer (line 348) | def _make_deconv_layer(self, num_layers, num_filters, num_kernels):
    method init_weights (line 381) | def init_weights(self):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/vipnas_heatmap_simple_head.py
  class ViPNASHeatmapSimpleHead (line 16) | class ViPNASHeatmapSimpleHead(TopdownHeatmapBaseHead):
    method __init__ (line 52) | def __init__(self,
    method get_loss (line 146) | def get_loss(self, output, target, target_weight):
    method get_accuracy (line 170) | def get_accuracy(self, output, target, target_weight):
    method forward (line 197) | def forward(self, x):
    method inference_model (line 204) | def inference_model(self, x, flip_pairs=None):
    method _init_inputs (line 229) | def _init_inputs(self, in_channels, in_index, input_transform):
    method _transform_inputs (line 269) | def _transform_inputs(self, inputs):
    method _make_deconv_layer (line 298) | def _make_deconv_layer(self, num_layers, num_filters, num_kernels,
    method init_weights (line 338) | def init_weights(self):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/heads/voxelpose_head.py
  class CuboidCenterHead (line 15) | class CuboidCenterHead(nn.Module):
    method __init__ (line 28) | def __init__(self,
    method _get_real_locations (line 44) | def _get_real_locations(self, indices):
    method _nms_by_max_pool (line 58) | def _nms_by_max_pool(self, heatmap_volumes):
    method _max_pool (line 69) | def _max_pool(self, inputs):
    method _get_3d_indices (line 78) | def _get_3d_indices(indices, shape):
    method forward (line 98) | def forward(self, heatmap_volumes):
    method get_loss (line 122) | def get_loss(self, pred_cubes, gt):
  class CuboidPoseHead (line 128) | class CuboidPoseHead(nn.Module):
    method __init__ (line 130) | def __init__(self, beta):
    method forward (line 144) | def forward(self, heatmap_volumes, grid_coordinates):
    method get_loss (line 165) | def get_loss(self, preds, targets, weights):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/builder/model_builder.py
  function build_model (line 17) | def build_model(model_name, checkpoint=None):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/model_builder.py
  function build_model (line 121) | def build_model(model_name, checkpoint=None):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/pose_utils/ViTPose_trt.py
  function torch_device_from_trt (line 6) | def torch_device_from_trt(device):
  function torch_dtype_from_trt (line 13) | def torch_dtype_from_trt(dtype):
  class TRTModule_ViTPose (line 26) | class TRTModule_ViTPose(torch.nn.Module):
    method __init__ (line 27) | def __init__(self, engine=None, input_names=None, output_names=None, i...
    method forward (line 68) | def forward(self, *inputs):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/pose_utils/general_utils.py
  function make_parser (line 17) | def make_parser():
  function jitter (line 32) | def jitter(tracking,temp,id1):
  function jitter2 (line 34) | def jitter2(tracking,temp,id1)  :
  function create_json_rabbitmq (line 37) | def create_json_rabbitmq( FRAME_ID,pose):
  function producer_rabbitmq (line 40) | def producer_rabbitmq():
  function fix_head (line 42) | def fix_head(xyz):
  function flatten_lst (line 45) | def flatten_lst(x):
  function polys_from_pose (line 51) | def polys_from_pose(pts):
  function fix_list_order (line 86) | def fix_list_order(list_,list2):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/pose_utils/logger_helper.py
  class CustomFormatter (line 3) | class CustomFormatter(logging.Formatter):
    method format (line 20) | def format(self, record):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/pose_utils/pose_utils.py
  function pose_points_yolo5 (line 25) | def pose_points_yolo5(detector,image,pose,tracker,tensorrt):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/pose_utils/pose_viz.py
  function joints_dict (line 9) | def joints_dict():
  function draw_points (line 71) | def draw_points(image, points, color_palette='tab20', palette_samples=16...
  function draw_skeleton (line 110) | def draw_skeleton(image, points, skeleton, color_palette='Set2', palette...
  function draw_points_and_skeleton (line 156) | def draw_points_and_skeleton(image, points, skeleton, points_color_palet...
  function save_images (line 195) | def save_images(images, target, joint_target, output, joint_output, join...
  function check_video_rotation (line 271) | def check_video_rotation(filename):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/pose_utils/timerr.py
  class Timer (line 4) | class Timer(object):
    method __init__ (line 6) | def __init__(self):
    method tic (line 15) | def tic(self):
    method toc (line 20) | def toc(self, average=True):
    method clear (line 31) | def clear(self):

FILE: eval/GVHMR/hmr4d/utils/preproc/vitpose_pytorch/src/vitpose_infer/pose_utils/visualizer.py
  function vis (line 7) | def vis(img, boxes, scores, cls_ids, conf=0.5, class_names=None):
  function get_color (line 41) | def get_color(idx):
  function plot_tracking (line 48) | def plot_tracking(image, tlwhs, obj_ids, scores=None, frame_id=0, fps=0....

FILE: eval/GVHMR/hmr4d/utils/pylogger.py
  function sync_time (line 7) | def sync_time():
  function timer (line 29) | def timer(sync_cuda=False, mem=False, loop=1):
  function timed (line 68) | def timed(fn):

FILE: eval/GVHMR/hmr4d/utils/seq_utils.py
  function get_frame_id_list_from_mask (line 27) | def get_frame_id_list_from_mask(mask):
  function get_batch_frame_id_lists_from_mask_BLC (line 56) | def get_batch_frame_id_lists_from_mask_BLC(masks):
  function get_frame_id_list_from_frame_id (line 96) | def get_frame_id_list_from_frame_id(frame_id):
  function rearrange_by_mask (line 103) | def rearrange_by_mask(x, mask):
  function frame_id_to_mask (line 119) | def frame_id_to_mask(frame_id, max_len):
  function mask_to_frame_id (line 125) | def mask_to_frame_id(mask):
  function linear_interpolate_frame_ids (line 130) | def linear_interpolate_frame_ids(data, frame_id_list):
  function linear_interpolate (line 149) | def linear_interpolate(data, N_middle_frames):
  function find_top_k_span (line 163) | def find_top_k_span(mask, k=3):

FILE: eval/GVHMR/hmr4d/utils/smplx_utils.py
  function make_smplx (line 18) | def make_smplx(type="neu_fullpose", **kwargs):
  function load_parents (line 172) | def load_parents(npz_path="models/smplx/SMPLX_NEUTRAL.npz"):
  function load_smpl_faces (line 179) | def load_smpl_faces(npz_path="models/smplh/SMPLH_FEMALE.pkl"):
  function decompose_fullpose (line 186) | def decompose_fullpose(fullpose, model_type="smplx"):
  function compose_fullpose (line 202) | def compose_fullpose(fullpose_dict, model_type="smplx"):
  function compute_R_from_kinetree (line 222) | def compute_R_from_kinetree(rot_mats, parents):
  function compute_relR_from_kinetree (line 245) | def compute_relR_from_kinetree(R, parents):
  function quat_mul (line 268) | def quat_mul(x, y):
  function quat_inv (line 301) | def quat_inv(q):
  function quat_mul_vec (line 313) | def quat_mul_vec(q, x):
  function inverse_kinematics_motion (line 329) | def inverse_kinematics_motion(
  function transform_mat (line 352) | def transform_mat(R, t):
  function normalize_joints (line 364) | def normalize_joints(joints):
  function compute_Rt_af2az (line 383) | def compute_Rt_af2az(joints, inverse=False):
  function finite_difference_forward (line 411) | def finite_difference_forward(x, dim_t=1, dup_last=True):
  function compute_joints_zero (line 422) | def compute_joints_zero(betas, gender):

FILE: eval/GVHMR/hmr4d/utils/video_io_utils.py
  function get_video_lwh (line 11) | def get_video_lwh(video_path):
  function read_video_np (line 16) | def read_video_np(video_path, start_frame=0, end_frame=-1, scale=1.0):
  function get_video_reader (line 47) | def get_video_reader(video_path):
  function read_images_np (line 51) | def read_images_np(image_paths, verbose=False):
  function save_video (line 66) | def save_video(images, video_path, fps=30, crf=17):
  function get_writer (line 84) | def get_writer(video_path, fps=30, crf=17):
  function copy_file (line 92) | def copy_file(video_path, out_video_path, overwrite=True):
  function merge_videos_horizontal (line 98) | def merge_videos_horizontal(in_video_paths: list, out_video_path: str):
  function merge_videos_vertical (line 107) | def merge_videos_vertical(in_video_paths: list, out_video_path: str):

FILE: eval/GVHMR/hmr4d/utils/vis/cv2_utils.py
  function to_numpy (line 7) | def to_numpy(x):
  function draw_bbx_xys_on_image (line 15) | def draw_bbx_xys_on_image(bbx_xys, image, conf=True):
  function draw_bbx_xys_on_image_batch (line 26) | def draw_bbx_xys_on_image_batch(bbx_xys_batch, image_batch, conf=None):
  function draw_bbx_xyxy_on_image (line 40) | def draw_bbx_xyxy_on_image(bbx_xys, image, conf=True):
  function draw_bbx_xyxy_on_image_batch (line 48) | def draw_bbx_xyxy_on_image_batch(bbx_xyxy_batch, image_batch, mask=None,...
  function draw_kpts (line 74) | def draw_kpts(frame, keypoints, color=(0, 255, 0), thickness=2):
  function draw_kpts_with_conf (line 81) | def draw_kpts_with_conf(frame, kp2d, conf, thickness=2):
  function draw_kpts_with_conf_batch (line 98) | def draw_kpts_with_conf_batch(frames, kp2d_batch, conf_batch, thickness=2):
  function draw_coco17_skeleton (line 112) | def draw_coco17_skeleton(img, keypoints, conf_thr=0):
  function draw_coco17_skeleton_batch (line 138) | def draw_coco17_skeleton_batch(imgs, keypoints_batch, conf_thr=0):

FILE: eval/GVHMR/hmr4d/utils/vis/renderer.py
  function overlay_image_onto_background (line 29) | def overlay_image_onto_background(image, mask, bbox, background):
  function update_intrinsics_from_bbox (line 45) | def update_intrinsics_from_bbox(K_org, bbox):
  function perspective_projection (line 73) | def perspective_projection(x3d, K, R=None, T=None):
  function compute_bbox_from_points (line 84) | def compute_bbox_from_points(X, img_w, img_h, scaleFactor=1.2):
  class Renderer (line 105) | class Renderer:
    method __init__ (line 106) | def __init__(self, width, height, focal_length=None, device="cuda", fa...
    method create_renderer (line 123) | def create_renderer(self):
    method create_camera (line 136) | def create_camera(self, R=None, T=None):
    method initialize_camera_params (line 146) | def initialize_camera_params(self, focal_length, K):
    method set_intrinsic (line 167) | def set_intrinsic(self, K):
    method set_ground (line 170) | def set_ground(self, length, center_x, center_z):
    method update_bbox (line 177) | def update_bbox(self, x3d, scale=2.0, mask=None):
    method reset_bbox (line 198) | def reset_bbox(
    method render_mesh (line 210) | def render_mesh(self, vertices, background=None, colors=[0.8, 0.8, 0.8...
    method render_with_ground (line 244) | def render_with_ground(self, verts, colors, cameras, lights, faces=None):
  function create_meshes (line 278) | def create_meshes(verts, faces, colors):
  function get_global_cameras (line 289) | def get_global_cameras(verts, device="cuda", distance=5, position=(-5.0,...
  function get_global_cameras_static (line 305) | def get_global_cameras_static(
  function get_ground_params_from_points (line 343) | def get_ground_params_from_points(root_points, vert_points):

FILE: eval/GVHMR/hmr4d/utils/vis/renderer_tools.py
  function read_image (line 8) | def read_image(path, scale=1):
  function transform_torch3d (line 17) | def transform_torch3d(T_c2w):
  function transform_pyrender (line 44) | def transform_pyrender(T_c2w):
  function smpl_to_geometry (line 60) | def smpl_to_geometry(verts, faces, vis_mask=None, track_ids=None):
  function filter_visible_meshes (line 79) | def filter_visible_meshes(verts, colors, faces, vis_mask=None, vis_opaci...
  function get_bboxes (line 112) | def get_bboxes(verts, vis_mask):
  function track_to_colors (line 137) | def track_to_colors(track_ids):
  function get_colors (line 145) | def get_colors():
  function checkerboard_geometry (line 161) | def checkerboard_geometry(
  function camera_marker_geometry (line 214) | def camera_marker_geometry(radius, height, up):
  function vis_keypoints (line 261) | def vis_keypoints(
  function imshow_keypoints (line 714) | def imshow_keypoints(

FILE: eval/GVHMR/hmr4d/utils/vis/renderer_utils.py
  function simple_render_mesh (line 6) | def simple_render_mesh(render_dict):
  function simple_render_mesh_background (line 21) | def simple_render_mesh_background(render_dict, VI=50, colors=[0.8, 0.8, ...

FILE: eval/GVHMR/hmr4d/utils/vis/rich_logger.py
  function print_cfg (line 10) | def print_cfg(cfg: DictConfig, use_rich: bool = False):

FILE: eval/GVHMR/hmr4d/utils/wis3d_utils.py
  function make_wis3d (line 10) | def make_wis3d(output_dir="outputs/wis3d", name="debug", time_postfix=Fa...
  function get_gradient_colors (line 38) | def get_gradient_colors(scheme="red", num_points=120, alpha=1.0):
  function get_const_colors (line 48) | def get_const_colors(name="red", partial_shape=(120, 5), alpha=1.0):
  function get_colors_by_conf (line 58) | def get_colors_by_conf(conf, low="red", high="green"):
  function convert_motion_as_line_mesh (line 92) | def convert_motion_as_line_mesh(motion, skeleton_type="smpl22", const_co...
  function add_motion_as_lines (line 124) | def add_motion_as_lines(motion, wis3d, name="joints22", skeleton_type="s...
  function add_prog_motion_as_lines (line 139) | def add_prog_motion_as_lines(motion, wis3d, name="joints22", skeleton_ty...
  function add_joints_motion_as_spheres (line 174) | def add_joints_motion_as_spheres(joints, wis3d, radius=0.05, name="joint...
  function create_skeleton_mesh (line 208) | def create_skeleton_mesh(p1, p2, radius, color, resolution=4, return_mer...
  function get_lines_of_my_frustum (line 278) | def get_lines_of_my_frustum(frustum_points):
  function draw_colored_vec (line 287) | def draw_colored_vec(wis3d, vec, name, radius=0.02, colors="r", starts=N...
  function draw_T_w2c (line 315) | def draw_T_w2c(wis3d, T_w2c, name, radius=0.01, all_in_one=True, l=0.1):
  function create_checkerboard_mesh (line 335) | def create_checkerboard_mesh(y=0.0, grid_size=1.0, bounds=((-3, -3), (3,...
  function add_a_trimesh (line 393) | def add_a_trimesh(mesh, wis3d, name):

FILE: eval/GVHMR/tools/demo/demo.py
  function parse_args_to_cfg (line 40) | def parse_args_to_cfg():
  function run_preprocess (line 88) | def run_preprocess(cfg):
  function load_data_dict (line 157) | def load_data_dict(cfg):
  function render_incam (line 180) | def render_incam(cfg):
  function render_global (line 222) | def render_global(cfg):

FILE: eval/GVHMR/tools/eval_pose.py
  function batch_rotation_matrix_angle_error (line 32) | def batch_rotation_matrix_angle_error(R1_batch, R2_batch):
  function normalize (line 51) | def normalize(x):
  function viewmatrix (line 54) | def viewmatrix(z, up, pos):
  function matrix_to_euler_angles (line 62) | def matrix_to_euler_angles(matrix):
  function eul2rot (line 77) | def eul2rot(theta) :
  function extract_location_rotation (line 85) | def extract_location_rotation(data):
  function parse_matrix (line 97) | def parse_matrix(matrix_str):
  function batch_axis_angle_to_rotation_matrix (line 105) | def batch_axis_angle_to_rotation_matrix(r_batch):

FILE: eval/GVHMR/tools/train.py
  function get_callbacks (line 12) | def get_callbacks(cfg: DictConfig) -> list:
  function train (line 31) | def train(cfg: DictConfig) -> None:
  function main (line 80) | def main(cfg) -> None:

FILE: eval/GVHMR/tools/unitest/run_dataset.py
  function get_dataset (line 6) | def get_dataset(DATA_TYPE):

FILE: eval/GVHMR/tools/video/merge_folder.py
  function main (line 8) | def main():

FILE: eval/GVHMR/tools/video/merge_horizontal.py
  function parse_args (line 5) | def parse_args():

FILE: eval/GVHMR/tools/video/merge_vertical.py
  function parse_args (line 5) | def parse_args():

FILE: eval/common_metrics_on_video_quality/calculate_clip.py
  function get_video_scores (line 21) | def get_video_scores(video_path, prompt):

FILE: eval/common_metrics_on_video_quality/calculate_fvd.py
  function trans (line 5) | def trans(x):
  function calculate_fvd (line 15) | def calculate_fvd(videos1, videos2, device, method='styleganv'):
  function main (line 66) | def main():

FILE: eval/common_metrics_on_video_quality/calculate_lpips.py
  function trans (line 15) | def trans(x):
  function calculate_lpips (line 25) | def calculate_lpips(videos1, videos2, device):
  function main (line 82) | def main():

FILE: eval/common_metrics_on_video_quality/calculate_psnr.py
  function img_psnr (line 6) | def img_psnr(img1, img2):
  function trans (line 17) | def trans(x):
  function calculate_psnr (line 20) | def calculate_psnr(videos1, videos2):
  function main (line 72) | def main():

FILE: eval/common_metrics_on_video_quality/calculate_ssim.py
  function ssim (line 6) | def ssim(img1, img2):
  function calculate_ssim_function (line 26) | def calculate_ssim_function(img1, img2):
  function trans (line 44) | def trans(x):
  function calculate_ssim (line 47) | def calculate_ssim(videos1, videos2):
  function main (line 99) | def main():