Welcome to Towhee’s documentation!

User Guide

User Guide:

• User Guide
  • DataCollection in 10 Minutes

User API

User API:

• towhee
  • ops
  • register()
• towhee.DataCollection
  • Get Started
    • DataCollection Introduction
  • DataCollection
    • DataCollection()
  • DataCollection Mixins
• Built-in Operators
  • Runas OP
  • Computer Vision
  • Tensor Like
  • Feature Engineer
  • Scikit-Learn
  • Milvus Search

Developer API

Developer API:

• towhee.operator
  • Operator
    • Operator.__init__()
    • Operator.__call__()
    • Operator.__weakref__
  • NNOperator
    • NNOperator.__init__()
    • NNOperator.save_model()
    • NNOperator.supported_model_names()
    • NNOperator.train()
    • NNOperator.setup_trainer()
  • PyOperator
    • PyOperator.__init__()
• trainer package
  • Subpackages
    • trainer.optimization package
    • trainer.utils package
  • Submodules
  • trainer.callback module
  • trainer.metrics module
  • trainer.modelcard module
  • trainer.scheduler module
  • trainer.trainer module
  • trainer.training_config module
  • Module contents
• trainer.optimization package
  • Submodules
  • trainer.optimization.adafactor module
  • trainer.optimization.adamw module
  • trainer.optimization.optimization module
  • Module contents
• trainer.utils package
  • Submodules
  • trainer.utils.layer_freezer module
  • trainer.utils.trainer_utils module
  • Module contents

Full API

Full API:

• towhee
  • towhee.DataCollection
    • DataCollection()
  • towhee.build_docker_image
    • build_docker_image()
  • towhee.build_pipeline_model
    • build_pipeline_model()
  • towhee.dataset
    • dataset()
  • towhee.command
    • towhee.command.cmdline
      • towhee.command.cmdline.main
        • main()
      • towhee.command.cmdline.main_body
        • main_body()
    • towhee.command.develop
      • towhee.command.develop.SetupCommand
        • SetupCommand
          • SetupCommand.__call__()
          • SetupCommand.__init__()
          • SetupCommand.read_requirements()
      • towhee.command.develop.UninstallCommand
        • UninstallCommand
          • UninstallCommand.__call__()
          • UninstallCommand.__init__()
    • towhee.command.execute
      • towhee.command.execute.PackageCommand
        • PackageCommand
          • PackageCommand.__call__()
          • PackageCommand.__init__()
          • PackageCommand.read_requirements()
      • towhee.command.execute.UploadCommand
        • UploadCommand
          • UploadCommand.__call__()
          • UploadCommand.__init__()
    • towhee.command.repo
      • towhee.command.repo.RepoCommand
        • RepoCommand
          • RepoCommand.__call__()
          • RepoCommand.__init__()
    • towhee.command.user
      • towhee.command.user.LogoutCommand
        • LogoutCommand
          • LogoutCommand.__call__()
          • LogoutCommand.__init__()
      • towhee.command.user.UserCommand
        • UserCommand
          • UserCommand.__call__()
          • UserCommand.__init__()
          • UserCommand.erase_from_credential_store()
          • UserCommand.login()
          • UserCommand.logout()
          • UserCommand.write_to_credential_store()
      • towhee.command.user.WhoCommand
        • WhoCommand
          • WhoCommand.__call__()
          • WhoCommand.__init__()
  • towhee.data
    • towhee.data.dataset
      • towhee.data.dataset.dataset
        • towhee.data.dataset.dataset.TorchDataSet
          • TorchDataSet
            • TorchDataSet.__init__()
        • towhee.data.dataset.dataset.TowheeDataSet
          • TowheeDataSet
            • TowheeDataSet.__init__()
      • towhee.data.dataset.image_datasets
        • towhee.data.dataset.image_datasets.PyTorchImageDataset
          • PyTorchImageDataset
            • PyTorchImageDataset.__init__()
  • towhee.datacollection
    • towhee.datacollection.data_collection
      • towhee.datacollection.data_collection.DataCollection
        • DataCollection
          • DataCollection.__add__()
          • DataCollection.__getitem__()
          • DataCollection.__init__()
          • DataCollection.__repr__()
          • DataCollection.__setitem__()
          • DataCollection.copy()
          • DataCollection.show()
          • DataCollection.to_list()
    • towhee.datacollection.entity
      • towhee.datacollection.entity.Entity
        • Entity
          • Entity.__getitem__()
          • Entity.__init__()
          • Entity.__repr__()
          • Entity.combine()
          • Entity.from_dict()
    • towhee.datacollection.mixins
      • towhee.datacollection.mixins.display
        • towhee.datacollection.mixins.display.table_display
          • table_display()
        • towhee.datacollection.mixins.display.to_html_table
          • to_html_table()
        • towhee.datacollection.mixins.display.to_plain_table
          • to_plain_table()
        • towhee.datacollection.mixins.display.to_printable_table
          • to_printable_table()
        • towhee.datacollection.mixins.display.DisplayMixin
          • DisplayMixin
            • DisplayMixin.show()
  • towhee.hub
    • towhee.hub.get_operator
      • get_operator()
    • towhee.hub.get_pipeline
      • get_pipeline()
    • towhee.hub.cache_manager
      • towhee.hub.cache_manager.get_local_dir
        • get_local_dir()
      • towhee.hub.cache_manager.set_local_dir
        • set_local_dir()
      • towhee.hub.cache_manager.CacheManager
        • CacheManager
          • CacheManager.__init__()
          • CacheManager.get_operator()
          • CacheManager.get_pipeline()
    • towhee.hub.downloader
      • towhee.hub.downloader.download_operator
        • download_operator()
      • towhee.hub.downloader.download_pipeline
        • download_pipeline()
      • towhee.hub.downloader.get_hub_url
        • get_hub_url()
      • towhee.hub.downloader.repo_tag_path
        • repo_tag_path()
      • towhee.hub.downloader.set_hub_url
        • set_hub_url()
    • towhee.hub.operator_manager
      • towhee.hub.operator_manager.OperatorManager
        • OperatorManager
          • OperatorManager.__init__()
          • OperatorManager.create()
          • OperatorManager.create_with_token()
          • OperatorManager.download()
          • OperatorManager.download_executor()
          • OperatorManager.download_files()
          • OperatorManager.exists()
          • OperatorManager.get_file_list()
          • OperatorManager.get_repo_type()
          • OperatorManager.init_nnoperator()
          • OperatorManager.init_pyoperator()
          • OperatorManager.latest_commit()
          • OperatorManager.obtain_lfs_extensions()
    • towhee.hub.pipeline_manager
      • towhee.hub.pipeline_manager.PipelineManager
        • PipelineManager
          • PipelineManager.__init__()
          • PipelineManager.check()
          • PipelineManager.create()
          • PipelineManager.create_with_token()
          • PipelineManager.download()
          • PipelineManager.download_executor()
          • PipelineManager.download_files()
          • PipelineManager.exists()
          • PipelineManager.get_file_list()
          • PipelineManager.get_repo_type()
          • PipelineManager.init_pipeline()
          • PipelineManager.latest_commit()
          • PipelineManager.obtain_lfs_extensions()
    • towhee.hub.repo_manager
      • towhee.hub.repo_manager.RepoManager
        • RepoManager
          • RepoManager.__init__()
          • RepoManager.download()
          • RepoManager.download_executor()
          • RepoManager.download_files()
          • RepoManager.exists()
          • RepoManager.get_file_list()
          • RepoManager.get_repo_type()
          • RepoManager.latest_commit()
          • RepoManager.obtain_lfs_extensions()
  • towhee.models
    • towhee.models.acar_net
      • towhee.models.acar_net.backbone
      • towhee.models.acar_net.head
      • towhee.models.acar_net.model
        • towhee.models.acar_net.model.AcarNet
          • AcarNet
            • AcarNet.__call__()
            • AcarNet.__init__()
            • AcarNet.__repr__()
            • AcarNet.add_module()
            • AcarNet.apply()
            • AcarNet.bfloat16()
            • AcarNet.buffers()
            • AcarNet.children()
            • AcarNet.cpu()
            • AcarNet.cuda()
            • AcarNet.double()
            • AcarNet.eval()
            • AcarNet.extra_repr()
            • AcarNet.float()
            • AcarNet.forward()
            • AcarNet.get_buffer()
            • AcarNet.get_extra_state()
            • AcarNet.get_parameter()
            • AcarNet.get_submodule()
            • AcarNet.half()
            • AcarNet.ipu()
            • AcarNet.load_state_dict()
            • AcarNet.modules()
            • AcarNet.named_buffers()
            • AcarNet.named_children()
            • AcarNet.named_modules()
            • AcarNet.named_parameters()
            • AcarNet.parameters()
            • AcarNet.register_backward_hook()
            • AcarNet.register_buffer()
            • AcarNet.register_forward_hook()
            • AcarNet.register_forward_pre_hook()
            • AcarNet.register_full_backward_hook()
            • AcarNet.register_full_backward_pre_hook()
            • AcarNet.register_load_state_dict_post_hook()
            • AcarNet.register_module()
            • AcarNet.register_parameter()
            • AcarNet.register_state_dict_pre_hook()
            • AcarNet.requires_grad_()
            • AcarNet.set_extra_state()
            • AcarNet.share_memory()
            • AcarNet.state_dict()
            • AcarNet.to()
            • AcarNet.to_empty()
            • AcarNet.train()
            • AcarNet.type()
            • AcarNet.xpu()
            • AcarNet.zero_grad()
      • towhee.models.acar_net.neck
      • towhee.models.acar_net.utils
        • towhee.models.acar_net.utils.get_bbox_after_aug
          • get_bbox_after_aug()
    • towhee.models.action_clip
      • towhee.models.action_clip.action_clip
        • towhee.models.action_clip.action_clip.create_model
          • create_model()
        • towhee.models.action_clip.action_clip.ActionClip
          • ActionClip
            • ActionClip.__init__()
      • towhee.models.action_clip.action_clip_utils
        • towhee.models.action_clip.action_clip_utils.get_configs
          • get_configs()
        • towhee.models.action_clip.action_clip_utils.get_similarity
          • get_similarity()
        • towhee.models.action_clip.action_clip_utils.map_state_dict
          • map_state_dict()
      • towhee.models.action_clip.text_prompt
      • towhee.models.action_clip.visual_prompt
        • towhee.models.action_clip.visual_prompt.LayerNorm
          • LayerNorm
            • LayerNorm.__call__()
            • LayerNorm.__init__()
            • LayerNorm.__repr__()
            • LayerNorm.add_module()
            • LayerNorm.apply()
            • LayerNorm.bfloat16()
            • LayerNorm.buffers()
            • LayerNorm.children()
            • LayerNorm.cpu()
            • LayerNorm.cuda()
            • LayerNorm.double()
            • LayerNorm.eval()
            • LayerNorm.extra_repr()
            • LayerNorm.float()
            • LayerNorm.forward()
            • LayerNorm.get_buffer()
            • LayerNorm.get_extra_state()
            • LayerNorm.get_parameter()
            • LayerNorm.get_submodule()
            • LayerNorm.half()
            • LayerNorm.ipu()
            • LayerNorm.load_state_dict()
            • LayerNorm.modules()
            • LayerNorm.named_buffers()
            • LayerNorm.named_children()
            • LayerNorm.named_modules()
            • LayerNorm.named_parameters()
            • LayerNorm.parameters()
            • LayerNorm.register_backward_hook()
            • LayerNorm.register_buffer()
            • LayerNorm.register_forward_hook()
            • LayerNorm.register_forward_pre_hook()
            • LayerNorm.register_full_backward_hook()
            • LayerNorm.register_full_backward_pre_hook()
            • LayerNorm.register_load_state_dict_post_hook()
            • LayerNorm.register_module()
            • LayerNorm.register_parameter()
            • LayerNorm.register_state_dict_pre_hook()
            • LayerNorm.requires_grad_()
            • LayerNorm.set_extra_state()
            • LayerNorm.share_memory()
            • LayerNorm.state_dict()
            • LayerNorm.to()
            • LayerNorm.to_empty()
            • LayerNorm.train()
            • LayerNorm.type()
            • LayerNorm.xpu()
            • LayerNorm.zero_grad()
        • towhee.models.action_clip.visual_prompt.QuickGELU
          • QuickGELU
            • QuickGELU.__call__()
            • QuickGELU.__init__()
            • QuickGELU.__repr__()
            • QuickGELU.add_module()
            • QuickGELU.apply()
            • QuickGELU.bfloat16()
            • QuickGELU.buffers()
            • QuickGELU.children()
            • QuickGELU.cpu()
            • QuickGELU.cuda()
            • QuickGELU.double()
            • QuickGELU.eval()
            • QuickGELU.extra_repr()
            • QuickGELU.float()
            • QuickGELU.forward()
            • QuickGELU.get_buffer()
            • QuickGELU.get_extra_state()
            • QuickGELU.get_parameter()
            • QuickGELU.get_submodule()
            • QuickGELU.half()
            • QuickGELU.ipu()
            • QuickGELU.load_state_dict()
            • QuickGELU.modules()
            • QuickGELU.named_buffers()
            • QuickGELU.named_children()
            • QuickGELU.named_modules()
            • QuickGELU.named_parameters()
            • QuickGELU.parameters()
            • QuickGELU.register_backward_hook()
            • QuickGELU.register_buffer()
            • QuickGELU.register_forward_hook()
            • QuickGELU.register_forward_pre_hook()
            • QuickGELU.register_full_backward_hook()
            • QuickGELU.register_full_backward_pre_hook()
            • QuickGELU.register_load_state_dict_post_hook()
            • QuickGELU.register_module()
            • QuickGELU.register_parameter()
            • QuickGELU.register_state_dict_pre_hook()
            • QuickGELU.requires_grad_()
            • QuickGELU.set_extra_state()
            • QuickGELU.share_memory()
            • QuickGELU.state_dict()
            • QuickGELU.to()
            • QuickGELU.to_empty()
            • QuickGELU.train()
            • QuickGELU.type()
            • QuickGELU.xpu()
            • QuickGELU.zero_grad()
        • towhee.models.action_clip.visual_prompt.ResidualAttentionBlock
          • ResidualAttentionBlock
            • ResidualAttentionBlock.__call__()
            • ResidualAttentionBlock.__init__()
            • ResidualAttentionBlock.__repr__()
            • ResidualAttentionBlock.add_module()
            • ResidualAttentionBlock.apply()
            • ResidualAttentionBlock.bfloat16()
            • ResidualAttentionBlock.buffers()
            • ResidualAttentionBlock.children()
            • ResidualAttentionBlock.cpu()
            • ResidualAttentionBlock.cuda()
            • ResidualAttentionBlock.double()
            • ResidualAttentionBlock.eval()
            • ResidualAttentionBlock.extra_repr()
            • ResidualAttentionBlock.float()
            • ResidualAttentionBlock.forward()
            • ResidualAttentionBlock.get_buffer()
            • ResidualAttentionBlock.get_extra_state()
            • ResidualAttentionBlock.get_parameter()
            • ResidualAttentionBlock.get_submodule()
            • ResidualAttentionBlock.half()
            • ResidualAttentionBlock.ipu()
            • ResidualAttentionBlock.load_state_dict()
            • ResidualAttentionBlock.modules()
            • ResidualAttentionBlock.named_buffers()
            • ResidualAttentionBlock.named_children()
            • ResidualAttentionBlock.named_modules()
            • ResidualAttentionBlock.named_parameters()
            • ResidualAttentionBlock.parameters()
            • ResidualAttentionBlock.register_backward_hook()
            • ResidualAttentionBlock.register_buffer()
            • ResidualAttentionBlock.register_forward_hook()
            • ResidualAttentionBlock.register_forward_pre_hook()
            • ResidualAttentionBlock.register_full_backward_hook()
            • ResidualAttentionBlock.register_full_backward_pre_hook()
            • ResidualAttentionBlock.register_load_state_dict_post_hook()
            • ResidualAttentionBlock.register_module()
            • ResidualAttentionBlock.register_parameter()
            • ResidualAttentionBlock.register_state_dict_pre_hook()
            • ResidualAttentionBlock.requires_grad_()
            • ResidualAttentionBlock.set_extra_state()
            • ResidualAttentionBlock.share_memory()
            • ResidualAttentionBlock.state_dict()
            • ResidualAttentionBlock.to()
            • ResidualAttentionBlock.to_empty()
            • ResidualAttentionBlock.train()
            • ResidualAttentionBlock.type()
            • ResidualAttentionBlock.xpu()
            • ResidualAttentionBlock.zero_grad()
        • towhee.models.action_clip.visual_prompt.TAggregate
          • TAggregate
            • TAggregate.__call__()
            • TAggregate.__init__()
            • TAggregate.__repr__()
            • TAggregate.add_module()
            • TAggregate.apply()
            • TAggregate.bfloat16()
            • TAggregate.buffers()
            • TAggregate.children()
            • TAggregate.cpu()
            • TAggregate.cuda()
            • TAggregate.double()
            • TAggregate.eval()
            • TAggregate.extra_repr()
            • TAggregate.float()
            • TAggregate.forward()
            • TAggregate.get_buffer()
            • TAggregate.get_extra_state()
            • TAggregate.get_parameter()
            • TAggregate.get_submodule()
            • TAggregate.half()
            • TAggregate.ipu()
            • TAggregate.load_state_dict()
            • TAggregate.modules()
            • TAggregate.named_buffers()
            • TAggregate.named_children()
            • TAggregate.named_modules()
            • TAggregate.named_parameters()
            • TAggregate.parameters()
            • TAggregate.register_backward_hook()
            • TAggregate.register_buffer()
            • TAggregate.register_forward_hook()
            • TAggregate.register_forward_pre_hook()
            • TAggregate.register_full_backward_hook()
            • TAggregate.register_full_backward_pre_hook()
            • TAggregate.register_load_state_dict_post_hook()
            • TAggregate.register_module()
            • TAggregate.register_parameter()
            • TAggregate.register_state_dict_pre_hook()
            • TAggregate.requires_grad_()
            • TAggregate.set_extra_state()
            • TAggregate.share_memory()
            • TAggregate.state_dict()
            • TAggregate.to()
            • TAggregate.to_empty()
            • TAggregate.train()
            • TAggregate.type()
            • TAggregate.xpu()
            • TAggregate.zero_grad()
        • towhee.models.action_clip.visual_prompt.TemporalTransformer
          • TemporalTransformer
            • TemporalTransformer.__call__()
            • TemporalTransformer.__init__()
            • TemporalTransformer.__repr__()
            • TemporalTransformer.add_module()
            • TemporalTransformer.apply()
            • TemporalTransformer.bfloat16()
            • TemporalTransformer.buffers()
            • TemporalTransformer.children()
            • TemporalTransformer.cpu()
            • TemporalTransformer.cuda()
            • TemporalTransformer.double()
            • TemporalTransformer.eval()
            • TemporalTransformer.extra_repr()
            • TemporalTransformer.float()
            • TemporalTransformer.forward()
            • TemporalTransformer.get_buffer()
            • TemporalTransformer.get_extra_state()
            • TemporalTransformer.get_parameter()
            • TemporalTransformer.get_submodule()
            • TemporalTransformer.half()
            • TemporalTransformer.ipu()
            • TemporalTransformer.load_state_dict()
            • TemporalTransformer.modules()
            • TemporalTransformer.named_buffers()
            • TemporalTransformer.named_children()
            • TemporalTransformer.named_modules()
            • TemporalTransformer.named_parameters()
            • TemporalTransformer.parameters()
            • TemporalTransformer.register_backward_hook()
            • TemporalTransformer.register_buffer()
            • TemporalTransformer.register_forward_hook()
            • TemporalTransformer.register_forward_pre_hook()
            • TemporalTransformer.register_full_backward_hook()
            • TemporalTransformer.register_full_backward_pre_hook()
            • TemporalTransformer.register_load_state_dict_post_hook()
            • TemporalTransformer.register_module()
            • TemporalTransformer.register_parameter()
            • TemporalTransformer.register_state_dict_pre_hook()
            • TemporalTransformer.requires_grad_()
            • TemporalTransformer.set_extra_state()
            • TemporalTransformer.share_memory()
            • TemporalTransformer.state_dict()
            • TemporalTransformer.to()
            • TemporalTransformer.to_empty()
            • TemporalTransformer.train()
            • TemporalTransformer.type()
            • TemporalTransformer.xpu()
            • TemporalTransformer.zero_grad()
        • towhee.models.action_clip.visual_prompt.VisualPrompt
          • VisualPrompt
            • VisualPrompt.__call__()
            • VisualPrompt.__init__()
            • VisualPrompt.__repr__()
            • VisualPrompt.add_module()
            • VisualPrompt.apply()
            • VisualPrompt.bfloat16()
            • VisualPrompt.buffers()
            • VisualPrompt.children()
            • VisualPrompt.cpu()
            • VisualPrompt.cuda()
            • VisualPrompt.double()
            • VisualPrompt.eval()
            • VisualPrompt.extra_repr()
            • VisualPrompt.float()
            • VisualPrompt.forward()
            • VisualPrompt.get_buffer()
            • VisualPrompt.get_extra_state()
            • VisualPrompt.get_parameter()
            • VisualPrompt.get_submodule()
            • VisualPrompt.half()
            • VisualPrompt.ipu()
            • VisualPrompt.load_state_dict()
            • VisualPrompt.modules()
            • VisualPrompt.named_buffers()
            • VisualPrompt.named_children()
            • VisualPrompt.named_modules()
            • VisualPrompt.named_parameters()
            • VisualPrompt.parameters()
            • VisualPrompt.register_backward_hook()
            • VisualPrompt.register_buffer()
            • VisualPrompt.register_forward_hook()
            • VisualPrompt.register_forward_pre_hook()
            • VisualPrompt.register_full_backward_hook()
            • VisualPrompt.register_full_backward_pre_hook()
            • VisualPrompt.register_load_state_dict_post_hook()
            • VisualPrompt.register_module()
            • VisualPrompt.register_parameter()
            • VisualPrompt.register_state_dict_pre_hook()
            • VisualPrompt.requires_grad_()
            • VisualPrompt.set_extra_state()
            • VisualPrompt.share_memory()
            • VisualPrompt.state_dict()
            • VisualPrompt.to()
            • VisualPrompt.to_empty()
            • VisualPrompt.train()
            • VisualPrompt.type()
            • VisualPrompt.xpu()
            • VisualPrompt.zero_grad()
    • towhee.models.allinone
      • towhee.models.allinone.allinone
        • towhee.models.allinone.allinone.VCOPHeader
          • VCOPHeader
            • VCOPHeader.__call__()
            • VCOPHeader.__init__()
            • VCOPHeader.__repr__()
            • VCOPHeader.add_module()
            • VCOPHeader.apply()
            • VCOPHeader.bfloat16()
            • VCOPHeader.buffers()
            • VCOPHeader.children()
            • VCOPHeader.cpu()
            • VCOPHeader.cuda()
            • VCOPHeader.double()
            • VCOPHeader.eval()
            • VCOPHeader.extra_repr()
            • VCOPHeader.float()
            • VCOPHeader.forward()
            • VCOPHeader.get_buffer()
            • VCOPHeader.get_extra_state()
            • VCOPHeader.get_parameter()
            • VCOPHeader.get_submodule()
            • VCOPHeader.half()
            • VCOPHeader.ipu()
            • VCOPHeader.load_state_dict()
            • VCOPHeader.modules()
            • VCOPHeader.named_buffers()
            • VCOPHeader.named_children()
            • VCOPHeader.named_modules()
            • VCOPHeader.named_parameters()
            • VCOPHeader.parameters()
            • VCOPHeader.register_backward_hook()
            • VCOPHeader.register_buffer()
            • VCOPHeader.register_forward_hook()
            • VCOPHeader.register_forward_pre_hook()
            • VCOPHeader.register_full_backward_hook()
            • VCOPHeader.register_full_backward_pre_hook()
            • VCOPHeader.register_load_state_dict_post_hook()
            • VCOPHeader.register_module()
            • VCOPHeader.register_parameter()
            • VCOPHeader.register_state_dict_pre_hook()
            • VCOPHeader.requires_grad_()
            • VCOPHeader.set_extra_state()
            • VCOPHeader.share_memory()
            • VCOPHeader.state_dict()
            • VCOPHeader.to()
            • VCOPHeader.to_empty()
            • VCOPHeader.train()
            • VCOPHeader.type()
            • VCOPHeader.xpu()
            • VCOPHeader.zero_grad()
    • towhee.models.clip
      • towhee.models.clip.auxilary
        • towhee.models.clip.auxilary.multi_head_attention_forward
          • multi_head_attention_forward()
        • towhee.models.clip.auxilary.MultiheadAttention
          • MultiheadAttention
            • MultiheadAttention.__call__()
            • MultiheadAttention.__init__()
            • MultiheadAttention.__repr__()
            • MultiheadAttention.add_module()
            • MultiheadAttention.apply()
            • MultiheadAttention.bfloat16()
            • MultiheadAttention.buffers()
            • MultiheadAttention.children()
            • MultiheadAttention.cpu()
            • MultiheadAttention.cuda()
            • MultiheadAttention.double()
            • MultiheadAttention.eval()
            • MultiheadAttention.extra_repr()
            • MultiheadAttention.float()
            • MultiheadAttention.forward()
            • MultiheadAttention.get_buffer()
            • MultiheadAttention.get_extra_state()
            • MultiheadAttention.get_parameter()
            • MultiheadAttention.get_submodule()
            • MultiheadAttention.half()
            • MultiheadAttention.ipu()
            • MultiheadAttention.load_state_dict()
            • MultiheadAttention.modules()
            • MultiheadAttention.named_buffers()
            • MultiheadAttention.named_children()
            • MultiheadAttention.named_modules()
            • MultiheadAttention.named_parameters()
            • MultiheadAttention.parameters()
            • MultiheadAttention.register_backward_hook()
            • MultiheadAttention.register_buffer()
            • MultiheadAttention.register_forward_hook()
            • MultiheadAttention.register_forward_pre_hook()
            • MultiheadAttention.register_full_backward_hook()
            • MultiheadAttention.register_full_backward_pre_hook()
            • MultiheadAttention.register_load_state_dict_post_hook()
            • MultiheadAttention.register_module()
            • MultiheadAttention.register_parameter()
            • MultiheadAttention.register_state_dict_pre_hook()
            • MultiheadAttention.requires_grad_()
            • MultiheadAttention.set_extra_state()
            • MultiheadAttention.share_memory()
            • MultiheadAttention.state_dict()
            • MultiheadAttention.to()
            • MultiheadAttention.to_empty()
            • MultiheadAttention.train()
            • MultiheadAttention.type()
            • MultiheadAttention.xpu()
            • MultiheadAttention.zero_grad()
      • towhee.models.clip.clip
        • towhee.models.clip.clip.create_model
          • create_model()
        • towhee.models.clip.clip.AttentionPool2d
          • AttentionPool2d
            • AttentionPool2d.__call__()
            • AttentionPool2d.__init__()
            • AttentionPool2d.__repr__()
            • AttentionPool2d.add_module()
            • AttentionPool2d.apply()
            • AttentionPool2d.bfloat16()
            • AttentionPool2d.buffers()
            • AttentionPool2d.children()
            • AttentionPool2d.cpu()
            • AttentionPool2d.cuda()
            • AttentionPool2d.double()
            • AttentionPool2d.eval()
            • AttentionPool2d.extra_repr()
            • AttentionPool2d.float()
            • AttentionPool2d.forward()
            • AttentionPool2d.get_buffer()
            • AttentionPool2d.get_extra_state()
            • AttentionPool2d.get_parameter()
            • AttentionPool2d.get_submodule()
            • AttentionPool2d.half()
            • AttentionPool2d.ipu()
            • AttentionPool2d.load_state_dict()
            • AttentionPool2d.modules()
            • AttentionPool2d.named_buffers()
            • AttentionPool2d.named_children()
            • AttentionPool2d.named_modules()
            • AttentionPool2d.named_parameters()
            • AttentionPool2d.parameters()
            • AttentionPool2d.register_backward_hook()
            • AttentionPool2d.register_buffer()
            • AttentionPool2d.register_forward_hook()
            • AttentionPool2d.register_forward_pre_hook()
            • AttentionPool2d.register_full_backward_hook()
            • AttentionPool2d.register_full_backward_pre_hook()
            • AttentionPool2d.register_load_state_dict_post_hook()
            • AttentionPool2d.register_module()
            • AttentionPool2d.register_parameter()
            • AttentionPool2d.register_state_dict_pre_hook()
            • AttentionPool2d.requires_grad_()
            • AttentionPool2d.set_extra_state()
            • AttentionPool2d.share_memory()
            • AttentionPool2d.state_dict()
            • AttentionPool2d.to()
            • AttentionPool2d.to_empty()
            • AttentionPool2d.train()
            • AttentionPool2d.type()
            • AttentionPool2d.xpu()
            • AttentionPool2d.zero_grad()
        • towhee.models.clip.clip.Bottleneck
          • Bottleneck
            • Bottleneck.__call__()
            • Bottleneck.__init__()
            • Bottleneck.__repr__()
            • Bottleneck.add_module()
            • Bottleneck.apply()
            • Bottleneck.bfloat16()
            • Bottleneck.buffers()
            • Bottleneck.children()
            • Bottleneck.cpu()
            • Bottleneck.cuda()
            • Bottleneck.double()
            • Bottleneck.eval()
            • Bottleneck.extra_repr()
            • Bottleneck.float()
            • Bottleneck.forward()
            • Bottleneck.get_buffer()
            • Bottleneck.get_extra_state()
            • Bottleneck.get_parameter()
            • Bottleneck.get_submodule()
            • Bottleneck.half()
            • Bottleneck.ipu()
            • Bottleneck.load_state_dict()
            • Bottleneck.modules()
            • Bottleneck.named_buffers()
            • Bottleneck.named_children()
            • Bottleneck.named_modules()
            • Bottleneck.named_parameters()
            • Bottleneck.parameters()
            • Bottleneck.register_backward_hook()
            • Bottleneck.register_buffer()
            • Bottleneck.register_forward_hook()
            • Bottleneck.register_forward_pre_hook()
            • Bottleneck.register_full_backward_hook()
            • Bottleneck.register_full_backward_pre_hook()
            • Bottleneck.register_load_state_dict_post_hook()
            • Bottleneck.register_module()
            • Bottleneck.register_parameter()
            • Bottleneck.register_state_dict_pre_hook()
            • Bottleneck.requires_grad_()
            • Bottleneck.set_extra_state()
            • Bottleneck.share_memory()
            • Bottleneck.state_dict()
            • Bottleneck.to()
            • Bottleneck.to_empty()
            • Bottleneck.train()
            • Bottleneck.type()
            • Bottleneck.xpu()
            • Bottleneck.zero_grad()
        • towhee.models.clip.clip.CLIP
          • CLIP
            • CLIP.__call__()
            • CLIP.__init__()
            • CLIP.__repr__()
            • CLIP.add_module()
            • CLIP.apply()
            • CLIP.bfloat16()
            • CLIP.buffers()
            • CLIP.children()
            • CLIP.cpu()
            • CLIP.cuda()
            • CLIP.double()
            • CLIP.eval()
            • CLIP.extra_repr()
            • CLIP.float()
            • CLIP.forward()
            • CLIP.get_buffer()
            • CLIP.get_extra_state()
            • CLIP.get_parameter()
            • CLIP.get_submodule()
            • CLIP.half()
            • CLIP.ipu()
            • CLIP.load_state_dict()
            • CLIP.modules()
            • CLIP.named_buffers()
            • CLIP.named_children()
            • CLIP.named_modules()
            • CLIP.named_parameters()
            • CLIP.parameters()
            • CLIP.register_backward_hook()
            • CLIP.register_buffer()
            • CLIP.register_forward_hook()
            • CLIP.register_forward_pre_hook()
            • CLIP.register_full_backward_hook()
            • CLIP.register_full_backward_pre_hook()
            • CLIP.register_load_state_dict_post_hook()
            • CLIP.register_module()
            • CLIP.register_parameter()
            • CLIP.register_state_dict_pre_hook()
            • CLIP.requires_grad_()
            • CLIP.set_extra_state()
            • CLIP.share_memory()
            • CLIP.state_dict()
            • CLIP.to()
            • CLIP.to_empty()
            • CLIP.train()
            • CLIP.type()
            • CLIP.xpu()
            • CLIP.zero_grad()
        • towhee.models.clip.clip.LayerNorm
          • LayerNorm
            • LayerNorm.__call__()
            • LayerNorm.__init__()
            • LayerNorm.__repr__()
            • LayerNorm.add_module()
            • LayerNorm.apply()
            • LayerNorm.bfloat16()
            • LayerNorm.buffers()
            • LayerNorm.children()
            • LayerNorm.cpu()
            • LayerNorm.cuda()
            • LayerNorm.double()
            • LayerNorm.eval()
            • LayerNorm.extra_repr()
            • LayerNorm.float()
            • LayerNorm.forward()
            • LayerNorm.get_buffer()
            • LayerNorm.get_extra_state()
            • LayerNorm.get_parameter()
            • LayerNorm.get_submodule()
            • LayerNorm.half()
            • LayerNorm.ipu()
            • LayerNorm.load_state_dict()
            • LayerNorm.modules()
            • LayerNorm.named_buffers()
            • LayerNorm.named_children()
            • LayerNorm.named_modules()
            • LayerNorm.named_parameters()
            • LayerNorm.parameters()
            • LayerNorm.register_backward_hook()
            • LayerNorm.register_buffer()
            • LayerNorm.register_forward_hook()
            • LayerNorm.register_forward_pre_hook()
            • LayerNorm.register_full_backward_hook()
            • LayerNorm.register_full_backward_pre_hook()
            • LayerNorm.register_load_state_dict_post_hook()
            • LayerNorm.register_module()
            • LayerNorm.register_parameter()
            • LayerNorm.register_state_dict_pre_hook()
            • LayerNorm.requires_grad_()
            • LayerNorm.set_extra_state()
            • LayerNorm.share_memory()
            • LayerNorm.state_dict()
            • LayerNorm.to()
            • LayerNorm.to_empty()
            • LayerNorm.train()
            • LayerNorm.type()
            • LayerNorm.xpu()
            • LayerNorm.zero_grad()
        • towhee.models.clip.clip.ModifiedResNet
          • ModifiedResNet
            • ModifiedResNet.__call__()
            • ModifiedResNet.__init__()
            • ModifiedResNet.__repr__()
            • ModifiedResNet.add_module()
            • ModifiedResNet.apply()
            • ModifiedResNet.bfloat16()
            • ModifiedResNet.buffers()
            • ModifiedResNet.children()
            • ModifiedResNet.cpu()
            • ModifiedResNet.cuda()
            • ModifiedResNet.double()
            • ModifiedResNet.eval()
            • ModifiedResNet.extra_repr()
            • ModifiedResNet.float()
            • ModifiedResNet.forward()
            • ModifiedResNet.get_buffer()
            • ModifiedResNet.get_extra_state()
            • ModifiedResNet.get_parameter()
            • ModifiedResNet.get_submodule()
            • ModifiedResNet.half()
            • ModifiedResNet.ipu()
            • ModifiedResNet.load_state_dict()
            • ModifiedResNet.modules()
            • ModifiedResNet.named_buffers()
            • ModifiedResNet.named_children()
            • ModifiedResNet.named_modules()
            • ModifiedResNet.named_parameters()
            • ModifiedResNet.parameters()
            • ModifiedResNet.register_backward_hook()
            • ModifiedResNet.register_buffer()
            • ModifiedResNet.register_forward_hook()
            • ModifiedResNet.register_forward_pre_hook()
            • ModifiedResNet.register_full_backward_hook()
            • ModifiedResNet.register_full_backward_pre_hook()
            • ModifiedResNet.register_load_state_dict_post_hook()
            • ModifiedResNet.register_module()
            • ModifiedResNet.register_parameter()
            • ModifiedResNet.register_state_dict_pre_hook()
            • ModifiedResNet.requires_grad_()
            • ModifiedResNet.set_extra_state()
            • ModifiedResNet.share_memory()
            • ModifiedResNet.state_dict()
            • ModifiedResNet.to()
            • ModifiedResNet.to_empty()
            • ModifiedResNet.train()
            • ModifiedResNet.type()
            • ModifiedResNet.xpu()
            • ModifiedResNet.zero_grad()
        • towhee.models.clip.clip.QuickGELU
          • QuickGELU
            • QuickGELU.__call__()
            • QuickGELU.__init__()
            • QuickGELU.__repr__()
            • QuickGELU.add_module()
            • QuickGELU.apply()
            • QuickGELU.bfloat16()
            • QuickGELU.buffers()
            • QuickGELU.children()
            • QuickGELU.cpu()
            • QuickGELU.cuda()
            • QuickGELU.double()
            • QuickGELU.eval()
            • QuickGELU.extra_repr()
            • QuickGELU.float()
            • QuickGELU.forward()
            • QuickGELU.get_buffer()
            • QuickGELU.get_extra_state()
            • QuickGELU.get_parameter()
            • QuickGELU.get_submodule()
            • QuickGELU.half()
            • QuickGELU.ipu()
            • QuickGELU.load_state_dict()
            • QuickGELU.modules()
            • QuickGELU.named_buffers()
            • QuickGELU.named_children()
            • QuickGELU.named_modules()
            • QuickGELU.named_parameters()
            • QuickGELU.parameters()
            • QuickGELU.register_backward_hook()
            • QuickGELU.register_buffer()
            • QuickGELU.register_forward_hook()
            • QuickGELU.register_forward_pre_hook()
            • QuickGELU.register_full_backward_hook()
            • QuickGELU.register_full_backward_pre_hook()
            • QuickGELU.register_load_state_dict_post_hook()
            • QuickGELU.register_module()
            • QuickGELU.register_parameter()
            • QuickGELU.register_state_dict_pre_hook()
            • QuickGELU.requires_grad_()
            • QuickGELU.set_extra_state()
            • QuickGELU.share_memory()
            • QuickGELU.state_dict()
            • QuickGELU.to()
            • QuickGELU.to_empty()
            • QuickGELU.train()
            • QuickGELU.type()
            • QuickGELU.xpu()
            • QuickGELU.zero_grad()
        • towhee.models.clip.clip.ResidualAttentionBlock
          • ResidualAttentionBlock
            • ResidualAttentionBlock.__call__()
            • ResidualAttentionBlock.__init__()
            • ResidualAttentionBlock.__repr__()
            • ResidualAttentionBlock.add_module()
            • ResidualAttentionBlock.apply()
            • ResidualAttentionBlock.bfloat16()
            • ResidualAttentionBlock.buffers()
            • ResidualAttentionBlock.children()
            • ResidualAttentionBlock.cpu()
            • ResidualAttentionBlock.cuda()
            • ResidualAttentionBlock.double()
            • ResidualAttentionBlock.eval()
            • ResidualAttentionBlock.extra_repr()
            • ResidualAttentionBlock.float()
            • ResidualAttentionBlock.forward()
            • ResidualAttentionBlock.get_buffer()
            • ResidualAttentionBlock.get_extra_state()
            • ResidualAttentionBlock.get_parameter()
            • ResidualAttentionBlock.get_submodule()
            • ResidualAttentionBlock.half()
            • ResidualAttentionBlock.ipu()
            • ResidualAttentionBlock.load_state_dict()
            • ResidualAttentionBlock.modules()
            • ResidualAttentionBlock.named_buffers()
            • ResidualAttentionBlock.named_children()
            • ResidualAttentionBlock.named_modules()
            • ResidualAttentionBlock.named_parameters()
            • ResidualAttentionBlock.parameters()
            • ResidualAttentionBlock.register_backward_hook()
            • ResidualAttentionBlock.register_buffer()
            • ResidualAttentionBlock.register_forward_hook()
            • ResidualAttentionBlock.register_forward_pre_hook()
            • ResidualAttentionBlock.register_full_backward_hook()
            • ResidualAttentionBlock.register_full_backward_pre_hook()
            • ResidualAttentionBlock.register_load_state_dict_post_hook()
            • ResidualAttentionBlock.register_module()
            • ResidualAttentionBlock.register_parameter()
            • ResidualAttentionBlock.register_state_dict_pre_hook()
            • ResidualAttentionBlock.requires_grad_()
            • ResidualAttentionBlock.set_extra_state()
            • ResidualAttentionBlock.share_memory()
            • ResidualAttentionBlock.state_dict()
            • ResidualAttentionBlock.to()
            • ResidualAttentionBlock.to_empty()
            • ResidualAttentionBlock.train()
            • ResidualAttentionBlock.type()
            • ResidualAttentionBlock.xpu()
            • ResidualAttentionBlock.zero_grad()
        • towhee.models.clip.clip.Transformer
          • Transformer
            • Transformer.__call__()
            • Transformer.__init__()
            • Transformer.__repr__()
            • Transformer.add_module()
            • Transformer.apply()
            • Transformer.bfloat16()
            • Transformer.buffers()
            • Transformer.children()
            • Transformer.cpu()
            • Transformer.cuda()
            • Transformer.double()
            • Transformer.eval()
            • Transformer.extra_repr()
            • Transformer.float()
            • Transformer.forward()
            • Transformer.get_buffer()
            • Transformer.get_extra_state()
            • Transformer.get_parameter()
            • Transformer.get_submodule()
            • Transformer.half()
            • Transformer.ipu()
            • Transformer.load_state_dict()
            • Transformer.modules()
            • Transformer.named_buffers()
            • Transformer.named_children()
            • Transformer.named_modules()
            • Transformer.named_parameters()
            • Transformer.parameters()
            • Transformer.register_backward_hook()
            • Transformer.register_buffer()
            • Transformer.register_forward_hook()
            • Transformer.register_forward_pre_hook()
            • Transformer.register_full_backward_hook()
            • Transformer.register_full_backward_pre_hook()
            • Transformer.register_load_state_dict_post_hook()
            • Transformer.register_module()
            • Transformer.register_parameter()
            • Transformer.register_state_dict_pre_hook()
            • Transformer.requires_grad_()
            • Transformer.set_extra_state()
            • Transformer.share_memory()
            • Transformer.state_dict()
            • Transformer.to()
            • Transformer.to_empty()
            • Transformer.train()
            • Transformer.type()
            • Transformer.xpu()
            • Transformer.zero_grad()
        • towhee.models.clip.clip.VisionTransformer
          • VisionTransformer
            • VisionTransformer.__call__()
            • VisionTransformer.__init__()
            • VisionTransformer.__repr__()
            • VisionTransformer.add_module()
            • VisionTransformer.apply()
            • VisionTransformer.bfloat16()
            • VisionTransformer.buffers()
            • VisionTransformer.children()
            • VisionTransformer.cpu()
            • VisionTransformer.cuda()
            • VisionTransformer.double()
            • VisionTransformer.eval()
            • VisionTransformer.extra_repr()
            • VisionTransformer.float()
            • VisionTransformer.forward()
            • VisionTransformer.get_buffer()
            • VisionTransformer.get_extra_state()
            • VisionTransformer.get_parameter()
            • VisionTransformer.get_submodule()
            • VisionTransformer.half()
            • VisionTransformer.ipu()
            • VisionTransformer.load_state_dict()
            • VisionTransformer.modules()
            • VisionTransformer.named_buffers()
            • VisionTransformer.named_children()
            • VisionTransformer.named_modules()
            • VisionTransformer.named_parameters()
            • VisionTransformer.parameters()
            • VisionTransformer.register_backward_hook()
            • VisionTransformer.register_buffer()
            • VisionTransformer.register_forward_hook()
            • VisionTransformer.register_forward_pre_hook()
            • VisionTransformer.register_full_backward_hook()
            • VisionTransformer.register_full_backward_pre_hook()
            • VisionTransformer.register_load_state_dict_post_hook()
            • VisionTransformer.register_module()
            • VisionTransformer.register_parameter()
            • VisionTransformer.register_state_dict_pre_hook()
            • VisionTransformer.requires_grad_()
            • VisionTransformer.set_extra_state()
            • VisionTransformer.share_memory()
            • VisionTransformer.state_dict()
            • VisionTransformer.to()
            • VisionTransformer.to_empty()
            • VisionTransformer.train()
            • VisionTransformer.type()
            • VisionTransformer.xpu()
            • VisionTransformer.zero_grad()
      • towhee.models.clip.clip_utils
        • towhee.models.clip.clip_utils.base_configs
          • base_configs()
        • towhee.models.clip.clip_utils.convert_weights
          • convert_weights()
        • towhee.models.clip.clip_utils.get_configs
          • get_configs()
        • towhee.models.clip.clip_utils.get_transforms
          • get_transforms()
        • towhee.models.clip.clip_utils.patch_device
          • patch_device()
        • towhee.models.clip.clip_utils.patch_float
          • patch_float()
        • towhee.models.clip.clip_utils.tokenize
          • tokenize()
      • towhee.models.clip.simple_tokenizer
        • towhee.models.clip.simple_tokenizer.basic_clean
          • basic_clean()
        • towhee.models.clip.simple_tokenizer.bytes_to_unicode
          • bytes_to_unicode()
        • towhee.models.clip.simple_tokenizer.default_bpe
          • default_bpe()
        • towhee.models.clip.simple_tokenizer.get_pairs
          • get_pairs()
        • towhee.models.clip.simple_tokenizer.whitespace_clean
          • whitespace_clean()
        • towhee.models.clip.simple_tokenizer.SimpleTokenizer
          • SimpleTokenizer
            • SimpleTokenizer.__init__()
    • towhee.models.clip4clip
      • towhee.models.clip4clip.clip4clip
        • towhee.models.clip4clip.clip4clip.create_model
          • create_model()
        • towhee.models.clip4clip.clip4clip.CLIP4Clip
          • CLIP4Clip
            • CLIP4Clip.__call__()
            • CLIP4Clip.__init__()
            • CLIP4Clip.__repr__()
            • CLIP4Clip.add_module()
            • CLIP4Clip.apply()
            • CLIP4Clip.bfloat16()
            • CLIP4Clip.buffers()
            • CLIP4Clip.children()
            • CLIP4Clip.cpu()
            • CLIP4Clip.cuda()
            • CLIP4Clip.double()
            • CLIP4Clip.eval()
            • CLIP4Clip.extra_repr()
            • CLIP4Clip.float()
            • CLIP4Clip.forward()
            • CLIP4Clip.get_buffer()
            • CLIP4Clip.get_extra_state()
            • CLIP4Clip.get_parameter()
            • CLIP4Clip.get_submodule()
            • CLIP4Clip.half()
            • CLIP4Clip.init_weights()
            • CLIP4Clip.ipu()
            • CLIP4Clip.load_state_dict()
            • CLIP4Clip.modules()
            • CLIP4Clip.named_buffers()
            • CLIP4Clip.named_children()
            • CLIP4Clip.named_modules()
            • CLIP4Clip.named_parameters()
            • CLIP4Clip.parameters()
            • CLIP4Clip.register_backward_hook()
            • CLIP4Clip.register_buffer()
            • CLIP4Clip.register_forward_hook()
            • CLIP4Clip.register_forward_pre_hook()
            • CLIP4Clip.register_full_backward_hook()
            • CLIP4Clip.register_full_backward_pre_hook()
            • CLIP4Clip.register_load_state_dict_post_hook()
            • CLIP4Clip.register_module()
            • CLIP4Clip.register_parameter()
            • CLIP4Clip.register_state_dict_pre_hook()
            • CLIP4Clip.requires_grad_()
            • CLIP4Clip.set_extra_state()
            • CLIP4Clip.share_memory()
            • CLIP4Clip.state_dict()
            • CLIP4Clip.to()
            • CLIP4Clip.to_empty()
            • CLIP4Clip.train()
            • CLIP4Clip.type()
            • CLIP4Clip.xpu()
            • CLIP4Clip.zero_grad()
        • towhee.models.clip4clip.clip4clip.CLIP4ClipPreTrainedModel
          • CLIP4ClipPreTrainedModel
            • CLIP4ClipPreTrainedModel.__call__()
            • CLIP4ClipPreTrainedModel.__init__()
            • CLIP4ClipPreTrainedModel.__repr__()
            • CLIP4ClipPreTrainedModel.add_module()
            • CLIP4ClipPreTrainedModel.apply()
            • CLIP4ClipPreTrainedModel.bfloat16()
            • CLIP4ClipPreTrainedModel.buffers()
            • CLIP4ClipPreTrainedModel.children()
            • CLIP4ClipPreTrainedModel.cpu()
            • CLIP4ClipPreTrainedModel.cuda()
            • CLIP4ClipPreTrainedModel.double()
            • CLIP4ClipPreTrainedModel.eval()
            • CLIP4ClipPreTrainedModel.extra_repr()
            • CLIP4ClipPreTrainedModel.float()
            • CLIP4ClipPreTrainedModel.forward()
            • CLIP4ClipPreTrainedModel.get_buffer()
            • CLIP4ClipPreTrainedModel.get_extra_state()
            • CLIP4ClipPreTrainedModel.get_parameter()
            • CLIP4ClipPreTrainedModel.get_submodule()
            • CLIP4ClipPreTrainedModel.half()
            • CLIP4ClipPreTrainedModel.init_weights()
            • CLIP4ClipPreTrainedModel.ipu()
            • CLIP4ClipPreTrainedModel.load_state_dict()
            • CLIP4ClipPreTrainedModel.modules()
            • CLIP4ClipPreTrainedModel.named_buffers()
            • CLIP4ClipPreTrainedModel.named_children()
            • CLIP4ClipPreTrainedModel.named_modules()
            • CLIP4ClipPreTrainedModel.named_parameters()
            • CLIP4ClipPreTrainedModel.parameters()
            • CLIP4ClipPreTrainedModel.register_backward_hook()
            • CLIP4ClipPreTrainedModel.register_buffer()
            • CLIP4ClipPreTrainedModel.register_forward_hook()
            • CLIP4ClipPreTrainedModel.register_forward_pre_hook()
            • CLIP4ClipPreTrainedModel.register_full_backward_hook()
            • CLIP4ClipPreTrainedModel.register_full_backward_pre_hook()
            • CLIP4ClipPreTrainedModel.register_load_state_dict_post_hook()
            • CLIP4ClipPreTrainedModel.register_module()
            • CLIP4ClipPreTrainedModel.register_parameter()
            • CLIP4ClipPreTrainedModel.register_state_dict_pre_hook()
            • CLIP4ClipPreTrainedModel.requires_grad_()
            • CLIP4ClipPreTrainedModel.set_extra_state()
            • CLIP4ClipPreTrainedModel.share_memory()
            • CLIP4ClipPreTrainedModel.state_dict()
            • CLIP4ClipPreTrainedModel.to()
            • CLIP4ClipPreTrainedModel.to_empty()
            • CLIP4ClipPreTrainedModel.train()
            • CLIP4ClipPreTrainedModel.type()
            • CLIP4ClipPreTrainedModel.xpu()
            • CLIP4ClipPreTrainedModel.zero_grad()
      • towhee.models.clip4clip.until_module
        • towhee.models.clip4clip.until_module.CrossEn
          • CrossEn
            • CrossEn.__call__()
            • CrossEn.__init__()
            • CrossEn.__repr__()
            • CrossEn.add_module()
            • CrossEn.apply()
            • CrossEn.bfloat16()
            • CrossEn.buffers()
            • CrossEn.children()
            • CrossEn.cpu()
            • CrossEn.cuda()
            • CrossEn.double()
            • CrossEn.eval()
            • CrossEn.extra_repr()
            • CrossEn.float()
            • CrossEn.forward()
            • CrossEn.get_buffer()
            • CrossEn.get_extra_state()
            • CrossEn.get_parameter()
            • CrossEn.get_submodule()
            • CrossEn.half()
            • CrossEn.ipu()
            • CrossEn.load_state_dict()
            • CrossEn.modules()
            • CrossEn.named_buffers()
            • CrossEn.named_children()
            • CrossEn.named_modules()
            • CrossEn.named_parameters()
            • CrossEn.parameters()
            • CrossEn.register_backward_hook()
            • CrossEn.register_buffer()
            • CrossEn.register_forward_hook()
            • CrossEn.register_forward_pre_hook()
            • CrossEn.register_full_backward_hook()
            • CrossEn.register_full_backward_pre_hook()
            • CrossEn.register_load_state_dict_post_hook()
            • CrossEn.register_module()
            • CrossEn.register_parameter()
            • CrossEn.register_state_dict_pre_hook()
            • CrossEn.requires_grad_()
            • CrossEn.set_extra_state()
            • CrossEn.share_memory()
            • CrossEn.state_dict()
            • CrossEn.to()
            • CrossEn.to_empty()
            • CrossEn.train()
            • CrossEn.type()
            • CrossEn.xpu()
            • CrossEn.zero_grad()
        • towhee.models.clip4clip.until_module.LayerNorm
          • LayerNorm
            • LayerNorm.__call__()
            • LayerNorm.__init__()
            • LayerNorm.__repr__()
            • LayerNorm.add_module()
            • LayerNorm.apply()
            • LayerNorm.bfloat16()
            • LayerNorm.buffers()
            • LayerNorm.children()
            • LayerNorm.cpu()
            • LayerNorm.cuda()
            • LayerNorm.double()
            • LayerNorm.eval()
            • LayerNorm.extra_repr()
            • LayerNorm.float()
            • LayerNorm.forward()
            • LayerNorm.get_buffer()
            • LayerNorm.get_extra_state()
            • LayerNorm.get_parameter()
            • LayerNorm.get_submodule()
            • LayerNorm.half()
            • LayerNorm.ipu()
            • LayerNorm.load_state_dict()
            • LayerNorm.modules()
            • LayerNorm.named_buffers()
            • LayerNorm.named_children()
            • LayerNorm.named_modules()
            • LayerNorm.named_parameters()
            • LayerNorm.parameters()
            • LayerNorm.register_backward_hook()
            • LayerNorm.register_buffer()
            • LayerNorm.register_forward_hook()
            • LayerNorm.register_forward_pre_hook()
            • LayerNorm.register_full_backward_hook()
            • LayerNorm.register_full_backward_pre_hook()
            • LayerNorm.register_load_state_dict_post_hook()
            • LayerNorm.register_module()
            • LayerNorm.register_parameter()
            • LayerNorm.register_state_dict_pre_hook()
            • LayerNorm.requires_grad_()
            • LayerNorm.set_extra_state()
            • LayerNorm.share_memory()
            • LayerNorm.state_dict()
            • LayerNorm.to()
            • LayerNorm.to_empty()
            • LayerNorm.train()
            • LayerNorm.type()
            • LayerNorm.xpu()
            • LayerNorm.zero_grad()
        • towhee.models.clip4clip.until_module.PreTrainedModel
          • PreTrainedModel
            • PreTrainedModel.__call__()
            • PreTrainedModel.__init__()
            • PreTrainedModel.__repr__()
            • PreTrainedModel.add_module()
            • PreTrainedModel.apply()
            • PreTrainedModel.bfloat16()
            • PreTrainedModel.buffers()
            • PreTrainedModel.children()
            • PreTrainedModel.cpu()
            • PreTrainedModel.cuda()
            • PreTrainedModel.double()
            • PreTrainedModel.eval()
            • PreTrainedModel.extra_repr()
            • PreTrainedModel.float()
            • PreTrainedModel.forward()
            • PreTrainedModel.get_buffer()
            • PreTrainedModel.get_extra_state()
            • PreTrainedModel.get_parameter()
            • PreTrainedModel.get_submodule()
            • PreTrainedModel.half()
            • PreTrainedModel.init_weights()
            • PreTrainedModel.ipu()
            • PreTrainedModel.load_state_dict()
            • PreTrainedModel.modules()
            • PreTrainedModel.named_buffers()
            • PreTrainedModel.named_children()
            • PreTrainedModel.named_modules()
            • PreTrainedModel.named_parameters()
            • PreTrainedModel.parameters()
            • PreTrainedModel.register_backward_hook()
            • PreTrainedModel.register_buffer()
            • PreTrainedModel.register_forward_hook()
            • PreTrainedModel.register_forward_pre_hook()
            • PreTrainedModel.register_full_backward_hook()
            • PreTrainedModel.register_full_backward_pre_hook()
            • PreTrainedModel.register_load_state_dict_post_hook()
            • PreTrainedModel.register_module()
            • PreTrainedModel.register_parameter()
            • PreTrainedModel.register_state_dict_pre_hook()
            • PreTrainedModel.requires_grad_()
            • PreTrainedModel.set_extra_state()
            • PreTrainedModel.share_memory()
            • PreTrainedModel.state_dict()
            • PreTrainedModel.to()
            • PreTrainedModel.to_empty()
            • PreTrainedModel.train()
            • PreTrainedModel.type()
            • PreTrainedModel.xpu()
            • PreTrainedModel.zero_grad()
      • towhee.models.clip4clip.utils
        • towhee.models.clip4clip.utils.convert_tokens_to_id
          • convert_tokens_to_id()
        • towhee.models.clip4clip.utils.tokenize
          • tokenize()
    • towhee.models.coca
      • towhee.models.coca.coca
        • towhee.models.coca.coca.CoCa
          • CoCa
            • CoCa.__call__()
            • CoCa.__init__()
            • CoCa.__repr__()
            • CoCa.add_module()
            • CoCa.apply()
            • CoCa.bfloat16()
            • CoCa.buffers()
            • CoCa.children()
            • CoCa.cpu()
            • CoCa.cuda()
            • CoCa.double()
            • CoCa.eval()
            • CoCa.extra_repr()
            • CoCa.float()
            • CoCa.forward()
            • CoCa.get_buffer()
            • CoCa.get_extra_state()
            • CoCa.get_parameter()
            • CoCa.get_submodule()
            • CoCa.half()
            • CoCa.ipu()
            • CoCa.load_state_dict()
            • CoCa.modules()
            • CoCa.named_buffers()
            • CoCa.named_children()
            • CoCa.named_modules()
            • CoCa.named_parameters()
            • CoCa.parameters()
            • CoCa.register_backward_hook()
            • CoCa.register_buffer()
            • CoCa.register_forward_hook()
            • CoCa.register_forward_pre_hook()
            • CoCa.register_full_backward_hook()
            • CoCa.register_full_backward_pre_hook()
            • CoCa.register_load_state_dict_post_hook()
            • CoCa.register_module()
            • CoCa.register_parameter()
            • CoCa.register_state_dict_pre_hook()
            • CoCa.requires_grad_()
            • CoCa.set_extra_state()
            • CoCa.share_memory()
            • CoCa.state_dict()
            • CoCa.to()
            • CoCa.to_empty()
            • CoCa.train()
            • CoCa.type()
            • CoCa.xpu()
            • CoCa.zero_grad()
        • towhee.models.coca.coca.ParallelTransformerBlock
          • ParallelTransformerBlock
            • ParallelTransformerBlock.__call__()
            • ParallelTransformerBlock.__init__()
            • ParallelTransformerBlock.__repr__()
            • ParallelTransformerBlock.add_module()
            • ParallelTransformerBlock.apply()
            • ParallelTransformerBlock.bfloat16()
            • ParallelTransformerBlock.buffers()
            • ParallelTransformerBlock.children()
            • ParallelTransformerBlock.cpu()
            • ParallelTransformerBlock.cuda()
            • ParallelTransformerBlock.double()
            • ParallelTransformerBlock.eval()
            • ParallelTransformerBlock.extra_repr()
            • ParallelTransformerBlock.float()
            • ParallelTransformerBlock.forward()
            • ParallelTransformerBlock.get_buffer()
            • ParallelTransformerBlock.get_extra_state()
            • ParallelTransformerBlock.get_parameter()
            • ParallelTransformerBlock.get_submodule()
            • ParallelTransformerBlock.half()
            • ParallelTransformerBlock.ipu()
            • ParallelTransformerBlock.load_state_dict()
            • ParallelTransformerBlock.modules()
            • ParallelTransformerBlock.named_buffers()
            • ParallelTransformerBlock.named_children()
            • ParallelTransformerBlock.named_modules()
            • ParallelTransformerBlock.named_parameters()
            • ParallelTransformerBlock.parameters()
            • ParallelTransformerBlock.register_backward_hook()
            • ParallelTransformerBlock.register_buffer()
            • ParallelTransformerBlock.register_forward_hook()
            • ParallelTransformerBlock.register_forward_pre_hook()
            • ParallelTransformerBlock.register_full_backward_hook()
            • ParallelTransformerBlock.register_full_backward_pre_hook()
            • ParallelTransformerBlock.register_load_state_dict_post_hook()
            • ParallelTransformerBlock.register_module()
            • ParallelTransformerBlock.register_parameter()
            • ParallelTransformerBlock.register_state_dict_pre_hook()
            • ParallelTransformerBlock.requires_grad_()
            • ParallelTransformerBlock.set_extra_state()
            • ParallelTransformerBlock.share_memory()
            • ParallelTransformerBlock.state_dict()
            • ParallelTransformerBlock.to()
            • ParallelTransformerBlock.to_empty()
            • ParallelTransformerBlock.train()
            • ParallelTransformerBlock.type()
            • ParallelTransformerBlock.xpu()
            • ParallelTransformerBlock.zero_grad()
    • towhee.models.coformer
      • towhee.models.coformer.backbone
        • towhee.models.coformer.backbone.build_backbone
          • build_backbone()
        • towhee.models.coformer.backbone.Backbone
          • Backbone
            • Backbone.__call__()
            • Backbone.__init__()
            • Backbone.__repr__()
            • Backbone.add_module()
            • Backbone.apply()
            • Backbone.bfloat16()
            • Backbone.buffers()
            • Backbone.children()
            • Backbone.cpu()
            • Backbone.cuda()
            • Backbone.double()
            • Backbone.eval()
            • Backbone.extra_repr()
            • Backbone.float()
            • Backbone.forward()
            • Backbone.get_buffer()
            • Backbone.get_extra_state()
            • Backbone.get_parameter()
            • Backbone.get_submodule()
            • Backbone.half()
            • Backbone.ipu()
            • Backbone.load_state_dict()
            • Backbone.modules()
            • Backbone.named_buffers()
            • Backbone.named_children()
            • Backbone.named_modules()
            • Backbone.named_parameters()
            • Backbone.parameters()
            • Backbone.register_backward_hook()
            • Backbone.register_buffer()
            • Backbone.register_forward_hook()
            • Backbone.register_forward_pre_hook()
            • Backbone.register_full_backward_hook()
            • Backbone.register_full_backward_pre_hook()
            • Backbone.register_load_state_dict_post_hook()
            • Backbone.register_module()
            • Backbone.register_parameter()
            • Backbone.register_state_dict_pre_hook()
            • Backbone.requires_grad_()
            • Backbone.set_extra_state()
            • Backbone.share_memory()
            • Backbone.state_dict()
            • Backbone.to()
            • Backbone.to_empty()
            • Backbone.train()
            • Backbone.type()
            • Backbone.xpu()
            • Backbone.zero_grad()
        • towhee.models.coformer.backbone.BackboneBase
          • BackboneBase
            • BackboneBase.__call__()
            • BackboneBase.__init__()
            • BackboneBase.__repr__()
            • BackboneBase.add_module()
            • BackboneBase.apply()
            • BackboneBase.bfloat16()
            • BackboneBase.buffers()
            • BackboneBase.children()
            • BackboneBase.cpu()
            • BackboneBase.cuda()
            • BackboneBase.double()
            • BackboneBase.eval()
            • BackboneBase.extra_repr()
            • BackboneBase.float()
            • BackboneBase.forward()
            • BackboneBase.get_buffer()
            • BackboneBase.get_extra_state()
            • BackboneBase.get_parameter()
            • BackboneBase.get_submodule()
            • BackboneBase.half()
            • BackboneBase.ipu()
            • BackboneBase.load_state_dict()
            • BackboneBase.modules()
            • BackboneBase.named_buffers()
            • BackboneBase.named_children()
            • BackboneBase.named_modules()
            • BackboneBase.named_parameters()
            • BackboneBase.parameters()
            • BackboneBase.register_backward_hook()
            • BackboneBase.register_buffer()
            • BackboneBase.register_forward_hook()
            • BackboneBase.register_forward_pre_hook()
            • BackboneBase.register_full_backward_hook()
            • BackboneBase.register_full_backward_pre_hook()
            • BackboneBase.register_load_state_dict_post_hook()
            • BackboneBase.register_module()
            • BackboneBase.register_parameter()
            • BackboneBase.register_state_dict_pre_hook()
            • BackboneBase.requires_grad_()
            • BackboneBase.set_extra_state()
            • BackboneBase.share_memory()
            • BackboneBase.state_dict()
            • BackboneBase.to()
            • BackboneBase.to_empty()
            • BackboneBase.train()
            • BackboneBase.type()
            • BackboneBase.xpu()
            • BackboneBase.zero_grad()
        • towhee.models.coformer.backbone.Joiner
          • Joiner
            • Joiner.__call__()
            • Joiner.__init__()
            • Joiner.__repr__()
            • Joiner.add_module()
            • Joiner.append()
            • Joiner.apply()
            • Joiner.bfloat16()
            • Joiner.buffers()
            • Joiner.children()
            • Joiner.cpu()
            • Joiner.cuda()
            • Joiner.double()
            • Joiner.eval()
            • Joiner.extra_repr()
            • Joiner.float()
            • Joiner.forward()
            • Joiner.get_buffer()
            • Joiner.get_extra_state()
            • Joiner.get_parameter()
            • Joiner.get_submodule()
            • Joiner.half()
            • Joiner.ipu()
            • Joiner.load_state_dict()
            • Joiner.modules()
            • Joiner.named_buffers()
            • Joiner.named_children()
            • Joiner.named_modules()
            • Joiner.named_parameters()
            • Joiner.parameters()
            • Joiner.register_backward_hook()
            • Joiner.register_buffer()
            • Joiner.register_forward_hook()
            • Joiner.register_forward_pre_hook()
            • Joiner.register_full_backward_hook()
            • Joiner.register_full_backward_pre_hook()
            • Joiner.register_load_state_dict_post_hook()
            • Joiner.register_module()
            • Joiner.register_parameter()
            • Joiner.register_state_dict_pre_hook()
            • Joiner.requires_grad_()
            • Joiner.set_extra_state()
            • Joiner.share_memory()
            • Joiner.state_dict()
            • Joiner.to()
            • Joiner.to_empty()
            • Joiner.train()
            • Joiner.type()
            • Joiner.xpu()
            • Joiner.zero_grad()
      • towhee.models.coformer.coformer
        • towhee.models.coformer.coformer.create_model
          • create_model()
        • towhee.models.coformer.coformer.CoFormer
          • CoFormer
            • CoFormer.__call__()
            • CoFormer.__init__()
            • CoFormer.__repr__()
            • CoFormer.add_module()
            • CoFormer.apply()
            • CoFormer.bfloat16()
            • CoFormer.buffers()
            • CoFormer.children()
            • CoFormer.cpu()
            • CoFormer.cuda()
            • CoFormer.double()
            • CoFormer.eval()
            • CoFormer.extra_repr()
            • CoFormer.float()
            • CoFormer.forward()
            • CoFormer.get_buffer()
            • CoFormer.get_extra_state()
            • CoFormer.get_parameter()
            • CoFormer.get_submodule()
            • CoFormer.half()
            • CoFormer.ipu()
            • CoFormer.load_state_dict()
            • CoFormer.modules()
            • CoFormer.named_buffers()
            • CoFormer.named_children()
            • CoFormer.named_modules()
            • CoFormer.named_parameters()
            • CoFormer.parameters()
            • CoFormer.register_backward_hook()
            • CoFormer.register_buffer()
            • CoFormer.register_forward_hook()
            • CoFormer.register_forward_pre_hook()
            • CoFormer.register_full_backward_hook()
            • CoFormer.register_full_backward_pre_hook()
            • CoFormer.register_load_state_dict_post_hook()
            • CoFormer.register_module()
            • CoFormer.register_parameter()
            • CoFormer.register_state_dict_pre_hook()
            • CoFormer.requires_grad_()
            • CoFormer.set_extra_state()
            • CoFormer.share_memory()
            • CoFormer.state_dict()
            • CoFormer.to()
            • CoFormer.to_empty()
            • CoFormer.train()
            • CoFormer.type()
            • CoFormer.xpu()
            • CoFormer.zero_grad()
      • towhee.models.coformer.config
      • towhee.models.coformer.transformer
        • towhee.models.coformer.transformer.build_transformer
          • build_transformer()
        • towhee.models.coformer.transformer.Transformer
          • Transformer
            • Transformer.__call__()
            • Transformer.__init__()
            • Transformer.__repr__()
            • Transformer.add_module()
            • Transformer.apply()
            • Transformer.bfloat16()
            • Transformer.buffers()
            • Transformer.children()
            • Transformer.cpu()
            • Transformer.cuda()
            • Transformer.double()
            • Transformer.eval()
            • Transformer.extra_repr()
            • Transformer.float()
            • Transformer.forward()
            • Transformer.get_buffer()
            • Transformer.get_extra_state()
            • Transformer.get_parameter()
            • Transformer.get_submodule()
            • Transformer.half()
            • Transformer.ipu()
            • Transformer.load_state_dict()
            • Transformer.modules()
            • Transformer.named_buffers()
            • Transformer.named_children()
            • Transformer.named_modules()
            • Transformer.named_parameters()
            • Transformer.parameters()
            • Transformer.register_backward_hook()
            • Transformer.register_buffer()
            • Transformer.register_forward_hook()
            • Transformer.register_forward_pre_hook()
            • Transformer.register_full_backward_hook()
            • Transformer.register_full_backward_pre_hook()
            • Transformer.register_load_state_dict_post_hook()
            • Transformer.register_module()
            • Transformer.register_parameter()
            • Transformer.register_state_dict_pre_hook()
            • Transformer.requires_grad_()
            • Transformer.set_extra_state()
            • Transformer.share_memory()
            • Transformer.state_dict()
            • Transformer.to()
            • Transformer.to_empty()
            • Transformer.train()
            • Transformer.type()
            • Transformer.xpu()
            • Transformer.zero_grad()
        • towhee.models.coformer.transformer.TransformerDecoder
          • TransformerDecoder
            • TransformerDecoder.__call__()
            • TransformerDecoder.__init__()
            • TransformerDecoder.__repr__()
            • TransformerDecoder.add_module()
            • TransformerDecoder.apply()
            • TransformerDecoder.bfloat16()
            • TransformerDecoder.buffers()
            • TransformerDecoder.children()
            • TransformerDecoder.cpu()
            • TransformerDecoder.cuda()
            • TransformerDecoder.double()
            • TransformerDecoder.eval()
            • TransformerDecoder.extra_repr()
            • TransformerDecoder.float()
            • TransformerDecoder.forward()
            • TransformerDecoder.get_buffer()
            • TransformerDecoder.get_extra_state()
            • TransformerDecoder.get_parameter()
            • TransformerDecoder.get_submodule()
            • TransformerDecoder.half()
            • TransformerDecoder.ipu()
            • TransformerDecoder.load_state_dict()
            • TransformerDecoder.modules()
            • TransformerDecoder.named_buffers()
            • TransformerDecoder.named_children()
            • TransformerDecoder.named_modules()
            • TransformerDecoder.named_parameters()
            • TransformerDecoder.parameters()
            • TransformerDecoder.register_backward_hook()
            • TransformerDecoder.register_buffer()
            • TransformerDecoder.register_forward_hook()
            • TransformerDecoder.register_forward_pre_hook()
            • TransformerDecoder.register_full_backward_hook()
            • TransformerDecoder.register_full_backward_pre_hook()
            • TransformerDecoder.register_load_state_dict_post_hook()
            • TransformerDecoder.register_module()
            • TransformerDecoder.register_parameter()
            • TransformerDecoder.register_state_dict_pre_hook()
            • TransformerDecoder.requires_grad_()
            • TransformerDecoder.set_extra_state()
            • TransformerDecoder.share_memory()
            • TransformerDecoder.state_dict()
            • TransformerDecoder.to()
            • TransformerDecoder.to_empty()
            • TransformerDecoder.train()
            • TransformerDecoder.type()
            • TransformerDecoder.xpu()
            • TransformerDecoder.zero_grad()
        • towhee.models.coformer.transformer.TransformerDecoderLayer
          • TransformerDecoderLayer
            • TransformerDecoderLayer.__call__()
            • TransformerDecoderLayer.__init__()
            • TransformerDecoderLayer.__repr__()
            • TransformerDecoderLayer.add_module()
            • TransformerDecoderLayer.apply()
            • TransformerDecoderLayer.bfloat16()
            • TransformerDecoderLayer.buffers()
            • TransformerDecoderLayer.children()
            • TransformerDecoderLayer.cpu()
            • TransformerDecoderLayer.cuda()
            • TransformerDecoderLayer.double()
            • TransformerDecoderLayer.eval()
            • TransformerDecoderLayer.extra_repr()
            • TransformerDecoderLayer.float()
            • TransformerDecoderLayer.forward()
            • TransformerDecoderLayer.get_buffer()
            • TransformerDecoderLayer.get_extra_state()
            • TransformerDecoderLayer.get_parameter()
            • TransformerDecoderLayer.get_submodule()
            • TransformerDecoderLayer.half()
            • TransformerDecoderLayer.ipu()
            • TransformerDecoderLayer.load_state_dict()
            • TransformerDecoderLayer.modules()
            • TransformerDecoderLayer.named_buffers()
            • TransformerDecoderLayer.named_children()
            • TransformerDecoderLayer.named_modules()
            • TransformerDecoderLayer.named_parameters()
            • TransformerDecoderLayer.parameters()
            • TransformerDecoderLayer.register_backward_hook()
            • TransformerDecoderLayer.register_buffer()
            • TransformerDecoderLayer.register_forward_hook()
            • TransformerDecoderLayer.register_forward_pre_hook()
            • TransformerDecoderLayer.register_full_backward_hook()
            • TransformerDecoderLayer.register_full_backward_pre_hook()
            • TransformerDecoderLayer.register_load_state_dict_post_hook()
            • TransformerDecoderLayer.register_module()
            • TransformerDecoderLayer.register_parameter()
            • TransformerDecoderLayer.register_state_dict_pre_hook()
            • TransformerDecoderLayer.requires_grad_()
            • TransformerDecoderLayer.set_extra_state()
            • TransformerDecoderLayer.share_memory()
            • TransformerDecoderLayer.state_dict()
            • TransformerDecoderLayer.to()
            • TransformerDecoderLayer.to_empty()
            • TransformerDecoderLayer.train()
            • TransformerDecoderLayer.type()
            • TransformerDecoderLayer.xpu()
            • TransformerDecoderLayer.zero_grad()
        • towhee.models.coformer.transformer.TransformerEncoder
          • TransformerEncoder
            • TransformerEncoder.__call__()
            • TransformerEncoder.__init__()
            • TransformerEncoder.__repr__()
            • TransformerEncoder.add_module()
            • TransformerEncoder.apply()
            • TransformerEncoder.bfloat16()
            • TransformerEncoder.buffers()
            • TransformerEncoder.children()
            • TransformerEncoder.cpu()
            • TransformerEncoder.cuda()
            • TransformerEncoder.double()
            • TransformerEncoder.eval()
            • TransformerEncoder.extra_repr()
            • TransformerEncoder.float()
            • TransformerEncoder.forward()
            • TransformerEncoder.get_buffer()
            • TransformerEncoder.get_extra_state()
            • TransformerEncoder.get_parameter()
            • TransformerEncoder.get_submodule()
            • TransformerEncoder.half()
            • TransformerEncoder.ipu()
            • TransformerEncoder.load_state_dict()
            • TransformerEncoder.modules()
            • TransformerEncoder.named_buffers()
            • TransformerEncoder.named_children()
            • TransformerEncoder.named_modules()
            • TransformerEncoder.named_parameters()
            • TransformerEncoder.parameters()
            • TransformerEncoder.register_backward_hook()
            • TransformerEncoder.register_buffer()
            • TransformerEncoder.register_forward_hook()
            • TransformerEncoder.register_forward_pre_hook()
            • TransformerEncoder.register_full_backward_hook()
            • TransformerEncoder.register_full_backward_pre_hook()
            • TransformerEncoder.register_load_state_dict_post_hook()
            • TransformerEncoder.register_module()
            • TransformerEncoder.register_parameter()
            • TransformerEncoder.register_state_dict_pre_hook()
            • TransformerEncoder.requires_grad_()
            • TransformerEncoder.set_extra_state()
            • TransformerEncoder.share_memory()
            • TransformerEncoder.state_dict()
            • TransformerEncoder.to()
            • TransformerEncoder.to_empty()
            • TransformerEncoder.train()
            • TransformerEncoder.type()
            • TransformerEncoder.xpu()
            • TransformerEncoder.zero_grad()
        • towhee.models.coformer.transformer.TransformerEncoderLayer
          • TransformerEncoderLayer
            • TransformerEncoderLayer.__call__()
            • TransformerEncoderLayer.__init__()
            • TransformerEncoderLayer.__repr__()
            • TransformerEncoderLayer.add_module()
            • TransformerEncoderLayer.apply()
            • TransformerEncoderLayer.bfloat16()
            • TransformerEncoderLayer.buffers()
            • TransformerEncoderLayer.children()
            • TransformerEncoderLayer.cpu()
            • TransformerEncoderLayer.cuda()
            • TransformerEncoderLayer.double()
            • TransformerEncoderLayer.eval()
            • TransformerEncoderLayer.extra_repr()
            • TransformerEncoderLayer.float()
            • TransformerEncoderLayer.forward()
            • TransformerEncoderLayer.get_buffer()
            • TransformerEncoderLayer.get_extra_state()
            • TransformerEncoderLayer.get_parameter()
            • TransformerEncoderLayer.get_submodule()
            • TransformerEncoderLayer.half()
            • TransformerEncoderLayer.ipu()
            • TransformerEncoderLayer.load_state_dict()
            • TransformerEncoderLayer.modules()
            • TransformerEncoderLayer.named_buffers()
            • TransformerEncoderLayer.named_children()
            • TransformerEncoderLayer.named_modules()
            • TransformerEncoderLayer.named_parameters()
            • TransformerEncoderLayer.parameters()
            • TransformerEncoderLayer.register_backward_hook()
            • TransformerEncoderLayer.register_buffer()
            • TransformerEncoderLayer.register_forward_hook()
            • TransformerEncoderLayer.register_forward_pre_hook()
            • TransformerEncoderLayer.register_full_backward_hook()
            • TransformerEncoderLayer.register_full_backward_pre_hook()
            • TransformerEncoderLayer.register_load_state_dict_post_hook()
            • TransformerEncoderLayer.register_module()
            • TransformerEncoderLayer.register_parameter()
            • TransformerEncoderLayer.register_state_dict_pre_hook()
            • TransformerEncoderLayer.requires_grad_()
            • TransformerEncoderLayer.set_extra_state()
            • TransformerEncoderLayer.share_memory()
            • TransformerEncoderLayer.state_dict()
            • TransformerEncoderLayer.to()
            • TransformerEncoderLayer.to_empty()
            • TransformerEncoderLayer.train()
            • TransformerEncoderLayer.type()
            • TransformerEncoderLayer.xpu()
            • TransformerEncoderLayer.zero_grad()
      • towhee.models.coformer.utils
        • towhee.models.coformer.utils.get_rank
          • get_rank()
        • towhee.models.coformer.utils.is_dist_avail_and_initialized
          • is_dist_avail_and_initialized()
        • towhee.models.coformer.utils.is_main_process
          • is_main_process()
        • towhee.models.coformer.utils.nested_tensor_from_tensor_list
          • nested_tensor_from_tensor_list()
        • towhee.models.coformer.utils.NestedTensor
          • NestedTensor
            • NestedTensor.__init__()
            • NestedTensor.__repr__()
    • towhee.models.collaborative_experts
      • towhee.models.collaborative_experts.collaborative_experts
        • towhee.models.collaborative_experts.collaborative_experts.create_model
          • create_model()
        • towhee.models.collaborative_experts.collaborative_experts.drop_nans
          • drop_nans()
        • towhee.models.collaborative_experts.collaborative_experts.kronecker_prod
          • kronecker_prod()
        • towhee.models.collaborative_experts.collaborative_experts.sharded_cross_view_inner_product
          • sharded_cross_view_inner_product()
        • towhee.models.collaborative_experts.collaborative_experts.sharded_single_view_inner_product
          • sharded_single_view_inner_product()
        • towhee.models.collaborative_experts.collaborative_experts.CEModule
          • CEModule
            • CEModule.__call__()
            • CEModule.__init__()
            • CEModule.__repr__()
            • CEModule.add_module()
            • CEModule.apply()
            • CEModule.bfloat16()
            • CEModule.buffers()
            • CEModule.children()
            • CEModule.cpu()
            • CEModule.cuda()
            • CEModule.double()
            • CEModule.eval()
            • CEModule.extra_repr()
            • CEModule.float()
            • CEModule.forward()
            • CEModule.get_buffer()
            • CEModule.get_extra_state()
            • CEModule.get_parameter()
            • CEModule.get_submodule()
            • CEModule.half()
            • CEModule.ipu()
            • CEModule.load_state_dict()
            • CEModule.modules()
            • CEModule.named_buffers()
            • CEModule.named_children()
            • CEModule.named_modules()
            • CEModule.named_parameters()
            • CEModule.parameters()
            • CEModule.register_backward_hook()
            • CEModule.register_buffer()
            • CEModule.register_forward_hook()
            • CEModule.register_forward_pre_hook()
            • CEModule.register_full_backward_hook()
            • CEModule.register_full_backward_pre_hook()
            • CEModule.register_load_state_dict_post_hook()
            • CEModule.register_module()
            • CEModule.register_parameter()
            • CEModule.register_state_dict_pre_hook()
            • CEModule.requires_grad_()
            • CEModule.set_extra_state()
            • CEModule.share_memory()
            • CEModule.state_dict()
            • CEModule.to()
            • CEModule.to_empty()
            • CEModule.train()
            • CEModule.type()
            • CEModule.xpu()
            • CEModule.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.CENet
          • CENet
            • CENet.__call__()
            • CENet.__init__()
            • CENet.__repr__()
            • CENet.add_module()
            • CENet.apply()
            • CENet.bfloat16()
            • CENet.buffers()
            • CENet.children()
            • CENet.cpu()
            • CENet.cuda()
            • CENet.double()
            • CENet.eval()
            • CENet.extra_repr()
            • CENet.float()
            • CENet.forward()
            • CENet.get_buffer()
            • CENet.get_extra_state()
            • CENet.get_parameter()
            • CENet.get_submodule()
            • CENet.half()
            • CENet.ipu()
            • CENet.load_state_dict()
            • CENet.modules()
            • CENet.named_buffers()
            • CENet.named_children()
            • CENet.named_modules()
            • CENet.named_parameters()
            • CENet.parameters()
            • CENet.register_backward_hook()
            • CENet.register_buffer()
            • CENet.register_forward_hook()
            • CENet.register_forward_pre_hook()
            • CENet.register_full_backward_hook()
            • CENet.register_full_backward_pre_hook()
            • CENet.register_load_state_dict_post_hook()
            • CENet.register_module()
            • CENet.register_parameter()
            • CENet.register_state_dict_pre_hook()
            • CENet.requires_grad_()
            • CENet.set_extra_state()
            • CENet.share_memory()
            • CENet.state_dict()
            • CENet.to()
            • CENet.to_empty()
            • CENet.train()
            • CENet.type()
            • CENet.xpu()
            • CENet.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.ContextGating
          • ContextGating
            • ContextGating.__call__()
            • ContextGating.__init__()
            • ContextGating.__repr__()
            • ContextGating.add_module()
            • ContextGating.apply()
            • ContextGating.bfloat16()
            • ContextGating.buffers()
            • ContextGating.children()
            • ContextGating.cpu()
            • ContextGating.cuda()
            • ContextGating.double()
            • ContextGating.eval()
            • ContextGating.extra_repr()
            • ContextGating.float()
            • ContextGating.forward()
            • ContextGating.get_buffer()
            • ContextGating.get_extra_state()
            • ContextGating.get_parameter()
            • ContextGating.get_submodule()
            • ContextGating.half()
            • ContextGating.ipu()
            • ContextGating.load_state_dict()
            • ContextGating.modules()
            • ContextGating.named_buffers()
            • ContextGating.named_children()
            • ContextGating.named_modules()
            • ContextGating.named_parameters()
            • ContextGating.parameters()
            • ContextGating.register_backward_hook()
            • ContextGating.register_buffer()
            • ContextGating.register_forward_hook()
            • ContextGating.register_forward_pre_hook()
            • ContextGating.register_full_backward_hook()
            • ContextGating.register_full_backward_pre_hook()
            • ContextGating.register_load_state_dict_post_hook()
            • ContextGating.register_module()
            • ContextGating.register_parameter()
            • ContextGating.register_state_dict_pre_hook()
            • ContextGating.requires_grad_()
            • ContextGating.set_extra_state()
            • ContextGating.share_memory()
            • ContextGating.state_dict()
            • ContextGating.to()
            • ContextGating.to_empty()
            • ContextGating.train()
            • ContextGating.type()
            • ContextGating.xpu()
            • ContextGating.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.ContextGatingReasoning
          • ContextGatingReasoning
            • ContextGatingReasoning.__call__()
            • ContextGatingReasoning.__init__()
            • ContextGatingReasoning.__repr__()
            • ContextGatingReasoning.add_module()
            • ContextGatingReasoning.apply()
            • ContextGatingReasoning.bfloat16()
            • ContextGatingReasoning.buffers()
            • ContextGatingReasoning.children()
            • ContextGatingReasoning.cpu()
            • ContextGatingReasoning.cuda()
            • ContextGatingReasoning.double()
            • ContextGatingReasoning.eval()
            • ContextGatingReasoning.extra_repr()
            • ContextGatingReasoning.float()
            • ContextGatingReasoning.forward()
            • ContextGatingReasoning.get_buffer()
            • ContextGatingReasoning.get_extra_state()
            • ContextGatingReasoning.get_parameter()
            • ContextGatingReasoning.get_submodule()
            • ContextGatingReasoning.half()
            • ContextGatingReasoning.ipu()
            • ContextGatingReasoning.load_state_dict()
            • ContextGatingReasoning.modules()
            • ContextGatingReasoning.named_buffers()
            • ContextGatingReasoning.named_children()
            • ContextGatingReasoning.named_modules()
            • ContextGatingReasoning.named_parameters()
            • ContextGatingReasoning.parameters()
            • ContextGatingReasoning.register_backward_hook()
            • ContextGatingReasoning.register_buffer()
            • ContextGatingReasoning.register_forward_hook()
            • ContextGatingReasoning.register_forward_pre_hook()
            • ContextGatingReasoning.register_full_backward_hook()
            • ContextGatingReasoning.register_full_backward_pre_hook()
            • ContextGatingReasoning.register_load_state_dict_post_hook()
            • ContextGatingReasoning.register_module()
            • ContextGatingReasoning.register_parameter()
            • ContextGatingReasoning.register_state_dict_pre_hook()
            • ContextGatingReasoning.requires_grad_()
            • ContextGatingReasoning.set_extra_state()
            • ContextGatingReasoning.share_memory()
            • ContextGatingReasoning.state_dict()
            • ContextGatingReasoning.to()
            • ContextGatingReasoning.to_empty()
            • ContextGatingReasoning.train()
            • ContextGatingReasoning.type()
            • ContextGatingReasoning.xpu()
            • ContextGatingReasoning.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.G_reason
          • G_reason
            • G_reason.__call__()
            • G_reason.__init__()
            • G_reason.__repr__()
            • G_reason.add_module()
            • G_reason.apply()
            • G_reason.bfloat16()
            • G_reason.buffers()
            • G_reason.children()
            • G_reason.cpu()
            • G_reason.cuda()
            • G_reason.double()
            • G_reason.eval()
            • G_reason.extra_repr()
            • G_reason.float()
            • G_reason.forward()
            • G_reason.get_buffer()
            • G_reason.get_extra_state()
            • G_reason.get_parameter()
            • G_reason.get_submodule()
            • G_reason.half()
            • G_reason.ipu()
            • G_reason.load_state_dict()
            • G_reason.modules()
            • G_reason.named_buffers()
            • G_reason.named_children()
            • G_reason.named_modules()
            • G_reason.named_parameters()
            • G_reason.parameters()
            • G_reason.register_backward_hook()
            • G_reason.register_buffer()
            • G_reason.register_forward_hook()
            • G_reason.register_forward_pre_hook()
            • G_reason.register_full_backward_hook()
            • G_reason.register_full_backward_pre_hook()
            • G_reason.register_load_state_dict_post_hook()
            • G_reason.register_module()
            • G_reason.register_parameter()
            • G_reason.register_state_dict_pre_hook()
            • G_reason.requires_grad_()
            • G_reason.set_extra_state()
            • G_reason.share_memory()
            • G_reason.state_dict()
            • G_reason.to()
            • G_reason.to_empty()
            • G_reason.train()
            • G_reason.type()
            • G_reason.xpu()
            • G_reason.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.GatedEmbeddingUnit
          • GatedEmbeddingUnit
            • GatedEmbeddingUnit.__call__()
            • GatedEmbeddingUnit.__init__()
            • GatedEmbeddingUnit.__repr__()
            • GatedEmbeddingUnit.add_module()
            • GatedEmbeddingUnit.apply()
            • GatedEmbeddingUnit.bfloat16()
            • GatedEmbeddingUnit.buffers()
            • GatedEmbeddingUnit.children()
            • GatedEmbeddingUnit.cpu()
            • GatedEmbeddingUnit.cuda()
            • GatedEmbeddingUnit.double()
            • GatedEmbeddingUnit.eval()
            • GatedEmbeddingUnit.extra_repr()
            • GatedEmbeddingUnit.float()
            • GatedEmbeddingUnit.forward()
            • GatedEmbeddingUnit.get_buffer()
            • GatedEmbeddingUnit.get_extra_state()
            • GatedEmbeddingUnit.get_parameter()
            • GatedEmbeddingUnit.get_submodule()
            • GatedEmbeddingUnit.half()
            • GatedEmbeddingUnit.ipu()
            • GatedEmbeddingUnit.load_state_dict()
            • GatedEmbeddingUnit.modules()
            • GatedEmbeddingUnit.named_buffers()
            • GatedEmbeddingUnit.named_children()
            • GatedEmbeddingUnit.named_modules()
            • GatedEmbeddingUnit.named_parameters()
            • GatedEmbeddingUnit.parameters()
            • GatedEmbeddingUnit.register_backward_hook()
            • GatedEmbeddingUnit.register_buffer()
            • GatedEmbeddingUnit.register_forward_hook()
            • GatedEmbeddingUnit.register_forward_pre_hook()
            • GatedEmbeddingUnit.register_full_backward_hook()
            • GatedEmbeddingUnit.register_full_backward_pre_hook()
            • GatedEmbeddingUnit.register_load_state_dict_post_hook()
            • GatedEmbeddingUnit.register_module()
            • GatedEmbeddingUnit.register_parameter()
            • GatedEmbeddingUnit.register_state_dict_pre_hook()
            • GatedEmbeddingUnit.requires_grad_()
            • GatedEmbeddingUnit.set_extra_state()
            • GatedEmbeddingUnit.share_memory()
            • GatedEmbeddingUnit.state_dict()
            • GatedEmbeddingUnit.to()
            • GatedEmbeddingUnit.to_empty()
            • GatedEmbeddingUnit.train()
            • GatedEmbeddingUnit.type()
            • GatedEmbeddingUnit.xpu()
            • GatedEmbeddingUnit.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.GatedEmbeddingUnitReasoning
          • GatedEmbeddingUnitReasoning
            • GatedEmbeddingUnitReasoning.__call__()
            • GatedEmbeddingUnitReasoning.__init__()
            • GatedEmbeddingUnitReasoning.__repr__()
            • GatedEmbeddingUnitReasoning.add_module()
            • GatedEmbeddingUnitReasoning.apply()
            • GatedEmbeddingUnitReasoning.bfloat16()
            • GatedEmbeddingUnitReasoning.buffers()
            • GatedEmbeddingUnitReasoning.children()
            • GatedEmbeddingUnitReasoning.cpu()
            • GatedEmbeddingUnitReasoning.cuda()
            • GatedEmbeddingUnitReasoning.double()
            • GatedEmbeddingUnitReasoning.eval()
            • GatedEmbeddingUnitReasoning.extra_repr()
            • GatedEmbeddingUnitReasoning.float()
            • GatedEmbeddingUnitReasoning.forward()
            • GatedEmbeddingUnitReasoning.get_buffer()
            • GatedEmbeddingUnitReasoning.get_extra_state()
            • GatedEmbeddingUnitReasoning.get_parameter()
            • GatedEmbeddingUnitReasoning.get_submodule()
            • GatedEmbeddingUnitReasoning.half()
            • GatedEmbeddingUnitReasoning.ipu()
            • GatedEmbeddingUnitReasoning.load_state_dict()
            • GatedEmbeddingUnitReasoning.modules()
            • GatedEmbeddingUnitReasoning.named_buffers()
            • GatedEmbeddingUnitReasoning.named_children()
            • GatedEmbeddingUnitReasoning.named_modules()
            • GatedEmbeddingUnitReasoning.named_parameters()
            • GatedEmbeddingUnitReasoning.parameters()
            • GatedEmbeddingUnitReasoning.register_backward_hook()
            • GatedEmbeddingUnitReasoning.register_buffer()
            • GatedEmbeddingUnitReasoning.register_forward_hook()
            • GatedEmbeddingUnitReasoning.register_forward_pre_hook()
            • GatedEmbeddingUnitReasoning.register_full_backward_hook()
            • GatedEmbeddingUnitReasoning.register_full_backward_pre_hook()
            • GatedEmbeddingUnitReasoning.register_load_state_dict_post_hook()
            • GatedEmbeddingUnitReasoning.register_module()
            • GatedEmbeddingUnitReasoning.register_parameter()
            • GatedEmbeddingUnitReasoning.register_state_dict_pre_hook()
            • GatedEmbeddingUnitReasoning.requires_grad_()
            • GatedEmbeddingUnitReasoning.set_extra_state()
            • GatedEmbeddingUnitReasoning.share_memory()
            • GatedEmbeddingUnitReasoning.state_dict()
            • GatedEmbeddingUnitReasoning.to()
            • GatedEmbeddingUnitReasoning.to_empty()
            • GatedEmbeddingUnitReasoning.train()
            • GatedEmbeddingUnitReasoning.type()
            • GatedEmbeddingUnitReasoning.xpu()
            • GatedEmbeddingUnitReasoning.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.MimicCEGatedEmbeddingUnit
          • MimicCEGatedEmbeddingUnit
            • MimicCEGatedEmbeddingUnit.__call__()
            • MimicCEGatedEmbeddingUnit.__init__()
            • MimicCEGatedEmbeddingUnit.__repr__()
            • MimicCEGatedEmbeddingUnit.add_module()
            • MimicCEGatedEmbeddingUnit.apply()
            • MimicCEGatedEmbeddingUnit.bfloat16()
            • MimicCEGatedEmbeddingUnit.buffers()
            • MimicCEGatedEmbeddingUnit.children()
            • MimicCEGatedEmbeddingUnit.cpu()
            • MimicCEGatedEmbeddingUnit.cuda()
            • MimicCEGatedEmbeddingUnit.double()
            • MimicCEGatedEmbeddingUnit.eval()
            • MimicCEGatedEmbeddingUnit.extra_repr()
            • MimicCEGatedEmbeddingUnit.float()
            • MimicCEGatedEmbeddingUnit.forward()
            • MimicCEGatedEmbeddingUnit.get_buffer()
            • MimicCEGatedEmbeddingUnit.get_extra_state()
            • MimicCEGatedEmbeddingUnit.get_parameter()
            • MimicCEGatedEmbeddingUnit.get_submodule()
            • MimicCEGatedEmbeddingUnit.half()
            • MimicCEGatedEmbeddingUnit.ipu()
            • MimicCEGatedEmbeddingUnit.load_state_dict()
            • MimicCEGatedEmbeddingUnit.modules()
            • MimicCEGatedEmbeddingUnit.named_buffers()
            • MimicCEGatedEmbeddingUnit.named_children()
            • MimicCEGatedEmbeddingUnit.named_modules()
            • MimicCEGatedEmbeddingUnit.named_parameters()
            • MimicCEGatedEmbeddingUnit.parameters()
            • MimicCEGatedEmbeddingUnit.register_backward_hook()
            • MimicCEGatedEmbeddingUnit.register_buffer()
            • MimicCEGatedEmbeddingUnit.register_forward_hook()
            • MimicCEGatedEmbeddingUnit.register_forward_pre_hook()
            • MimicCEGatedEmbeddingUnit.register_full_backward_hook()
            • MimicCEGatedEmbeddingUnit.register_full_backward_pre_hook()
            • MimicCEGatedEmbeddingUnit.register_load_state_dict_post_hook()
            • MimicCEGatedEmbeddingUnit.register_module()
            • MimicCEGatedEmbeddingUnit.register_parameter()
            • MimicCEGatedEmbeddingUnit.register_state_dict_pre_hook()
            • MimicCEGatedEmbeddingUnit.requires_grad_()
            • MimicCEGatedEmbeddingUnit.set_extra_state()
            • MimicCEGatedEmbeddingUnit.share_memory()
            • MimicCEGatedEmbeddingUnit.state_dict()
            • MimicCEGatedEmbeddingUnit.to()
            • MimicCEGatedEmbeddingUnit.to_empty()
            • MimicCEGatedEmbeddingUnit.train()
            • MimicCEGatedEmbeddingUnit.type()
            • MimicCEGatedEmbeddingUnit.xpu()
            • MimicCEGatedEmbeddingUnit.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.Mish
          • Mish
            • Mish.__call__()
            • Mish.__init__()
            • Mish.__repr__()
            • Mish.add_module()
            • Mish.apply()
            • Mish.bfloat16()
            • Mish.buffers()
            • Mish.children()
            • Mish.cpu()
            • Mish.cuda()
            • Mish.double()
            • Mish.eval()
            • Mish.extra_repr()
            • Mish.float()
            • Mish.forward()
            • Mish.get_buffer()
            • Mish.get_extra_state()
            • Mish.get_parameter()
            • Mish.get_submodule()
            • Mish.half()
            • Mish.ipu()
            • Mish.load_state_dict()
            • Mish.modules()
            • Mish.named_buffers()
            • Mish.named_children()
            • Mish.named_modules()
            • Mish.named_parameters()
            • Mish.parameters()
            • Mish.register_backward_hook()
            • Mish.register_buffer()
            • Mish.register_forward_hook()
            • Mish.register_forward_pre_hook()
            • Mish.register_full_backward_hook()
            • Mish.register_full_backward_pre_hook()
            • Mish.register_load_state_dict_post_hook()
            • Mish.register_module()
            • Mish.register_parameter()
            • Mish.register_state_dict_pre_hook()
            • Mish.requires_grad_()
            • Mish.set_extra_state()
            • Mish.share_memory()
            • Mish.state_dict()
            • Mish.to()
            • Mish.to_empty()
            • Mish.train()
            • Mish.type()
            • Mish.xpu()
            • Mish.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.ReduceDim
          • ReduceDim
            • ReduceDim.__call__()
            • ReduceDim.__init__()
            • ReduceDim.__repr__()
            • ReduceDim.add_module()
            • ReduceDim.apply()
            • ReduceDim.bfloat16()
            • ReduceDim.buffers()
            • ReduceDim.children()
            • ReduceDim.cpu()
            • ReduceDim.cuda()
            • ReduceDim.double()
            • ReduceDim.eval()
            • ReduceDim.extra_repr()
            • ReduceDim.float()
            • ReduceDim.forward()
            • ReduceDim.get_buffer()
            • ReduceDim.get_extra_state()
            • ReduceDim.get_parameter()
            • ReduceDim.get_submodule()
            • ReduceDim.half()
            • ReduceDim.ipu()
            • ReduceDim.load_state_dict()
            • ReduceDim.modules()
            • ReduceDim.named_buffers()
            • ReduceDim.named_children()
            • ReduceDim.named_modules()
            • ReduceDim.named_parameters()
            • ReduceDim.parameters()
            • ReduceDim.register_backward_hook()
            • ReduceDim.register_buffer()
            • ReduceDim.register_forward_hook()
            • ReduceDim.register_forward_pre_hook()
            • ReduceDim.register_full_backward_hook()
            • ReduceDim.register_full_backward_pre_hook()
            • ReduceDim.register_load_state_dict_post_hook()
            • ReduceDim.register_module()
            • ReduceDim.register_parameter()
            • ReduceDim.register_state_dict_pre_hook()
            • ReduceDim.requires_grad_()
            • ReduceDim.set_extra_state()
            • ReduceDim.share_memory()
            • ReduceDim.state_dict()
            • ReduceDim.to()
            • ReduceDim.to_empty()
            • ReduceDim.train()
            • ReduceDim.type()
            • ReduceDim.xpu()
            • ReduceDim.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.RelationModuleMultiScale
          • RelationModuleMultiScale
            • RelationModuleMultiScale.__call__()
            • RelationModuleMultiScale.__init__()
            • RelationModuleMultiScale.__repr__()
            • RelationModuleMultiScale.add_module()
            • RelationModuleMultiScale.apply()
            • RelationModuleMultiScale.bfloat16()
            • RelationModuleMultiScale.buffers()
            • RelationModuleMultiScale.children()
            • RelationModuleMultiScale.cpu()
            • RelationModuleMultiScale.cuda()
            • RelationModuleMultiScale.double()
            • RelationModuleMultiScale.eval()
            • RelationModuleMultiScale.extra_repr()
            • RelationModuleMultiScale.float()
            • RelationModuleMultiScale.forward()
            • RelationModuleMultiScale.get_buffer()
            • RelationModuleMultiScale.get_extra_state()
            • RelationModuleMultiScale.get_parameter()
            • RelationModuleMultiScale.get_submodule()
            • RelationModuleMultiScale.half()
            • RelationModuleMultiScale.ipu()
            • RelationModuleMultiScale.load_state_dict()
            • RelationModuleMultiScale.modules()
            • RelationModuleMultiScale.named_buffers()
            • RelationModuleMultiScale.named_children()
            • RelationModuleMultiScale.named_modules()
            • RelationModuleMultiScale.named_parameters()
            • RelationModuleMultiScale.parameters()
            • RelationModuleMultiScale.register_backward_hook()
            • RelationModuleMultiScale.register_buffer()
            • RelationModuleMultiScale.register_forward_hook()
            • RelationModuleMultiScale.register_forward_pre_hook()
            • RelationModuleMultiScale.register_full_backward_hook()
            • RelationModuleMultiScale.register_full_backward_pre_hook()
            • RelationModuleMultiScale.register_load_state_dict_post_hook()
            • RelationModuleMultiScale.register_module()
            • RelationModuleMultiScale.register_parameter()
            • RelationModuleMultiScale.register_state_dict_pre_hook()
            • RelationModuleMultiScale.requires_grad_()
            • RelationModuleMultiScale.set_extra_state()
            • RelationModuleMultiScale.share_memory()
            • RelationModuleMultiScale.state_dict()
            • RelationModuleMultiScale.to()
            • RelationModuleMultiScale.to_empty()
            • RelationModuleMultiScale.train()
            • RelationModuleMultiScale.type()
            • RelationModuleMultiScale.xpu()
            • RelationModuleMultiScale.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.RelationModuleMultiScale_Cat
          • RelationModuleMultiScale_Cat
            • RelationModuleMultiScale_Cat.__call__()
            • RelationModuleMultiScale_Cat.__init__()
            • RelationModuleMultiScale_Cat.__repr__()
            • RelationModuleMultiScale_Cat.add_module()
            • RelationModuleMultiScale_Cat.apply()
            • RelationModuleMultiScale_Cat.bfloat16()
            • RelationModuleMultiScale_Cat.buffers()
            • RelationModuleMultiScale_Cat.children()
            • RelationModuleMultiScale_Cat.cpu()
            • RelationModuleMultiScale_Cat.cuda()
            • RelationModuleMultiScale_Cat.double()
            • RelationModuleMultiScale_Cat.eval()
            • RelationModuleMultiScale_Cat.extra_repr()
            • RelationModuleMultiScale_Cat.float()
            • RelationModuleMultiScale_Cat.forward()
            • RelationModuleMultiScale_Cat.get_buffer()
            • RelationModuleMultiScale_Cat.get_extra_state()
            • RelationModuleMultiScale_Cat.get_parameter()
            • RelationModuleMultiScale_Cat.get_submodule()
            • RelationModuleMultiScale_Cat.half()
            • RelationModuleMultiScale_Cat.ipu()
            • RelationModuleMultiScale_Cat.load_state_dict()
            • RelationModuleMultiScale_Cat.modules()
            • RelationModuleMultiScale_Cat.named_buffers()
            • RelationModuleMultiScale_Cat.named_children()
            • RelationModuleMultiScale_Cat.named_modules()
            • RelationModuleMultiScale_Cat.named_parameters()
            • RelationModuleMultiScale_Cat.parameters()
            • RelationModuleMultiScale_Cat.register_backward_hook()
            • RelationModuleMultiScale_Cat.register_buffer()
            • RelationModuleMultiScale_Cat.register_forward_hook()
            • RelationModuleMultiScale_Cat.register_forward_pre_hook()
            • RelationModuleMultiScale_Cat.register_full_backward_hook()
            • RelationModuleMultiScale_Cat.register_full_backward_pre_hook()
            • RelationModuleMultiScale_Cat.register_load_state_dict_post_hook()
            • RelationModuleMultiScale_Cat.register_module()
            • RelationModuleMultiScale_Cat.register_parameter()
            • RelationModuleMultiScale_Cat.register_state_dict_pre_hook()
            • RelationModuleMultiScale_Cat.requires_grad_()
            • RelationModuleMultiScale_Cat.set_extra_state()
            • RelationModuleMultiScale_Cat.share_memory()
            • RelationModuleMultiScale_Cat.state_dict()
            • RelationModuleMultiScale_Cat.to()
            • RelationModuleMultiScale_Cat.to_empty()
            • RelationModuleMultiScale_Cat.train()
            • RelationModuleMultiScale_Cat.type()
            • RelationModuleMultiScale_Cat.xpu()
            • RelationModuleMultiScale_Cat.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.SpatialMLP
          • SpatialMLP
            • SpatialMLP.__call__()
            • SpatialMLP.__init__()
            • SpatialMLP.__repr__()
            • SpatialMLP.add_module()
            • SpatialMLP.apply()
            • SpatialMLP.bfloat16()
            • SpatialMLP.buffers()
            • SpatialMLP.children()
            • SpatialMLP.cpu()
            • SpatialMLP.cuda()
            • SpatialMLP.double()
            • SpatialMLP.eval()
            • SpatialMLP.extra_repr()
            • SpatialMLP.float()
            • SpatialMLP.forward()
            • SpatialMLP.get_buffer()
            • SpatialMLP.get_extra_state()
            • SpatialMLP.get_parameter()
            • SpatialMLP.get_submodule()
            • SpatialMLP.half()
            • SpatialMLP.ipu()
            • SpatialMLP.load_state_dict()
            • SpatialMLP.modules()
            • SpatialMLP.named_buffers()
            • SpatialMLP.named_children()
            • SpatialMLP.named_modules()
            • SpatialMLP.named_parameters()
            • SpatialMLP.parameters()
            • SpatialMLP.register_backward_hook()
            • SpatialMLP.register_buffer()
            • SpatialMLP.register_forward_hook()
            • SpatialMLP.register_forward_pre_hook()
            • SpatialMLP.register_full_backward_hook()
            • SpatialMLP.register_full_backward_pre_hook()
            • SpatialMLP.register_load_state_dict_post_hook()
            • SpatialMLP.register_module()
            • SpatialMLP.register_parameter()
            • SpatialMLP.register_state_dict_pre_hook()
            • SpatialMLP.requires_grad_()
            • SpatialMLP.set_extra_state()
            • SpatialMLP.share_memory()
            • SpatialMLP.state_dict()
            • SpatialMLP.to()
            • SpatialMLP.to_empty()
            • SpatialMLP.train()
            • SpatialMLP.type()
            • SpatialMLP.xpu()
            • SpatialMLP.zero_grad()
        • towhee.models.collaborative_experts.collaborative_experts.TemporalAttention
          • TemporalAttention
            • TemporalAttention.__call__()
            • TemporalAttention.__init__()
            • TemporalAttention.__repr__()
            • TemporalAttention.add_module()
            • TemporalAttention.apply()
            • TemporalAttention.bfloat16()
            • TemporalAttention.buffers()
            • TemporalAttention.children()
            • TemporalAttention.cpu()
            • TemporalAttention.cuda()
            • TemporalAttention.double()
            • TemporalAttention.eval()
            • TemporalAttention.extra_repr()
            • TemporalAttention.float()
            • TemporalAttention.forward()
            • TemporalAttention.get_buffer()
            • TemporalAttention.get_extra_state()
            • TemporalAttention.get_parameter()
            • TemporalAttention.get_submodule()
            • TemporalAttention.half()
            • TemporalAttention.ipu()
            • TemporalAttention.load_state_dict()
            • TemporalAttention.modules()
            • TemporalAttention.named_buffers()
            • TemporalAttention.named_children()
            • TemporalAttention.named_modules()
            • TemporalAttention.named_parameters()
            • TemporalAttention.parameters()
            • TemporalAttention.register_backward_hook()
            • TemporalAttention.register_buffer()
            • TemporalAttention.register_forward_hook()
            • TemporalAttention.register_forward_pre_hook()
            • TemporalAttention.register_full_backward_hook()
            • TemporalAttention.register_full_backward_pre_hook()
            • TemporalAttention.register_load_state_dict_post_hook()
            • TemporalAttention.register_module()
            • TemporalAttention.register_parameter()
            • TemporalAttention.register_state_dict_pre_hook()
            • TemporalAttention.requires_grad_()
            • TemporalAttention.set_extra_state()
            • TemporalAttention.share_memory()
            • TemporalAttention.state_dict()
            • TemporalAttention.to()
            • TemporalAttention.to_empty()
            • TemporalAttention.train()
            • TemporalAttention.type()
            • TemporalAttention.xpu()
            • TemporalAttention.zero_grad()
      • towhee.models.collaborative_experts.net_vlad
        • towhee.models.collaborative_experts.net_vlad.NetVLAD
          • NetVLAD
            • NetVLAD.__call__()
            • NetVLAD.__init__()
            • NetVLAD.__repr__()
            • NetVLAD.add_module()
            • NetVLAD.apply()
            • NetVLAD.bfloat16()
            • NetVLAD.buffers()
            • NetVLAD.children()
            • NetVLAD.cpu()
            • NetVLAD.cuda()
            • NetVLAD.double()
            • NetVLAD.eval()
            • NetVLAD.extra_repr()
            • NetVLAD.float()
            • NetVLAD.forward()
            • NetVLAD.get_buffer()
            • NetVLAD.get_extra_state()
            • NetVLAD.get_parameter()
            • NetVLAD.get_submodule()
            • NetVLAD.half()
            • NetVLAD.ipu()
            • NetVLAD.load_state_dict()
            • NetVLAD.modules()
            • NetVLAD.named_buffers()
            • NetVLAD.named_children()
            • NetVLAD.named_modules()
            • NetVLAD.named_parameters()
            • NetVLAD.parameters()
            • NetVLAD.register_backward_hook()
            • NetVLAD.register_buffer()
            • NetVLAD.register_forward_hook()
            • NetVLAD.register_forward_pre_hook()
            • NetVLAD.register_full_backward_hook()
            • NetVLAD.register_full_backward_pre_hook()
            • NetVLAD.register_load_state_dict_post_hook()
            • NetVLAD.register_module()
            • NetVLAD.register_parameter()
            • NetVLAD.register_state_dict_pre_hook()
            • NetVLAD.requires_grad_()
            • NetVLAD.set_extra_state()
            • NetVLAD.share_memory()
            • NetVLAD.state_dict()
            • NetVLAD.to()
            • NetVLAD.to_empty()
            • NetVLAD.train()
            • NetVLAD.type()
            • NetVLAD.xpu()
            • NetVLAD.zero_grad()
      • towhee.models.collaborative_experts.util
        • towhee.models.collaborative_experts.util.expert_tensor_storage
          • expert_tensor_storage()
    • towhee.models.convnext
      • towhee.models.convnext.configs
        • towhee.models.convnext.configs.get_configs
          • get_configs()
      • towhee.models.convnext.convnext
        • towhee.models.convnext.convnext.create_model
          • create_model()
        • towhee.models.convnext.convnext.ConvNeXt
          • ConvNeXt
            • ConvNeXt.__call__()
            • ConvNeXt.__init__()
            • ConvNeXt.__repr__()
            • ConvNeXt.add_module()
            • ConvNeXt.apply()
            • ConvNeXt.bfloat16()
            • ConvNeXt.buffers()
            • ConvNeXt.children()
            • ConvNeXt.cpu()
            • ConvNeXt.cuda()
            • ConvNeXt.double()
            • ConvNeXt.eval()
            • ConvNeXt.extra_repr()
            • ConvNeXt.float()
            • ConvNeXt.forward()
            • ConvNeXt.get_buffer()
            • ConvNeXt.get_extra_state()
            • ConvNeXt.get_parameter()
            • ConvNeXt.get_submodule()
            • ConvNeXt.half()
            • ConvNeXt.ipu()
            • ConvNeXt.load_state_dict()
            • ConvNeXt.modules()
            • ConvNeXt.named_buffers()
            • ConvNeXt.named_children()
            • ConvNeXt.named_modules()
            • ConvNeXt.named_parameters()
            • ConvNeXt.parameters()
            • ConvNeXt.register_backward_hook()
            • ConvNeXt.register_buffer()
            • ConvNeXt.register_forward_hook()
            • ConvNeXt.register_forward_pre_hook()
            • ConvNeXt.register_full_backward_hook()
            • ConvNeXt.register_full_backward_pre_hook()
            • ConvNeXt.register_load_state_dict_post_hook()
            • ConvNeXt.register_module()
            • ConvNeXt.register_parameter()
            • ConvNeXt.register_state_dict_pre_hook()
            • ConvNeXt.requires_grad_()
            • ConvNeXt.set_extra_state()
            • ConvNeXt.share_memory()
            • ConvNeXt.state_dict()
            • ConvNeXt.to()
            • ConvNeXt.to_empty()
            • ConvNeXt.train()
            • ConvNeXt.type()
            • ConvNeXt.xpu()
            • ConvNeXt.zero_grad()
      • towhee.models.convnext.utils
        • towhee.models.convnext.utils.Block
          • Block
            • Block.__call__()
            • Block.__init__()
            • Block.__repr__()
            • Block.add_module()
            • Block.apply()
            • Block.bfloat16()
            • Block.buffers()
            • Block.children()
            • Block.cpu()
            • Block.cuda()
            • Block.double()
            • Block.eval()
            • Block.extra_repr()
            • Block.float()
            • Block.forward()
            • Block.get_buffer()
            • Block.get_extra_state()
            • Block.get_parameter()
            • Block.get_submodule()
            • Block.half()
            • Block.ipu()
            • Block.load_state_dict()
            • Block.modules()
            • Block.named_buffers()
            • Block.named_children()
            • Block.named_modules()
            • Block.named_parameters()
            • Block.parameters()
            • Block.register_backward_hook()
            • Block.register_buffer()
            • Block.register_forward_hook()
            • Block.register_forward_pre_hook()
            • Block.register_full_backward_hook()
            • Block.register_full_backward_pre_hook()
            • Block.register_load_state_dict_post_hook()
            • Block.register_module()
            • Block.register_parameter()
            • Block.register_state_dict_pre_hook()
            • Block.requires_grad_()
            • Block.set_extra_state()
            • Block.share_memory()
            • Block.state_dict()
            • Block.to()
            • Block.to_empty()
            • Block.train()
            • Block.type()
            • Block.xpu()
            • Block.zero_grad()
        • towhee.models.convnext.utils.LayerNorm
          • LayerNorm
            • LayerNorm.__call__()
            • LayerNorm.__init__()
            • LayerNorm.__repr__()
            • LayerNorm.add_module()
            • LayerNorm.apply()
            • LayerNorm.bfloat16()
            • LayerNorm.buffers()
            • LayerNorm.children()
            • LayerNorm.cpu()
            • LayerNorm.cuda()
            • LayerNorm.double()
            • LayerNorm.eval()
            • LayerNorm.extra_repr()
            • LayerNorm.float()
            • LayerNorm.forward()
            • LayerNorm.get_buffer()
            • LayerNorm.get_extra_state()
            • LayerNorm.get_parameter()
            • LayerNorm.get_submodule()
            • LayerNorm.half()
            • LayerNorm.ipu()
            • LayerNorm.load_state_dict()
            • LayerNorm.modules()
            • LayerNorm.named_buffers()
            • LayerNorm.named_children()
            • LayerNorm.named_modules()
            • LayerNorm.named_parameters()
            • LayerNorm.parameters()
            • LayerNorm.register_backward_hook()
            • LayerNorm.register_buffer()
            • LayerNorm.register_forward_hook()
            • LayerNorm.register_forward_pre_hook()
            • LayerNorm.register_full_backward_hook()
            • LayerNorm.register_full_backward_pre_hook()
            • LayerNorm.register_load_state_dict_post_hook()
            • LayerNorm.register_module()
            • LayerNorm.register_parameter()
            • LayerNorm.register_state_dict_pre_hook()
            • LayerNorm.requires_grad_()
            • LayerNorm.set_extra_state()
            • LayerNorm.share_memory()
            • LayerNorm.state_dict()
            • LayerNorm.to()
            • LayerNorm.to_empty()
            • LayerNorm.train()
            • LayerNorm.type()
            • LayerNorm.xpu()
            • LayerNorm.zero_grad()
    • towhee.models.cvnet
      • towhee.models.cvnet.cvnet
        • towhee.models.cvnet.cvnet.create_model
          • create_model()
        • towhee.models.cvnet.cvnet.CVNet
          • CVNet
            • CVNet.__call__()
            • CVNet.__init__()
            • CVNet.__repr__()
            • CVNet.add_module()
            • CVNet.apply()
            • CVNet.bfloat16()
            • CVNet.buffers()
            • CVNet.children()
            • CVNet.cpu()
            • CVNet.cuda()
            • CVNet.double()
            • CVNet.eval()
            • CVNet.extra_repr()
            • CVNet.float()
            • CVNet.forward()
            • CVNet.get_buffer()
            • CVNet.get_extra_state()
            • CVNet.get_parameter()
            • CVNet.get_submodule()
            • CVNet.half()
            • CVNet.ipu()
            • CVNet.load_state_dict()
            • CVNet.modules()
            • CVNet.named_buffers()
            • CVNet.named_children()
            • CVNet.named_modules()
            • CVNet.named_parameters()
            • CVNet.parameters()
            • CVNet.register_backward_hook()
            • CVNet.register_buffer()
            • CVNet.register_forward_hook()
            • CVNet.register_forward_pre_hook()
            • CVNet.register_full_backward_hook()
            • CVNet.register_full_backward_pre_hook()
            • CVNet.register_load_state_dict_post_hook()
            • CVNet.register_module()
            • CVNet.register_parameter()
            • CVNet.register_state_dict_pre_hook()
            • CVNet.requires_grad_()
            • CVNet.set_extra_state()
            • CVNet.share_memory()
            • CVNet.state_dict()
            • CVNet.to()
            • CVNet.to_empty()
            • CVNet.train()
            • CVNet.type()
            • CVNet.xpu()
            • CVNet.zero_grad()
      • towhee.models.cvnet.cvnet_block
        • towhee.models.cvnet.cvnet_block.CVLearner
          • CVLearner
            • CVLearner.__call__()
            • CVLearner.__init__()
            • CVLearner.__repr__()
            • CVLearner.add_module()
            • CVLearner.apply()
            • CVLearner.bfloat16()
            • CVLearner.buffers()
            • CVLearner.children()
            • CVLearner.cpu()
            • CVLearner.cuda()
            • CVLearner.double()
            • CVLearner.eval()
            • CVLearner.extra_repr()
            • CVLearner.float()
            • CVLearner.forward()
            • CVLearner.get_buffer()
            • CVLearner.get_extra_state()
            • CVLearner.get_parameter()
            • CVLearner.get_submodule()
            • CVLearner.half()
            • CVLearner.ipu()
            • CVLearner.load_state_dict()
            • CVLearner.modules()
            • CVLearner.named_buffers()
            • CVLearner.named_children()
            • CVLearner.named_modules()
            • CVLearner.named_parameters()
            • CVLearner.parameters()
            • CVLearner.register_backward_hook()
            • CVLearner.register_buffer()
            • CVLearner.register_forward_hook()
            • CVLearner.register_forward_pre_hook()
            • CVLearner.register_full_backward_hook()
            • CVLearner.register_full_backward_pre_hook()
            • CVLearner.register_load_state_dict_post_hook()
            • CVLearner.register_module()
            • CVLearner.register_parameter()
            • CVLearner.register_state_dict_pre_hook()
            • CVLearner.requires_grad_()
            • CVLearner.set_extra_state()
            • CVLearner.share_memory()
            • CVLearner.state_dict()
            • CVLearner.to()
            • CVLearner.to_empty()
            • CVLearner.train()
            • CVLearner.type()
            • CVLearner.xpu()
            • CVLearner.zero_grad()
        • towhee.models.cvnet.cvnet_block.Correlation
          • Correlation
            • Correlation.compute_crossscale_correlation()
      • towhee.models.cvnet.cvnet_utils
        • towhee.models.cvnet.cvnet_utils.extract_feat_res_pycls
          • extract_feat_res_pycls()
        • towhee.models.cvnet.cvnet_utils.get_configs
          • get_configs()
        • towhee.models.cvnet.cvnet_utils.Geometry
          • Geometry
      • towhee.models.cvnet.resnet
        • towhee.models.cvnet.resnet.get_trans_fun
          • get_trans_fun()
        • towhee.models.cvnet.resnet.BasicTransform
          • BasicTransform
            • BasicTransform.__call__()
            • BasicTransform.__init__()
            • BasicTransform.__repr__()
            • BasicTransform.add_module()
            • BasicTransform.apply()
            • BasicTransform.bfloat16()
            • BasicTransform.buffers()
            • BasicTransform.children()
            • BasicTransform.cpu()
            • BasicTransform.cuda()
            • BasicTransform.double()
            • BasicTransform.eval()
            • BasicTransform.extra_repr()
            • BasicTransform.float()
            • BasicTransform.forward()
            • BasicTransform.get_buffer()
            • BasicTransform.get_extra_state()
            • BasicTransform.get_parameter()
            • BasicTransform.get_submodule()
            • BasicTransform.half()
            • BasicTransform.ipu()
            • BasicTransform.load_state_dict()
            • BasicTransform.modules()
            • BasicTransform.named_buffers()
            • BasicTransform.named_children()
            • BasicTransform.named_modules()
            • BasicTransform.named_parameters()
            • BasicTransform.parameters()
            • BasicTransform.register_backward_hook()
            • BasicTransform.register_buffer()
            • BasicTransform.register_forward_hook()
            • BasicTransform.register_forward_pre_hook()
            • BasicTransform.register_full_backward_hook()
            • BasicTransform.register_full_backward_pre_hook()
            • BasicTransform.register_load_state_dict_post_hook()
            • BasicTransform.register_module()
            • BasicTransform.register_parameter()
            • BasicTransform.register_state_dict_pre_hook()
            • BasicTransform.requires_grad_()
            • BasicTransform.set_extra_state()
            • BasicTransform.share_memory()
            • BasicTransform.state_dict()
            • BasicTransform.to()
            • BasicTransform.to_empty()
            • BasicTransform.train()
            • BasicTransform.type()
            • BasicTransform.xpu()
            • BasicTransform.zero_grad()
        • towhee.models.cvnet.resnet.BottleneckTransform
          • BottleneckTransform
            • BottleneckTransform.__call__()
            • BottleneckTransform.__init__()
            • BottleneckTransform.__repr__()
            • BottleneckTransform.add_module()
            • BottleneckTransform.apply()
            • BottleneckTransform.bfloat16()
            • BottleneckTransform.buffers()
            • BottleneckTransform.children()
            • BottleneckTransform.cpu()
            • BottleneckTransform.cuda()
            • BottleneckTransform.double()
            • BottleneckTransform.eval()
            • BottleneckTransform.extra_repr()
            • BottleneckTransform.float()
            • BottleneckTransform.forward()
            • BottleneckTransform.get_buffer()
            • BottleneckTransform.get_extra_state()
            • BottleneckTransform.get_parameter()
            • BottleneckTransform.get_submodule()
            • BottleneckTransform.half()
            • BottleneckTransform.ipu()
            • BottleneckTransform.load_state_dict()
            • BottleneckTransform.modules()
            • BottleneckTransform.named_buffers()
            • BottleneckTransform.named_children()
            • BottleneckTransform.named_modules()
            • BottleneckTransform.named_parameters()
            • BottleneckTransform.parameters()
            • BottleneckTransform.register_backward_hook()
            • BottleneckTransform.register_buffer()
            • BottleneckTransform.register_forward_hook()
            • BottleneckTransform.register_forward_pre_hook()
            • BottleneckTransform.register_full_backward_hook()
            • BottleneckTransform.register_full_backward_pre_hook()
            • BottleneckTransform.register_load_state_dict_post_hook()
            • BottleneckTransform.register_module()
            • BottleneckTransform.register_parameter()
            • BottleneckTransform.register_state_dict_pre_hook()
            • BottleneckTransform.requires_grad_()
            • BottleneckTransform.set_extra_state()
            • BottleneckTransform.share_memory()
            • BottleneckTransform.state_dict()
            • BottleneckTransform.to()
            • BottleneckTransform.to_empty()
            • BottleneckTransform.train()
            • BottleneckTransform.type()
            • BottleneckTransform.xpu()
            • BottleneckTransform.zero_grad()
        • towhee.models.cvnet.resnet.GeneralizedMeanPooling
          • GeneralizedMeanPooling
            • GeneralizedMeanPooling.__call__()
            • GeneralizedMeanPooling.__init__()
            • GeneralizedMeanPooling.__repr__()
            • GeneralizedMeanPooling.add_module()
            • GeneralizedMeanPooling.apply()
            • GeneralizedMeanPooling.bfloat16()
            • GeneralizedMeanPooling.buffers()
            • GeneralizedMeanPooling.children()
            • GeneralizedMeanPooling.cpu()
            • GeneralizedMeanPooling.cuda()
            • GeneralizedMeanPooling.double()
            • GeneralizedMeanPooling.eval()
            • GeneralizedMeanPooling.extra_repr()
            • GeneralizedMeanPooling.float()
            • GeneralizedMeanPooling.forward()
            • GeneralizedMeanPooling.get_buffer()
            • GeneralizedMeanPooling.get_extra_state()
            • GeneralizedMeanPooling.get_parameter()
            • GeneralizedMeanPooling.get_submodule()
            • GeneralizedMeanPooling.half()
            • GeneralizedMeanPooling.ipu()
            • GeneralizedMeanPooling.load_state_dict()
            • GeneralizedMeanPooling.modules()
            • GeneralizedMeanPooling.named_buffers()
            • GeneralizedMeanPooling.named_children()
            • GeneralizedMeanPooling.named_modules()
            • GeneralizedMeanPooling.named_parameters()
            • GeneralizedMeanPooling.parameters()
            • GeneralizedMeanPooling.register_backward_hook()
            • GeneralizedMeanPooling.register_buffer()
            • GeneralizedMeanPooling.register_forward_hook()
            • GeneralizedMeanPooling.register_forward_pre_hook()
            • GeneralizedMeanPooling.register_full_backward_hook()
            • GeneralizedMeanPooling.register_full_backward_pre_hook()
            • GeneralizedMeanPooling.register_load_state_dict_post_hook()
            • GeneralizedMeanPooling.register_module()
            • GeneralizedMeanPooling.register_parameter()
            • GeneralizedMeanPooling.register_state_dict_pre_hook()
            • GeneralizedMeanPooling.requires_grad_()
            • GeneralizedMeanPooling.set_extra_state()
            • GeneralizedMeanPooling.share_memory()
            • GeneralizedMeanPooling.state_dict()
            • GeneralizedMeanPooling.to()
            • GeneralizedMeanPooling.to_empty()
            • GeneralizedMeanPooling.train()
            • GeneralizedMeanPooling.type()
            • GeneralizedMeanPooling.xpu()
            • GeneralizedMeanPooling.zero_grad()
        • towhee.models.cvnet.resnet.GeneralizedMeanPoolingP
          • GeneralizedMeanPoolingP
            • GeneralizedMeanPoolingP.__call__()
            • GeneralizedMeanPoolingP.__init__()
            • GeneralizedMeanPoolingP.__repr__()
            • GeneralizedMeanPoolingP.add_module()
            • GeneralizedMeanPoolingP.apply()
            • GeneralizedMeanPoolingP.bfloat16()
            • GeneralizedMeanPoolingP.buffers()
            • GeneralizedMeanPoolingP.children()
            • GeneralizedMeanPoolingP.cpu()
            • GeneralizedMeanPoolingP.cuda()
            • GeneralizedMeanPoolingP.double()
            • GeneralizedMeanPoolingP.eval()
            • GeneralizedMeanPoolingP.extra_repr()
            • GeneralizedMeanPoolingP.float()
            • GeneralizedMeanPoolingP.forward()
            • GeneralizedMeanPoolingP.get_buffer()
            • GeneralizedMeanPoolingP.get_extra_state()
            • GeneralizedMeanPoolingP.get_parameter()
            • GeneralizedMeanPoolingP.get_submodule()
            • GeneralizedMeanPoolingP.half()
            • GeneralizedMeanPoolingP.ipu()
            • GeneralizedMeanPoolingP.load_state_dict()
            • GeneralizedMeanPoolingP.modules()
            • GeneralizedMeanPoolingP.named_buffers()
            • GeneralizedMeanPoolingP.named_children()
            • GeneralizedMeanPoolingP.named_modules()
            • GeneralizedMeanPoolingP.named_parameters()
            • GeneralizedMeanPoolingP.parameters()
            • GeneralizedMeanPoolingP.register_backward_hook()
            • GeneralizedMeanPoolingP.register_buffer()
            • GeneralizedMeanPoolingP.register_forward_hook()
            • GeneralizedMeanPoolingP.register_forward_pre_hook()
            • GeneralizedMeanPoolingP.register_full_backward_hook()
            • GeneralizedMeanPoolingP.register_full_backward_pre_hook()
            • GeneralizedMeanPoolingP.register_load_state_dict_post_hook()
            • GeneralizedMeanPoolingP.register_module()
            • GeneralizedMeanPoolingP.register_parameter()
            • GeneralizedMeanPoolingP.register_state_dict_pre_hook()
            • GeneralizedMeanPoolingP.requires_grad_()
            • GeneralizedMeanPoolingP.set_extra_state()
            • GeneralizedMeanPoolingP.share_memory()
            • GeneralizedMeanPoolingP.state_dict()
            • GeneralizedMeanPoolingP.to()
            • GeneralizedMeanPoolingP.to_empty()
            • GeneralizedMeanPoolingP.train()
            • GeneralizedMeanPoolingP.type()
            • GeneralizedMeanPoolingP.xpu()
            • GeneralizedMeanPoolingP.zero_grad()
        • towhee.models.cvnet.resnet.GlobalHead
          • GlobalHead
            • GlobalHead.__call__()
            • GlobalHead.__init__()
            • GlobalHead.__repr__()
            • GlobalHead.add_module()
            • GlobalHead.apply()
            • GlobalHead.bfloat16()
            • GlobalHead.buffers()
            • GlobalHead.children()
            • GlobalHead.cpu()
            • GlobalHead.cuda()
            • GlobalHead.double()
            • GlobalHead.eval()
            • GlobalHead.extra_repr()
            • GlobalHead.float()
            • GlobalHead.forward()
            • GlobalHead.get_buffer()
            • GlobalHead.get_extra_state()
            • GlobalHead.get_parameter()
            • GlobalHead.get_submodule()
            • GlobalHead.half()
            • GlobalHead.ipu()
            • GlobalHead.load_state_dict()
            • GlobalHead.modules()
            • GlobalHead.named_buffers()
            • GlobalHead.named_children()
            • GlobalHead.named_modules()
            • GlobalHead.named_parameters()
            • GlobalHead.parameters()
            • GlobalHead.register_backward_hook()
            • GlobalHead.register_buffer()
            • GlobalHead.register_forward_hook()
            • GlobalHead.register_forward_pre_hook()
            • GlobalHead.register_full_backward_hook()
            • GlobalHead.register_full_backward_pre_hook()
            • GlobalHead.register_load_state_dict_post_hook()
            • GlobalHead.register_module()
            • GlobalHead.register_parameter()
            • GlobalHead.register_state_dict_pre_hook()
            • GlobalHead.requires_grad_()
            • GlobalHead.set_extra_state()
            • GlobalHead.share_memory()
            • GlobalHead.state_dict()
            • GlobalHead.to()
            • GlobalHead.to_empty()
            • GlobalHead.train()
            • GlobalHead.type()
            • GlobalHead.xpu()
            • GlobalHead.zero_grad()
        • towhee.models.cvnet.resnet.ResBlock
          • ResBlock
            • ResBlock.__call__()
            • ResBlock.__init__()
            • ResBlock.__repr__()
            • ResBlock.add_module()
            • ResBlock.apply()
            • ResBlock.bfloat16()
            • ResBlock.buffers()
            • ResBlock.children()
            • ResBlock.cpu()
            • ResBlock.cuda()
            • ResBlock.double()
            • ResBlock.eval()
            • ResBlock.extra_repr()
            • ResBlock.float()
            • ResBlock.forward()
            • ResBlock.get_buffer()
            • ResBlock.get_extra_state()
            • ResBlock.get_parameter()
            • ResBlock.get_submodule()
            • ResBlock.half()
            • ResBlock.ipu()
            • ResBlock.load_state_dict()
            • ResBlock.modules()
            • ResBlock.named_buffers()
            • ResBlock.named_children()
            • ResBlock.named_modules()
            • ResBlock.named_parameters()
            • ResBlock.parameters()
            • ResBlock.register_backward_hook()
            • ResBlock.register_buffer()
            • ResBlock.register_forward_hook()
            • ResBlock.register_forward_pre_hook()
            • ResBlock.register_full_backward_hook()
            • ResBlock.register_full_backward_pre_hook()
            • ResBlock.register_load_state_dict_post_hook()
            • ResBlock.register_module()
            • ResBlock.register_parameter()
            • ResBlock.register_state_dict_pre_hook()
            • ResBlock.requires_grad_()
            • ResBlock.set_extra_state()
            • ResBlock.share_memory()
            • ResBlock.state_dict()
            • ResBlock.to()
            • ResBlock.to_empty()
            • ResBlock.train()
            • ResBlock.type()
            • ResBlock.xpu()
            • ResBlock.zero_grad()
        • towhee.models.cvnet.resnet.ResNet
          • ResNet
            • ResNet.__call__()
            • ResNet.__init__()
            • ResNet.__repr__()
            • ResNet.add_module()
            • ResNet.apply()
            • ResNet.bfloat16()
            • ResNet.buffers()
            • ResNet.children()
            • ResNet.cpu()
            • ResNet.cuda()
            • ResNet.double()
            • ResNet.eval()
            • ResNet.extra_repr()
            • ResNet.float()
            • ResNet.forward()
            • ResNet.get_buffer()
            • ResNet.get_extra_state()
            • ResNet.get_parameter()
            • ResNet.get_submodule()
            • ResNet.half()
            • ResNet.ipu()
            • ResNet.load_state_dict()
            • ResNet.modules()
            • ResNet.named_buffers()
            • ResNet.named_children()
            • ResNet.named_modules()
            • ResNet.named_parameters()
            • ResNet.parameters()
            • ResNet.register_backward_hook()
            • ResNet.register_buffer()
            • ResNet.register_forward_hook()
            • ResNet.register_forward_pre_hook()
            • ResNet.register_full_backward_hook()
            • ResNet.register_full_backward_pre_hook()
            • ResNet.register_load_state_dict_post_hook()
            • ResNet.register_module()
            • ResNet.register_parameter()
            • ResNet.register_state_dict_pre_hook()
            • ResNet.requires_grad_()
            • ResNet.set_extra_state()
            • ResNet.share_memory()
            • ResNet.state_dict()
            • ResNet.to()
            • ResNet.to_empty()
            • ResNet.train()
            • ResNet.type()
            • ResNet.xpu()
            • ResNet.zero_grad()
        • towhee.models.cvnet.resnet.ResStage
          • ResStage
            • ResStage.__call__()
            • ResStage.__init__()
            • ResStage.__repr__()
            • ResStage.add_module()
            • ResStage.apply()
            • ResStage.bfloat16()
            • ResStage.buffers()
            • ResStage.children()
            • ResStage.cpu()
            • ResStage.cuda()
            • ResStage.double()
            • ResStage.eval()
            • ResStage.extra_repr()
            • ResStage.float()
            • ResStage.forward()
            • ResStage.get_buffer()
            • ResStage.get_extra_state()
            • ResStage.get_parameter()
            • ResStage.get_submodule()
            • ResStage.half()
            • ResStage.ipu()
            • ResStage.load_state_dict()
            • ResStage.modules()
            • ResStage.named_buffers()
            • ResStage.named_children()
            • ResStage.named_modules()
            • ResStage.named_parameters()
            • ResStage.parameters()
            • ResStage.register_backward_hook()
            • ResStage.register_buffer()
            • ResStage.register_forward_hook()
            • ResStage.register_forward_pre_hook()
            • ResStage.register_full_backward_hook()
            • ResStage.register_full_backward_pre_hook()
            • ResStage.register_load_state_dict_post_hook()
            • ResStage.register_module()
            • ResStage.register_parameter()
            • ResStage.register_state_dict_pre_hook()
            • ResStage.requires_grad_()
            • ResStage.set_extra_state()
            • ResStage.share_memory()
            • ResStage.state_dict()
            • ResStage.to()
            • ResStage.to_empty()
            • ResStage.train()
            • ResStage.type()
            • ResStage.xpu()
            • ResStage.zero_grad()
        • towhee.models.cvnet.resnet.ResStemIN
          • ResStemIN
            • ResStemIN.__call__()
            • ResStemIN.__init__()
            • ResStemIN.__repr__()
            • ResStemIN.add_module()
            • ResStemIN.apply()
            • ResStemIN.bfloat16()
            • ResStemIN.buffers()
            • ResStemIN.children()
            • ResStemIN.cpu()
            • ResStemIN.cuda()
            • ResStemIN.double()
            • ResStemIN.eval()
            • ResStemIN.extra_repr()
            • ResStemIN.float()
            • ResStemIN.forward()
            • ResStemIN.get_buffer()
            • ResStemIN.get_extra_state()
            • ResStemIN.get_parameter()
            • ResStemIN.get_submodule()
            • ResStemIN.half()
            • ResStemIN.ipu()
            • ResStemIN.load_state_dict()
            • ResStemIN.modules()
            • ResStemIN.named_buffers()
            • ResStemIN.named_children()
            • ResStemIN.named_modules()
            • ResStemIN.named_parameters()
            • ResStemIN.parameters()
            • ResStemIN.register_backward_hook()
            • ResStemIN.register_buffer()
            • ResStemIN.register_forward_hook()
            • ResStemIN.register_forward_pre_hook()
            • ResStemIN.register_full_backward_hook()
            • ResStemIN.register_full_backward_pre_hook()
            • ResStemIN.register_load_state_dict_post_hook()
            • ResStemIN.register_module()
            • ResStemIN.register_parameter()
            • ResStemIN.register_state_dict_pre_hook()
            • ResStemIN.requires_grad_()
            • ResStemIN.set_extra_state()
            • ResStemIN.share_memory()
            • ResStemIN.state_dict()
            • ResStemIN.to()
            • ResStemIN.to_empty()
            • ResStemIN.train()
            • ResStemIN.type()
            • ResStemIN.xpu()
            • ResStemIN.zero_grad()
    • towhee.models.drl
      • towhee.models.drl.drl
        • towhee.models.drl.drl.create_model
          • create_model()
        • towhee.models.drl.drl.DRL
          • DRL
            • DRL.__call__()
            • DRL.__init__()
            • DRL.__repr__()
            • DRL.add_module()
            • DRL.apply()
            • DRL.bfloat16()
            • DRL.buffers()
            • DRL.children()
            • DRL.cpu()
            • DRL.cuda()
            • DRL.double()
            • DRL.dtype
            • DRL.eval()