Welcome to Towhee’s documentation!

User Guide

User Guide:

• User Guide
  • DataCollection in 10 Minutes

User API

User API:

• towhee
  • api
  • dc
  • ops
  • register()
  • read_camera()
  • read_csv()
  • read_json()
  • read_zip()
  • glob
  • glob_zip
• towhee.DataCollection
  • Get Started
    • DataCollection Introduction
  • DataCollection
    • DataCollection
  • DataCollection Mixins
    • DatasetMixin
    • DispatcherMixin
    • ParallelMixin
    • ComputerVisionMixin
    • StateMixin
    • MetricMixin
    • MilvusMixin
    • FaissMixin
    • ConfigMixin
    • CompileMixin
• Built-in Operators
  • Runas OP
    • runas_op
  • Computer Vision
    • image_load
    • image_dump
    • image_resize
    • image_convert_color
    • image_filter
    • image_blur
  • Tensor Like
    • tensor_stack
    • tensor_unstack
    • tensor_concat
    • tensor_split
    • tensor_normalize
    • tensor_reshape
    • tensor_random
  • Feature Engineer
    • standard_scaler
    • num_discretizer
    • cate_one_hot_encoder
  • Scikit-Learn
    • logistic_regression
    • random_forest
    • decision_tree
    • svc
  • Milvus Search
    • 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()
    • NNOperator.load()
    • NNOperator.save()
  • PyOperator
    • PyOperator.__init__()
  • StatefulOperator
    • StatefulOperator.__init__()
    • StatefulOperator.__call__()
• trainer package
  • Subpackages
    • trainer.optimization package
    • trainer.utils package
  • Submodules
  • trainer.callback module
    • Callback
    • CallbackList
    • EarlyStoppingCallback
    • ModelCheckpointCallback
    • PrintCallBack
    • ProgressBarCallBack
    • TensorBoardCallBack
    • TrainerControl
  • trainer.metrics module
  • trainer.modelcard module
    • ModelCard
  • trainer.scheduler module
    • check_scheduler()
    • configure_constant_scheduler()
    • configure_constant_scheduler_with_warmup()
    • configure_cosine_scheduler_with_warmup()
    • configure_cosine_with_hard_restarts_scheduler_with_warmup()
    • configure_linear_scheduler_with_warmup()
    • configure_polynomial_decay_scheduler_with_warmup()
  • trainer.trainer module
  • trainer.training_config module
    • TrainingConfig
    • dump_default_yaml()
    • get_config_help()
  • Module contents
• trainer.optimization package
  • Submodules
  • trainer.optimization.adafactor module
    • Adafactor
  • trainer.optimization.adamw module
    • AdamW
  • trainer.optimization.optimization module
    • get_constant_schedule()
    • get_constant_schedule_with_warmup()
    • get_cosine_schedule_with_warmup()
    • get_cosine_with_hard_restarts_schedule_with_warmup()
    • get_linear_schedule_with_warmup()
    • get_polynomial_decay_schedule_with_warmup()
    • get_scheduler()
    • get_warmup_steps()
  • Module contents
• trainer.utils package
  • Submodules
  • trainer.utils.layer_freezer module
    • LayerFreezer
  • trainer.utils.trainer_utils module
    • SchedulerType
    • TrainOutput
    • get_last_checkpoint()
    • get_rank()
    • get_world_size()
    • honor_type()
    • is_dist_avail_and_initialized()
    • is_main_process()
    • is_torch_tensor()
    • recursively_apply()
    • reduce_value()
    • send_to_device()
    • set_seed()
    • unwrap_model()
  • Module contents

Full API

Full API:

• towhee
  • towhee.add_cache_path
    • add_cache_path()
  • towhee.build_docker_image
    • build_docker_image()
  • towhee.dataset
    • dataset()
  • towhee.plot
    • plot()
  • towhee.update_default_cache
    • update_default_cache()
  • towhee.Inject
    • Inject
      • Inject.__init__()
  • 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.ExecuteCommand
        • ExecuteCommand
          • ExecuteCommand.__call__()
          • ExecuteCommand.__init__()
          • ExecuteCommand.save_result()
    • towhee.command.repo
      • towhee.command.repo.PipeCommand
        • PipeCommand
          • PipeCommand.__call__()
          • PipeCommand.__init__()
      • 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.connectors
  • towhee.dag
    • towhee.dag.base_repr
      • towhee.dag.base_repr.BaseRepr
        • BaseRepr
          • BaseRepr.__init__()
          • BaseRepr.is_valid()
          • BaseRepr.load_file()
          • BaseRepr.load_src()
          • BaseRepr.load_str()
          • BaseRepr.load_url()
    • towhee.dag.dataframe_repr
      • towhee.dag.dataframe_repr.DataFrameRepr
        • DataFrameRepr
          • DataFrameRepr.__init__()
          • DataFrameRepr.from_dict()
          • DataFrameRepr.is_valid()
          • DataFrameRepr.load_file()
          • DataFrameRepr.load_src()
          • DataFrameRepr.load_str()
          • DataFrameRepr.load_url()
    • towhee.dag.graph_repr
      • towhee.dag.graph_repr.GraphRepr
        • GraphRepr
          • GraphRepr.__init__()
          • GraphRepr.dfs()
          • GraphRepr.from_dict()
          • GraphRepr.from_yaml()
          • GraphRepr.get_isolated_df()
          • GraphRepr.get_isolated_op()
          • GraphRepr.get_loop()
          • GraphRepr.is_valid()
          • GraphRepr.load_file()
          • GraphRepr.load_src()
          • GraphRepr.load_str()
          • GraphRepr.load_url()
          • GraphRepr.to_yaml()
    • towhee.dag.operator_repr
      • towhee.dag.operator_repr.OperatorRepr
        • OperatorRepr
          • OperatorRepr.__init__()
          • OperatorRepr.from_dict()
          • OperatorRepr.init_args
          • OperatorRepr.inputs
          • OperatorRepr.is_valid()
          • OperatorRepr.iter_info
          • OperatorRepr.load_file()
          • OperatorRepr.load_src()
          • OperatorRepr.load_str()
          • OperatorRepr.load_url()
          • OperatorRepr.outputs
          • OperatorRepr.tag
    • towhee.dag.pipeline_decorator
      • towhee.dag.pipeline_decorator.create_pipeline
        • create_pipeline()
    • towhee.dag.utils
      • towhee.dag.utils.callstack
        • towhee.dag.utils.callstack.Callstack
          • Callstack
            • Callstack.__init__()
            • Callstack.find_func()
            • Callstack.hash()
            • Callstack.num_frames()
    • towhee.dag.variable_repr
      • towhee.dag.variable_repr.VariableRepr
        • VariableRepr
          • VariableRepr.__init__()
          • VariableRepr.is_valid()
          • VariableRepr.load_file()
          • VariableRepr.load_src()
          • VariableRepr.load_str()
          • VariableRepr.load_url()
  • 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.dataframe
    • towhee.dataframe.array
      • towhee.dataframe.array.array
        • towhee.dataframe.array.array.Array
          • Array
            • Array.__init__()
            • Array.__repr__()
            • Array.append()
            • Array.data
            • Array.gc()
            • Array.is_empty()
            • Array.name
            • Array.put()
            • Array.size
      • towhee.dataframe.array.utils
        • towhee.dataframe.array.utils.full
          • full()
    • towhee.dataframe.dataframe
      • towhee.dataframe.dataframe.DataFrame
        • DataFrame
          • DataFrame.__getitem__()
          • DataFrame.__init__()
          • DataFrame.ack()
          • DataFrame.gc_blocked()
          • DataFrame.gc_data()
          • DataFrame.get()
          • DataFrame.get_window()
          • DataFrame.notify_map_block()
          • DataFrame.notify_window_block()
          • DataFrame.put()
          • DataFrame.register_iter()
          • DataFrame.remove_iter()
          • DataFrame.seal()
          • DataFrame.unblock_all()
          • DataFrame.unblock_iter()
      • towhee.dataframe.dataframe.Responses
        • Responses
    • towhee.dataframe.iterators
      • towhee.dataframe.iterators.BatchIterator
        • BatchIterator
          • BatchIterator.__init__()
          • BatchIterator.accessible_size
          • BatchIterator.current_index
          • BatchIterator.df_name
          • BatchIterator.notify()
      • towhee.dataframe.iterators.DataFrameIterator
        • DataFrameIterator
          • DataFrameIterator.__init__()
          • DataFrameIterator.accessible_size
          • DataFrameIterator.current_index
          • DataFrameIterator.df_name
          • DataFrameIterator.notify()
      • towhee.dataframe.iterators.MapIterator
        • MapIterator
          • MapIterator.__init__()
          • MapIterator.accessible_size
          • MapIterator.current_index
          • MapIterator.df_name
          • MapIterator.notify()
      • towhee.dataframe.iterators.WindowIterator
        • WindowIterator
          • WindowIterator.__init__()
          • WindowIterator.accessible_size
          • WindowIterator.current_index
          • WindowIterator.df_name
          • WindowIterator.notify()
  • towhee.engine
    • towhee.engine.engine
      • towhee.engine.engine.start_engine
        • start_engine()
    • towhee.engine.execution
      • towhee.engine.execution.base_execution
        • towhee.engine.execution.base_execution.BaseExecution
          • BaseExecution
            • BaseExecution.__call__()
      • towhee.engine.execution.pandas_execution
        • towhee.engine.execution.pandas_execution.PandasExecution
          • PandasExecution
      • towhee.engine.execution.stateful_execution
        • towhee.engine.execution.stateful_execution.StatefulExecution
          • StatefulExecution
      • towhee.engine.execution.vectorized_execution
        • towhee.engine.execution.vectorized_execution.VectorizedExecution
          • VectorizedExecution
    • towhee.engine.factory
      • towhee.engine.factory.op
        • op()
      • towhee.engine.factory.pipeline
        • pipeline()
    • towhee.engine.graph_context
      • towhee.engine.graph_context.GraphContext
        • GraphContext
          • GraphContext.__call__()
          • GraphContext.__init__()
          • GraphContext.inputs
          • GraphContext.outputs
          • GraphContext.slow_down()
          • GraphContext.speed_up()
    • towhee.engine.operator_context
      • towhee.engine.operator_context.OpStatus
        • OpStatus
      • towhee.engine.operator_context.OperatorContext
        • OperatorContext
          • OperatorContext.__init__()
          • OperatorContext.status
    • towhee.engine.operator_io
      • towhee.engine.operator_io.create_reader
        • create_reader()
      • towhee.engine.operator_io.create_writer
        • create_writer()
      • towhee.engine.operator_io.reader
        • towhee.engine.operator_io.reader.BatchFrameReader
          • BatchFrameReader
            • BatchFrameReader.__init__()
        • towhee.engine.operator_io.reader.BlockMapReaderWithOriginData
          • BlockMapReaderWithOriginData
            • BlockMapReaderWithOriginData.__init__()
            • BlockMapReaderWithOriginData.read()
        • towhee.engine.operator_io.reader.DataFrameReader
          • DataFrameReader
            • DataFrameReader.__init__()
        • towhee.engine.operator_io.reader.ReaderBase
          • ReaderBase
        • towhee.engine.operator_io.reader.TimeWindowReader
          • TimeWindowReader
            • TimeWindowReader.__init__()
      • towhee.engine.operator_io.writer
        • towhee.engine.operator_io.writer.DataFrameWriter
          • DataFrameWriter
            • DataFrameWriter.__init__()
        • towhee.engine.operator_io.writer.DictDataFrameWriter
          • DictDataFrameWriter
            • DictDataFrameWriter.__init__()
        • towhee.engine.operator_io.writer.RowDataFrameWriter
          • RowDataFrameWriter
            • RowDataFrameWriter.__init__()
    • towhee.engine.operator_loader
      • towhee.engine.operator_loader.OperatorLoader
        • OperatorLoader
          • OperatorLoader.__init__()
          • OperatorLoader.load_operator()
          • OperatorLoader.load_operator_from_path()
    • towhee.engine.operator_pool
      • towhee.engine.operator_pool.OperatorPool
        • OperatorPool
          • OperatorPool.__init__()
          • OperatorPool.acquire_op()
          • OperatorPool.release_op()
    • towhee.engine.operator_registry
      • towhee.engine.operator_registry.OperatorRegistry
        • OperatorRegistry
          • OperatorRegistry.__init__()
          • OperatorRegistry.register()
          • OperatorRegistry.resolve()
    • towhee.engine.operator_runner
      • towhee.engine.operator_runner.create_runner
        • create_runner()
      • towhee.engine.operator_runner.concat_runner
        • towhee.engine.operator_runner.concat_runner.ConcatRunner
          • ConcatRunner
            • ConcatRunner.__init__()
      • towhee.engine.operator_runner.filter_runner
        • towhee.engine.operator_runner.filter_runner.FilterRunner
          • FilterRunner
            • FilterRunner.__init__()
      • towhee.engine.operator_runner.flatmap_runner
        • towhee.engine.operator_runner.flatmap_runner.FlatMapRunner
          • FlatMapRunner
            • FlatMapRunner.__init__()
      • towhee.engine.operator_runner.generator_runner
        • towhee.engine.operator_runner.generator_runner.GeneratorRunner
          • GeneratorRunner
            • GeneratorRunner.__init__()
      • towhee.engine.operator_runner.map_runner
        • towhee.engine.operator_runner.map_runner.MapRunner
          • MapRunner
            • MapRunner.__init__()
      • towhee.engine.operator_runner.runner_base
        • towhee.engine.operator_runner.runner_base.RunnerBase
          • RunnerBase
            • RunnerBase.__init__()
        • towhee.engine.operator_runner.runner_base.RunnerStatus
          • RunnerStatus
      • towhee.engine.operator_runner.window_runner
        • towhee.engine.operator_runner.window_runner.WindowRunner
          • WindowRunner
            • WindowRunner.__init__()
    • towhee.engine.pipeline
      • towhee.engine.pipeline.Pipeline
        • Pipeline
          • Pipeline.__call__()
          • Pipeline.__init__()
          • Pipeline.__repr__()
    • towhee.engine.status
      • towhee.engine.status.Status
        • Status
          • Status.__init__()
    • towhee.engine.task_scheduler
      • towhee.engine.task_scheduler.BasicScheduler
        • BasicScheduler
          • BasicScheduler.__init__()
          • BasicScheduler.register()
          • BasicScheduler.schedule_forever()
          • BasicScheduler.schedule_step()
      • towhee.engine.task_scheduler.TaskScheduler
        • TaskScheduler
          • TaskScheduler.__init__()
          • TaskScheduler.schedule_forever()
    • towhee.engine.thread_pool_task_executor
      • towhee.engine.thread_pool_task_executor.ThreadPoolTaskExecutor
        • ThreadPoolTaskExecutor
          • ThreadPoolTaskExecutor.__init__()
          • ThreadPoolTaskExecutor.__repr__()
          • ThreadPoolTaskExecutor.daemon
          • ThreadPoolTaskExecutor.ident
          • ThreadPoolTaskExecutor.is_alive()
          • ThreadPoolTaskExecutor.join()
          • ThreadPoolTaskExecutor.name
          • ThreadPoolTaskExecutor.native_id
          • ThreadPoolTaskExecutor.push_task()
          • ThreadPoolTaskExecutor.run()
          • ThreadPoolTaskExecutor.start()
          • ThreadPoolTaskExecutor.stop()
    • towhee.engine.uri
      • towhee.engine.uri.URI
        • URI
          • URI.__init__()
  • towhee.errors
    • towhee.errors.EmptyInputError
      • EmptyInputError
    • towhee.errors.GraphError
      • GraphError
    • towhee.errors.NoSchedulerError
      • NoSchedulerError
    • towhee.errors.OpFailedError
      • OpFailedError
    • towhee.errors.OpIOTypeError
      • OpIOTypeError
    • towhee.errors.OpTypeError
      • OpTypeError
    • towhee.errors.SchedulerTypeError
      • SchedulerTypeError
    • towhee.errors.TowheeError
      • TowheeError
  • towhee.functional
    • towhee.functional.from_df
      • from_df()
    • towhee.functional.data_collection
      • towhee.functional.data_collection.DataCollection
        • DataCollection
          • DataCollection.__add__()
          • DataCollection.__getattr__()
          • DataCollection.__getitem__()
          • DataCollection.__init__()
          • DataCollection.__repr__()
          • DataCollection.__setitem__()
          • DataCollection.append()
          • DataCollection.as_function()
          • DataCollection.batch()
          • DataCollection.clear()
          • DataCollection.config()
          • DataCollection.copy()
          • DataCollection.count()
          • DataCollection.drop_empty()
          • DataCollection.exception_safe()
          • DataCollection.extend()
          • DataCollection.fill_empty()
          • DataCollection.filter()
          • DataCollection.flatten()
          • DataCollection.from_glob()
          • DataCollection.get_config()
          • DataCollection.get_pipeline_config()
          • DataCollection.get_state()
          • DataCollection.head()
          • DataCollection.insert()
          • DataCollection.is_stream
          • DataCollection.map()
          • DataCollection.mmap()
          • DataCollection.pipeline_config()
          • DataCollection.pmap()
          • DataCollection.pop()
          • DataCollection.range()
          • DataCollection.ray_start()
          • DataCollection.read_camera()
          • DataCollection.read_video()
          • DataCollection.read_zip()
          • DataCollection.remove()
          • DataCollection.report()
          • DataCollection.reverse()
          • DataCollection.rolling()
          • DataCollection.run()
          • DataCollection.safe()
          • DataCollection.sample()
          • DataCollection.select_from()
          • DataCollection.serve()
          • DataCollection.set_evaluating()
          • DataCollection.set_format_priority()
          • DataCollection.set_parallel()
          • DataCollection.set_state()
          • DataCollection.set_training()
          • DataCollection.show()
          • DataCollection.shuffle()
          • DataCollection.sort()
          • DataCollection.split()
          • DataCollection.split_train_test()
          • DataCollection.stream()
          • DataCollection.to_csv()
          • DataCollection.to_df()
          • DataCollection.to_list()
          • DataCollection.to_video()
          • DataCollection.unstream()
          • DataCollection.zip()
      • towhee.functional.data_collection.DataFrame
        • DataFrame
          • DataFrame.ModeFlag
          • DataFrame.__add__()
          • DataFrame.__getattr__()
          • DataFrame.__getitem__()
          • DataFrame.__init__()
          • DataFrame.__repr__()
          • DataFrame.__setitem__()
          • DataFrame.append()
          • DataFrame.as_entity()
          • DataFrame.as_function()
          • DataFrame.as_json()
          • DataFrame.as_raw()
          • DataFrame.batch()
          • DataFrame.clear()
          • DataFrame.cmap()
          • DataFrame.config()
          • DataFrame.copy()
          • DataFrame.count()
          • DataFrame.drop_empty()
          • DataFrame.dropna()
          • DataFrame.exception_safe()
          • DataFrame.extend()
          • DataFrame.fill_empty()
          • DataFrame.fill_entity()
          • DataFrame.filter()
          • DataFrame.flatten()
          • DataFrame.from_glob()
          • DataFrame.get_config()
          • DataFrame.get_pipeline_config()
          • DataFrame.get_state()
          • DataFrame.head()
          • DataFrame.insert()
          • DataFrame.is_stream
          • DataFrame.map()
          • DataFrame.mmap()
          • DataFrame.mode
          • DataFrame.parse_json()
          • DataFrame.pipeline_config()
          • DataFrame.pmap()
          • DataFrame.pop()
          • DataFrame.range()
          • DataFrame.ray_start()
          • DataFrame.read_camera()
          • DataFrame.read_video()
          • DataFrame.read_zip()
          • DataFrame.remove()
          • DataFrame.rename()
          • DataFrame.replace()
          • DataFrame.report()
          • DataFrame.reverse()
          • DataFrame.rolling()
          • DataFrame.run()
          • DataFrame.safe()
          • DataFrame.sample()
          • DataFrame.select_from()
          • DataFrame.serve()
          • DataFrame.set_chunksize()
          • DataFrame.set_evaluating()
          • DataFrame.set_format_priority()
          • DataFrame.set_parallel()
          • DataFrame.set_state()
          • DataFrame.set_training()
          • DataFrame.show()
          • DataFrame.shuffle()
          • DataFrame.sort()
          • DataFrame.split()
          • DataFrame.split_train_test()
          • DataFrame.stream()
          • DataFrame.to_column()
          • DataFrame.to_csv()
          • DataFrame.to_dc()
          • DataFrame.to_df()
          • DataFrame.to_list()
          • DataFrame.to_video()
          • DataFrame.unstream()
          • DataFrame.zip()
    • towhee.functional.entity
      • towhee.functional.entity.Entity
        • Entity
          • Entity.__init__()
          • Entity.__repr__()
      • towhee.functional.entity.EntityView
        • EntityView
          • EntityView.__init__()
          • EntityView.__repr__()
    • towhee.functional.mixins
      • towhee.functional.mixins.DCMixins
        • DCMixins
          • DCMixins.__init__()
          • DCMixins.append()
          • DCMixins.as_function()
          • DCMixins.batch()
          • DCMixins.clear()
          • DCMixins.config()
          • DCMixins.copy()
          • DCMixins.count()
          • DCMixins.drop_empty()
          • DCMixins.exception_safe()
          • DCMixins.extend()
          • DCMixins.fill_empty()
          • DCMixins.flatten()
          • DCMixins.from_glob()
          • DCMixins.get_config()
          • DCMixins.get_pipeline_config()
          • DCMixins.get_state()
          • DCMixins.head()
          • DCMixins.insert()
          • DCMixins.is_stream
          • DCMixins.mmap()
          • DCMixins.pipeline_config()
          • DCMixins.pmap()
          • DCMixins.pop()
          • DCMixins.ray_start()
          • DCMixins.read_camera()
          • DCMixins.read_video()
          • DCMixins.read_zip()
          • DCMixins.remove()
          • DCMixins.report()
          • DCMixins.reverse()
          • DCMixins.rolling()
          • DCMixins.safe()
          • DCMixins.sample()
          • DCMixins.select_from()
          • DCMixins.serve()
          • DCMixins.set_evaluating()
          • DCMixins.set_format_priority()
          • DCMixins.set_parallel()
          • DCMixins.set_state()
          • DCMixins.set_training()
          • DCMixins.show()
          • DCMixins.shuffle()
          • DCMixins.sort()
          • DCMixins.split()
          • DCMixins.split_train_test()
          • DCMixins.stream()
          • DCMixins.to_csv()
          • DCMixins.to_video()
          • DCMixins.unstream()
          • DCMixins.zip()
      • towhee.functional.mixins.column
        • towhee.functional.mixins.column.ColumnMixin
          • ColumnMixin
            • ColumnMixin.ModeFlag
            • ColumnMixin.__init__()
            • ColumnMixin.cmap()
            • ColumnMixin.set_chunksize()
            • ColumnMixin.to_column()
      • towhee.functional.mixins.compile
        • towhee.functional.mixins.compile.CompileMixin
          • CompileMixin
            • CompileMixin.__init__()
        • towhee.functional.mixins.compile.NumbaCompiler
          • NumbaCompiler
            • NumbaCompiler.__call__()
            • NumbaCompiler.__init__()
        • towhee.functional.mixins.compile.TowheeCompiler
          • TowheeCompiler
            • TowheeCompiler.__call__()
            • TowheeCompiler.__init__()
      • towhee.functional.mixins.computer_vision
        • towhee.functional.mixins.computer_vision.ComputerVisionMixin
          • ComputerVisionMixin
            • ComputerVisionMixin.read_camera()
            • ComputerVisionMixin.read_video()
            • ComputerVisionMixin.to_video()
      • towhee.functional.mixins.config
        • towhee.functional.mixins.config.ConfigMixin
          • ConfigMixin
            • ConfigMixin.__init__()
            • ConfigMixin.config()
            • ConfigMixin.get_config()
            • ConfigMixin.get_pipeline_config()
            • ConfigMixin.pipeline_config()
      • towhee.functional.mixins.dag
        • towhee.functional.mixins.dag.register_dag
          • register_dag()
        • towhee.functional.mixins.dag.ControlPlane
          • ControlPlane
            • ControlPlane.__init__()
        • towhee.functional.mixins.dag.DagMixin
          • DagMixin
            • DagMixin.__init__()
      • towhee.functional.mixins.data_processing
        • towhee.functional.mixins.data_processing.DataProcessingMixin
          • DataProcessingMixin
            • DataProcessingMixin.batch()
            • DataProcessingMixin.flatten()
            • DataProcessingMixin.head()
            • DataProcessingMixin.rolling()
            • DataProcessingMixin.sample()
            • DataProcessingMixin.select_from()
            • DataProcessingMixin.shuffle()
            • DataProcessingMixin.zip()
      • towhee.functional.mixins.dataframe
        • towhee.functional.mixins.dataframe.DataFrameMixin
          • DataFrameMixin
            • DataFrameMixin.__init__()
            • DataFrameMixin.as_entity()
            • DataFrameMixin.as_json()
            • DataFrameMixin.as_raw()
            • DataFrameMixin.dropna()
            • DataFrameMixin.fill_entity()
            • DataFrameMixin.parse_json()
            • DataFrameMixin.rename()
            • DataFrameMixin.replace()
      • towhee.functional.mixins.dataset
        • towhee.functional.mixins.dataset.DatasetMixin
          • DatasetMixin
            • DatasetMixin.from_glob()
            • DatasetMixin.read_zip()
            • DatasetMixin.split_train_test()
            • DatasetMixin.to_csv()
      • towhee.functional.mixins.dispatcher
        • towhee.functional.mixins.dispatcher.DispatcherMixin
          • DispatcherMixin
      • towhee.functional.mixins.display
        • towhee.functional.mixins.display.calc_df
          • calc_df()
        • towhee.functional.mixins.display.get_df_on_columns
          • get_df_on_columns()
        • towhee.functional.mixins.display.table_display
          • table_display()
        • towhee.functional.mixins.display.to_html_table
          • to_html_table()
        • towhee.functional.mixins.display.to_plain_table
          • to_plain_table()
        • towhee.functional.mixins.display.to_printable_table
          • to_printable_table()
        • towhee.functional.mixins.display.DisplayMixin
          • DisplayMixin
            • DisplayMixin.__init__()
            • DisplayMixin.show()
      • towhee.functional.mixins.faiss
        • towhee.functional.mixins.faiss.get_faiss_index
          • get_faiss_index()
        • towhee.functional.mixins.faiss.FaissMixin
          • FaissMixin
            • FaissMixin.__init__()
      • towhee.functional.mixins.format_priority
        • towhee.functional.mixins.format_priority.FormatPriorityMixin
          • FormatPriorityMixin
            • FormatPriorityMixin.__init__()
            • FormatPriorityMixin.set_format_priority()
      • towhee.functional.mixins.list
        • towhee.functional.mixins.list.ListMixin
          • ListMixin
            • ListMixin.append()
            • ListMixin.clear()
            • ListMixin.copy()
            • ListMixin.count()
            • ListMixin.extend()
            • ListMixin.insert()
            • ListMixin.pop()
            • ListMixin.remove()
            • ListMixin.reverse()
            • ListMixin.sort()
      • towhee.functional.mixins.metric
        • towhee.functional.mixins.metric.encode_fig_img
          • encode_fig_img()
        • towhee.functional.mixins.metric.get_scores_dict
          • get_scores_dict()
        • towhee.functional.mixins.metric.mean_average_precision
          • mean_average_precision()
        • towhee.functional.mixins.metric.mean_hit_ratio
          • mean_hit_ratio()
        • towhee.functional.mixins.metric.Collector
          • Collector
            • Collector.__init__()
        • towhee.functional.mixins.metric.MetricMixin
          • MetricMixin
            • MetricMixin.__init__()
            • MetricMixin.report()
      • towhee.functional.mixins.milvus
        • towhee.functional.mixins.milvus.MilvusMixin
          • MilvusMixin
            • MilvusMixin.__init__()
      • towhee.functional.mixins.parallel
        • towhee.functional.mixins.parallel.initializer
          • initializer()
        • towhee.functional.mixins.parallel.EOS
          • EOS
        • towhee.functional.mixins.parallel.ParallelMixin
          • ParallelMixin
            • ParallelMixin.__init__()
            • ParallelMixin.mmap()
            • ParallelMixin.pmap()
            • ParallelMixin.set_parallel()
            • ParallelMixin.split()
      • towhee.functional.mixins.ray
        • towhee.functional.mixins.ray.RayMixin
          • RayMixin
            • RayMixin.ray_start()
      • towhee.functional.mixins.remote
        • towhee.functional.mixins.remote.RemoteMixin
          • RemoteMixin
      • towhee.functional.mixins.safe
        • towhee.functional.mixins.safe.SafeMixin
          • SafeMixin
            • SafeMixin.drop_empty()
            • SafeMixin.exception_safe()
            • SafeMixin.fill_empty()
            • SafeMixin.safe()
      • towhee.functional.mixins.serve
        • towhee.functional.mixins.serve.ServeMixin
          • ServeMixin
            • ServeMixin.as_function()
            • ServeMixin.serve()
      • towhee.functional.mixins.state
        • towhee.functional.mixins.state.StateMixin
          • StateMixin
            • StateMixin.__init__()
            • StateMixin.get_state()
            • StateMixin.set_evaluating()
            • StateMixin.set_state()
            • StateMixin.set_training()
      • towhee.functional.mixins.stream
        • towhee.functional.mixins.stream.StreamMixin
          • StreamMixin
            • StreamMixin.is_stream
            • StreamMixin.stream()
            • StreamMixin.unstream()
    • towhee.functional.option
      • towhee.functional.option.Empty
        • Empty
          • Empty.__init__()
          • Empty.__repr__()
          • Empty.empty()
          • Empty.flat_map()
          • Empty.get()
          • Empty.get_or_else()
          • Empty.is_empty()
          • Empty.is_some()
          • Empty.map()
          • Empty.of()
      • towhee.functional.option.Option
        • Option
          • Option.empty()
          • Option.flat_map()
          • Option.get_or_else()
          • Option.is_empty()
          • Option.is_some()
          • Option.map()
          • Option.of()
      • towhee.functional.option.Some
        • Some
          • Some.__init__()
          • Some.__repr__()
          • Some.empty()
          • Some.flat_map()
          • Some.get()
          • Some.get_or_else()
          • Some.is_empty()
          • Some.is_some()
          • Some.map()
          • Some.of()
    • towhee.functional.storages
      • towhee.functional.storages.ChunkedTable
        • ChunkedTable
          • ChunkedTable.__init__()
      • towhee.functional.storages.WritableTable
        • WritableTable
          • WritableTable.__init__()
          • WritableTable.__repr__()
  • towhee.hparam
    • towhee.hparam.hyperparameter
      • towhee.hparam.hyperparameter.all_params
        • all_params()
      • towhee.hparam.hyperparameter.auto_param
        • auto_param()
      • towhee.hparam.hyperparameter.dynamic_dispatch
        • dynamic_dispatch()
      • towhee.hparam.hyperparameter.reads
        • reads()
      • towhee.hparam.hyperparameter.safe_numeric
        • safe_numeric()
      • towhee.hparam.hyperparameter.set_auto_param_callback
        • set_auto_param_callback()
      • towhee.hparam.hyperparameter.writes
        • writes()
      • towhee.hparam.hyperparameter.DynamicDispatch
        • DynamicDispatch
          • DynamicDispatch.__call__()
          • DynamicDispatch.__init__()
      • towhee.hparam.hyperparameter.HyperParameter
        • HyperParameter
          • HyperParameter.__call__()
          • HyperParameter.__getattr__()
          • HyperParameter.__getitem__()
          • HyperParameter.__init__()
          • HyperParameter.__or__()
          • HyperParameter.__repr__()
          • HyperParameter.__setitem__()
          • HyperParameter.clear()
          • HyperParameter.copy()
          • HyperParameter.dispatch()
          • HyperParameter.fromkeys()
          • HyperParameter.get()
          • HyperParameter.items()
          • HyperParameter.keys()
          • HyperParameter.load()
          • HyperParameter.loads()
          • HyperParameter.pop()
          • HyperParameter.popitem()
          • HyperParameter.put()
          • HyperParameter.setdefault()
          • HyperParameter.update()
          • HyperParameter.values()
      • towhee.hparam.hyperparameter.param_scope
        • param_scope
          • param_scope.__call__()
          • param_scope.__getattr__()
          • param_scope.__getitem__()
          • param_scope.__init__()
          • param_scope.__or__()
          • param_scope.__repr__()
          • param_scope.__setitem__()
          • param_scope.clear()
          • param_scope.copy()
          • param_scope.dispatch()
          • param_scope.fromkeys()
          • param_scope.get()
          • param_scope.init()
          • param_scope.items()
          • param_scope.keys()
          • param_scope.load()
          • param_scope.loads()
          • param_scope.pop()
          • param_scope.popitem()
          • param_scope.put()
          • param_scope.setdefault()
          • param_scope.update()
          • param_scope.values()
  • towhee.hub
    • towhee.hub.bin
      • towhee.hub.bin.hub_tools
        • towhee.hub.bin.hub_tools.get_repo_obj
          • get_repo_obj()
        • towhee.hub.bin.hub_tools.init_repo
          • init_repo()
        • towhee.hub.bin.hub_tools.main
          • main()
    • towhee.hub.builtin
      • towhee.hub.builtin.operators
        • towhee.hub.builtin.operators.computer_vision
          • towhee.hub.builtin.operators.computer_vision.image_blur
            • image_blur
              • image_blur.__call__()
              • image_blur.__init__()
          • towhee.hub.builtin.operators.computer_vision.image_convert_color
            • image_convert_color
              • image_convert_color.__call__()
              • image_convert_color.__init__()
          • towhee.hub.builtin.operators.computer_vision.image_dump
            • image_dump
              • image_dump.__call__()
              • image_dump.__init__()
          • towhee.hub.builtin.operators.computer_vision.image_filter
            • image_filter
              • image_filter.__call__()
              • image_filter.__init__()
          • towhee.hub.builtin.operators.computer_vision.image_resize
            • image_resize
              • image_resize.__call__()
              • image_resize.__init__()
          • towhee.hub.builtin.operators.computer_vision.save_image
            • save_image
              • save_image.__call__()
              • save_image.__init__()
        • towhee.hub.builtin.operators.faiss_search
          • towhee.hub.builtin.operators.faiss_search.faiss_search
            • faiss_search
              • faiss_search.__call__()
              • faiss_search.__init__()
        • towhee.hub.builtin.operators.feature_engineer
          • towhee.hub.builtin.operators.feature_engineer.cate_one_hot_encoder
            • cate_one_hot_encoder
              • cate_one_hot_encoder.__call__()
              • cate_one_hot_encoder.__init__()
          • towhee.hub.builtin.operators.feature_engineer.num_discretizer
            • num_discretizer
              • num_discretizer.__call__()
              • num_discretizer.__init__()
          • towhee.hub.builtin.operators.feature_engineer.standard_scaler
            • standard_scaler
              • standard_scaler.__call__()
              • standard_scaler.__init__()
        • towhee.hub.builtin.operators.milvus_search
          • towhee.hub.builtin.operators.milvus_search.milvus_search
            • milvus_search
              • milvus_search.__call__()
              • milvus_search.__init__()
        • towhee.hub.builtin.operators.runas_op
          • towhee.hub.builtin.operators.runas_op.runas_op
            • runas_op
              • runas_op.__call__()
              • runas_op.__init__()
        • towhee.hub.builtin.operators.sklearn
          • towhee.hub.builtin.operators.sklearn.decision_tree
            • decision_tree
              • decision_tree.__call__()
              • decision_tree.__init__()
          • towhee.hub.builtin.operators.sklearn.logistic_regression
            • logistic_regression
              • logistic_regression.__call__()
              • logistic_regression.__init__()
          • towhee.hub.builtin.operators.sklearn.random_forest
            • random_forest
              • random_forest.__call__()
              • random_forest.__init__()
          • towhee.hub.builtin.operators.sklearn.svc
            • svc
              • svc.__call__()
              • svc.__init__()
        • towhee.hub.builtin.operators.tensor_like
          • towhee.hub.builtin.operators.tensor_like.tensor_concat
            • tensor_concat
              • tensor_concat.__call__()
              • tensor_concat.__init__()
          • towhee.hub.builtin.operators.tensor_like.tensor_matmul
            • tensor_matmul
              • tensor_matmul.__call__()
              • tensor_matmul.__init__()
          • towhee.hub.builtin.operators.tensor_like.tensor_normalize
            • tensor_normalize
              • tensor_normalize.__call__()
              • tensor_normalize.__init__()
          • towhee.hub.builtin.operators.tensor_like.tensor_random
            • tensor_random
              • tensor_random.__call__()
              • tensor_random.__init__()
          • towhee.hub.builtin.operators.tensor_like.tensor_reshape
            • tensor_reshape
              • tensor_reshape.__call__()
              • tensor_reshape.__init__()
          • towhee.hub.builtin.operators.tensor_like.tensor_split
            • tensor_split
              • tensor_split.__call__()
              • tensor_split.__init__()
          • towhee.hub.builtin.operators.tensor_like.tensor_stack
            • tensor_stack
              • tensor_stack.__call__()
              • tensor_stack.__init__()
          • towhee.hub.builtin.operators.tensor_like.tensor_unstack
            • tensor_unstack
              • tensor_unstack.__call__()
              • tensor_unstack.__init__()
      • towhee.hub.builtin.pipelines
    • towhee.hub.cmdline
      • towhee.hub.cmdline.main
        • main()
      • towhee.hub.cmdline.main_body
        • main_body()
    • towhee.hub.file_manager
    • towhee.hub.operator_manager
      • towhee.hub.operator_manager.OperatorManager
        • OperatorManager
          • OperatorManager.__init__()
          • OperatorManager.check()
          • OperatorManager.check_yaml()
          • OperatorManager.create()
          • OperatorManager.create_with_token()
          • OperatorManager.download()
          • OperatorManager.download_executor()
          • OperatorManager.download_files()
          • OperatorManager.exists()
          • OperatorManager.generate_yaml()
          • 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.preclude
    • 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.hub.subcmds
      • towhee.hub.subcmds.develop
        • towhee.hub.subcmds.develop.DevelopCommand
          • DevelopCommand
            • DevelopCommand.__call__()
            • DevelopCommand.__init__()
      • towhee.hub.subcmds.execute
        • towhee.hub.subcmds.execute.ExecuteCommand
          • ExecuteCommand
            • ExecuteCommand.__call__()
            • ExecuteCommand.__init__()
  • 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.init_weights()
            • 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.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.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()
            • DRL.extra_repr()
            • DRL.float()
            • DRL.forward()
            • DRL.get_buffer()
            • DRL.get_extra_state()
            • DRL.get_parameter()
            • DRL.get_submodule()
            • DRL.half()
            • DRL.init_weights()
            • DRL.ipu()
            • DRL.load_state_dict()
            • DRL.modules()
            • DRL.named_buffers()
            • DRL.named_children()
            • DRL.named_modules()
            • DRL.named_parameters()
            • DRL.parameters()
            • DRL.register_backward_hook()
            • DRL.register_buffer()
            • DRL.register_forward_hook()
            • DRL.register_forward_pre_hook()
            • DRL.register_full_backward_hook()
            • DRL.register_full_backward_pre_hook()
            • DRL.register_load_state_dict_post_hook()
            • DRL.register_module()
            • DRL.register_parameter()
            • DRL.register_state_dict_pre_hook()
            • DRL.requires_grad_()
            • DRL.set_extra_state()
            • DRL.share_memory()
            • DRL.state_dict()
            • DRL.to()
            • DRL.to_empty()
            • DRL.train()
            • DRL.type()
            • DRL.xpu()
            • DRL.zero_grad()
      • towhee.models.drl.module_cross
        • towhee.models.drl.module_cross.CrossEmbeddings
          • CrossEmbeddings
            • CrossEmbeddings.__call__()
            • CrossEmbeddings.__init__()
            • CrossEmbeddings.__repr__()
            • CrossEmbeddings.add_module()
            • CrossEmbeddings.apply()
            • CrossEmbeddings.bfloat16()
            • CrossEmbeddings.buffers()
            • CrossEmbeddings.children()
            • CrossEmbeddings.cpu()
            • CrossEmbeddings.cuda()
            • CrossEmbeddings.double()
            • CrossEmbeddings.eval()
            • CrossEmbeddings.extra_repr()
            • CrossEmbeddings.float()
            • CrossEmbeddings.forward()
            • CrossEmbeddings.get_buffer()
            • CrossEmbeddings.get_extra_state()
            • CrossEmbeddings.get_parameter()
            • CrossEmbeddings.get_submodule()
            • CrossEmbeddings.half()
            • CrossEmbeddings.ipu()
            • CrossEmbeddings.load_state_dict()
            • CrossEmbeddings.modules()
            • CrossEmbeddings.named_buffers()
            • CrossEmbeddings.named_children()
            • CrossEmbeddings.named_modules()
            • CrossEmbeddings.named_parameters()
            • CrossEmbeddings.parameters()
            • CrossEmbeddings.register_backward_hook()
            • CrossEmbeddings.register_buffer()
            • CrossEmbeddings.register_forward_hook()
            • CrossEmbeddings.register_forward_pre_hook()
            • CrossEmbeddings.register_full_backward_hook()
            • CrossEmbeddings.register_full_backward_pre_hook()
            • CrossEmbeddings.register_load_state_dict_post_hook()
            • CrossEmbeddings.register_module()
            • CrossEmbeddings.register_parameter()
            • CrossEmbeddings.register_state_dict_pre_hook()
            • CrossEmbeddings.requires_grad_()
            • CrossEmbeddings.set_extra_state()
            • CrossEmbeddings.share_memory()
            • CrossEmbeddings.state_dict()
            • CrossEmbeddings.to()
            • CrossEmbeddings.to_empty()
            • CrossEmbeddings.train()
            • CrossEmbeddings.type()
            • CrossEmbeddings.xpu()
            • CrossEmbeddings.zero_grad()
        • towhee.models.drl.module_cross.CrossModel
          • CrossModel
            • CrossModel.__call__()
            • CrossModel.__init__()
            • CrossModel.__repr__()
            • CrossModel.add_module()
            • CrossModel.apply()
            • CrossModel.bfloat16()
            • CrossModel.buffers()
            • CrossModel.children()
            • CrossModel.cpu()
            • CrossModel.cuda()
            • CrossModel.double()
            • CrossModel.dtype
            • CrossModel.eval()
            • CrossModel.extra_repr()
            • CrossModel.float()
            • CrossModel.forward()
            • CrossModel.get_buffer()
            • CrossModel.get_extra_state()
            • CrossModel.get_parameter()
            • CrossModel.get_submodule()
            • CrossModel.half()
            • CrossModel.init_weights()
            • CrossModel.ipu()
            • CrossModel.load_state_dict()
            • CrossModel.modules()
            • CrossModel.named_buffers()
            • CrossModel.named_children()
            • CrossModel.named_modules()
            • CrossModel.named_parameters()
            • CrossModel.parameters()
            • CrossModel.register_backward_hook()
            • CrossModel.register_buffer()
            • CrossModel.register_forward_hook()
            • CrossModel.register_forward_pre_hook()
            • CrossModel.register_full_backward_hook()
            • CrossModel.register_full_backward_pre_hook()
            • CrossModel.register_load_state_dict_post_hook()
            • CrossModel.register_module()
            • CrossModel.register_parameter()
            • CrossModel.register_state_dict_pre_hook()
            • CrossModel.requires_grad_()
            • CrossModel.set_extra_state()
            • CrossModel.share_memory()
            • CrossModel.state_dict()
            • CrossModel.to()
            • CrossModel.to_empty()
            • CrossModel.train()
            • CrossModel.type()
            • CrossModel.xpu()
            • CrossModel.zero_grad()
        • towhee.models.drl.module_cross.CrossPooler
          • CrossPooler
            • CrossPooler.__call__()
            • CrossPooler.__init__()
            • CrossPooler.__repr__()
            • CrossPooler.add_module()
            • CrossPooler.apply()
            • CrossPooler.bfloat16()
            • CrossPooler.buffers()
            • CrossPooler.children()
            • CrossPooler.cpu()
            • CrossPooler.cuda()
            • CrossPooler.double()
            • CrossPooler.eval()
            • CrossPooler.extra_repr()
            • CrossPooler.float()
            • CrossPooler.forward()
            • CrossPooler.get_buffer()
            • CrossPooler.get_extra_state()
            • CrossPooler.get_parameter()
            • CrossPooler.get_submodule()
            • CrossPooler.half()
            • CrossPooler.ipu()
            • CrossPooler.load_state_dict()
            • CrossPooler.modules()
            • CrossPooler.named_buffers()
            • CrossPooler.named_children()
            • CrossPooler.named_modules()
            • CrossPooler.named_parameters()
            • CrossPooler.parameters()
            • CrossPooler.register_backward_hook()
            • CrossPooler.register_buffer()
            • CrossPooler.register_forward_hook()
            • CrossPooler.register_forward_pre_hook()
            • CrossPooler.register_full_backward_hook()
            • CrossPooler.register_full_backward_pre_hook()
            • CrossPooler.register_load_state_dict_post_hook()
            • CrossPooler.register_module()
            • CrossPooler.register_parameter()
            • CrossPooler.register_state_dict_pre_hook()
            • CrossPooler.requires_grad_()
            • CrossPooler.set_extra_state()
            • CrossPooler.share_memory()
            • CrossPooler.state_dict()
            • CrossPooler.to()
            • CrossPooler.to_empty()
            • CrossPooler.train()
            • CrossPooler.type()
            • CrossPooler.xpu()
            • CrossPooler.zero_grad()
        • towhee.models.drl.module_cross.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.drl.module_cross.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.drl.module_cross.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.drl.until_module
        • towhee.models.drl.until_module.convert_weights
          • convert_weights()
        • towhee.models.drl.until_module.gelu
          • gelu()
        • towhee.models.drl.until_module.swish
          • swish()
        • towhee.models.drl.until_module.AllGather
          • AllGather
            • AllGather.__call__()
            • AllGather.__init__()
            • AllGather.backward()
            • AllGather.forward()
            • AllGather.is_traceable
            • AllGather.jvp()
            • AllGather.mark_dirty()
            • AllGather.mark_non_differentiable()
            • AllGather.save_for_backward()
            • AllGather.save_for_forward()
            • AllGather.set_materialize_grads()
            • AllGather.setup_context()
            • AllGather.vjp()
            • AllGather.vmap()
        • towhee.models.drl.until_module.AllGather2
          • AllGather2
            • AllGather2.__call__()
            • AllGather2.__init__()
            • AllGather2.backward()
            • AllGather2.forward()
            • AllGather2.is_traceable
            • AllGather2.jvp()
            • AllGather2.mark_dirty()
            • AllGather2.mark_non_differentiable()
            • AllGather2.save_for_backward()
            • AllGather2.save_for_forward()
            • AllGather2.set_materialize_grads()
            • AllGather2.setup_context()
            • AllGather2.vjp()
            • AllGather2.vmap()
        • towhee.models.drl.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.drl.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.embedding
      • towhee.models.embedding.embedding_extractor
        • towhee.models.embedding.embedding_extractor.EmbeddingExtractor
          • EmbeddingExtractor
            • EmbeddingExtractor.__init__()
            • EmbeddingExtractor.disp_modules()
            • EmbeddingExtractor.register()
        • towhee.models.embedding.embedding_extractor.EmbeddingOutput
          • EmbeddingOutput
            • EmbeddingOutput.__call__()
            • EmbeddingOutput.__init__()
            • EmbeddingOutput.clear()
    • towhee.models.layers
      • towhee.models.layers.activations
        • towhee.models.layers.activations.gelu
        • towhee.models.layers.activations.hardmish
          • towhee.models.layers.activations.hardmish.hard_mish
            • hard_mish()
          • towhee.models.layers.activations.hardmish.HardMish
            • HardMish
              • HardMish.__call__()
              • HardMish.__init__()
              • HardMish.__repr__()
              • HardMish.add_module()
              • HardMish.apply()
              • HardMish.bfloat16()
              • HardMish.buffers()
              • HardMish.children()
              • HardMish.cpu()
              • HardMish.cuda()
              • HardMish.double()
              • HardMish.eval()
              • HardMish.extra_repr()
              • HardMish.float()
              • HardMish.forward()
              • HardMish.get_buffer()
              • HardMish.get_extra_state()
              • HardMish.get_parameter()
              • HardMish.get_submodule()
              • HardMish.half()
              • HardMish.ipu()
              • HardMish.load_state_dict()
              • HardMish.modules()
              • HardMish.named_buffers()
              • HardMish.named_children()
              • HardMish.named_modules()
              • HardMish.named_parameters()
              • HardMish.parameters()
              • HardMish.register_backward_hook()
              • HardMish.register_buffer()
              • HardMish.register_forward_hook()
              • HardMish.register_forward_pre_hook()
              • HardMish.register_full_backward_hook()
              • HardMish.register_full_backward_pre_hook()
              • HardMish.register_load_state_dict_post_hook()
              • HardMish.register_module()
              • HardMish.register_parameter()
              • HardMish.register_state_dict_pre_hook()
              • HardMish.requires_grad_()
              • HardMish.set_extra_state()
              • HardMish.share_memory()
              • HardMish.state_dict()
              • HardMish.to()
              • HardMish.to_empty()
              • HardMish.train()
              • HardMish.type()
              • HardMish.xpu()
              • HardMish.zero_grad()
        • towhee.models.layers.activations.hardsigmoid
          • towhee.models.layers.activations.hardsigmoid.hard_sigmoid
            • hard_sigmoid()
          • towhee.models.layers.activations.hardsigmoid.HardSigmoid
            • HardSigmoid
              • HardSigmoid.__call__()
              • HardSigmoid.__init__()
              • HardSigmoid.__repr__()
              • HardSigmoid.add_module()
              • HardSigmoid.apply()
              • HardSigmoid.bfloat16()
              • HardSigmoid.buffers()
              • HardSigmoid.children()
              • HardSigmoid.cpu()
              • HardSigmoid.cuda()
              • HardSigmoid.double()
              • HardSigmoid.eval()
              • HardSigmoid.extra_repr()
              • HardSigmoid.float()
              • HardSigmoid.forward()
              • HardSigmoid.get_buffer()
              • HardSigmoid.get_extra_state()
              • HardSigmoid.get_parameter()
              • HardSigmoid.get_submodule()
              • HardSigmoid.half()
              • HardSigmoid.ipu()
              • HardSigmoid.load_state_dict()
              • HardSigmoid.modules()
              • HardSigmoid.named_buffers()
              • HardSigmoid.named_children()
              • HardSigmoid.named_modules()
              • HardSigmoid.named_parameters()
              • HardSigmoid.parameters()
              • HardSigmoid.register_backward_hook()
              • HardSigmoid.register_buffer()
              • HardSigmoid.register_forward_hook()
              • HardSigmoid.register_forward_pre_hook()
              • HardSigmoid.register_full_backward_hook()
              • HardSigmoid.register_full_backward_pre_hook()
              • HardSigmoid.register_load_state_dict_post_hook()
              • HardSigmoid.register_module()
              • HardSigmoid.register_parameter()
              • HardSigmoid.register_state_dict_pre_hook()
              • HardSigmoid.requires_grad_()
              • HardSigmoid.set_extra_state()
              • HardSigmoid.share_memory()
              • HardSigmoid.state_dict()
              • HardSigmoid.to()
              • HardSigmoid.to_empty()
              • HardSigmoid.train()
              • HardSigmoid.type()
              • HardSigmoid.xpu()
              • HardSigmoid.zero_grad()
        • towhee.models.layers.activations.hardswish
          • towhee.models.layers.activations.hardswish.hard_swish
            • hard_swish()
          • towhee.models.layers.activations.hardswish.HardSwish
            • HardSwish
              • HardSwish.__call__()
              • HardSwish.__init__()
              • HardSwish.__repr__()
              • HardSwish.add_module()
              • HardSwish.apply()
              • HardSwish.bfloat16()
              • HardSwish.buffers()
              • HardSwish.children()
              • HardSwish.cpu()
              • HardSwish.cuda()
              • HardSwish.double()
              • HardSwish.eval()
              • HardSwish.extra_repr()
              • HardSwish.float()
              • HardSwish.forward()
              • HardSwish.get_buffer()
              • HardSwish.get_extra_state()
              • HardSwish.get_parameter()
              • HardSwish.get_submodule()
              • HardSwish.half()
              • HardSwish.ipu()
              • HardSwish.load_state_dict()
              • HardSwish.modules()
              • HardSwish.named_buffers()
              • HardSwish.named_children()
              • HardSwish.named_modules()
              • HardSwish.named_parameters()
              • HardSwish.parameters()
              • HardSwish.register_backward_hook()
              • HardSwish.register_buffer()
              • HardSwish.register_forward_hook()
              • HardSwish.register_forward_pre_hook()
              • HardSwish.register_full_backward_hook()
              • HardSwish.register_full_backward_pre_hook()
              • HardSwish.register_load_state_dict_post_hook()
              • HardSwish.register_module()
              • HardSwish.register_parameter()
              • HardSwish.register_state_dict_pre_hook()
              • HardSwish.requires_grad_()
              • HardSwish.set_extra_state()
              • HardSwish.share_memory()
              • HardSwish.state_dict()
              • HardSwish.to()
              • HardSwish.to_empty()
              • HardSwish.train()
              • HardSwish.type()
              • HardSwish.xpu()
              • HardSwish.zero_grad()
        • towhee.models.layers.activations.mish
        • towhee.models.layers.activations.prelu
          • towhee.models.layers.activations.prelu.PReLU
            • PReLU
              • PReLU.__call__()
              • PReLU.__init__()
              • PReLU.__repr__()
              • PReLU.add_module()
              • PReLU.apply()
              • PReLU.bfloat16()
              • PReLU.buffers()
              • PReLU.children()
              • PReLU.cpu()
              • PReLU.cuda()
              • PReLU.double()
              • PReLU.eval()
              • PReLU.extra_repr()
              • PReLU.float()
              • PReLU.forward()
              • PReLU.get_buffer()
              • PReLU.get_extra_state()
              • PReLU.get_parameter()
              • PReLU.get_submodule()
              • PReLU.half()
              • PReLU.ipu()
              • PReLU.load_state_dict()
              • PReLU.modules()
              • PReLU.named_buffers()
              • PReLU.named_children()
              • PReLU.named_modules()
              • PReLU.named_parameters()
              • PReLU.parameters()
              • PReLU.register_backward_hook()
              • PReLU.register_buffer()
              • PReLU.register_forward_hook()
              • PReLU.register_forward_pre_hook()
              • PReLU.register_full_backward_hook()
              • PReLU.register_full_backward_pre_hook()
              • PReLU.register_load_state_dict_post_hook()
              • PReLU.register_module()
              • PReLU.register_parameter()
              • PReLU.register_state_dict_pre_hook()
              • PReLU.requires_grad_()
              • PReLU.set_extra_state()
              • PReLU.share_memory()
              • PReLU.state_dict()
              • PReLU.to()
              • PReLU.to_empty()
              • PReLU.train()
              • PReLU.type()
              • PReLU.xpu()
              • PReLU.zero_grad()
        • towhee.models.layers.activations.sigmoid
        • towhee.models.layers.activations.swiglu
          • towhee.models.layers.activations.swiglu.SwiGLU
            • SwiGLU
              • SwiGLU.__call__()
              • SwiGLU.__init__()
              • SwiGLU.__repr__()
              • SwiGLU.add_module()
              • SwiGLU.apply()
              • SwiGLU.bfloat16()
              • SwiGLU.buffers()
              • SwiGLU.children()
              • SwiGLU.cpu()
              • SwiGLU.cuda()
              • SwiGLU.double()
              • SwiGLU.eval()
              • SwiGLU.extra_repr()
              • SwiGLU.float()
              • SwiGLU.forward()
              • SwiGLU.get_buffer()
              • SwiGLU.get_extra_state()
              • SwiGLU.get_parameter()
              • SwiGLU.get_submodule()
              • SwiGLU.half()
              • SwiGLU.ipu()
              • SwiGLU.load_state_dict()
              • SwiGLU.modules()
              • SwiGLU.named_buffers()
              • SwiGLU.named_children()
              • SwiGLU.named_modules()
              • SwiGLU.named_parameters()
              • SwiGLU.parameters()
              • SwiGLU.register_backward_hook()
              • SwiGLU.register_buffer()
              • SwiGLU.register_forward_hook()
              • SwiGLU.register_forward_pre_hook()
              • SwiGLU.register_full_backward_hook()
              • SwiGLU.register_full_backward_pre_hook()
              • SwiGLU.register_load_state_dict_post_hook()
              • SwiGLU.register_module()
              • SwiGLU.register_parameter()
              • SwiGLU.register_state_dict_pre_hook()
              • SwiGLU.requires_grad_()
              • SwiGLU.set_extra_state()
              • SwiGLU.share_memory()
              • SwiGLU.state_dict()
              • SwiGLU.to()
              • SwiGLU.to_empty()
              • SwiGLU.train()
              • SwiGLU.type()
              • SwiGLU.xpu()
              • SwiGLU.zero_grad()
        • towhee.models.layers.activations.swish
        • towhee.models.layers.activations.tanh
      • towhee.models.layers.aspp
        • towhee.models.layers.aspp.ASPP
          • ASPP
            • ASPP.__call__()
            • ASPP.__init__()
            • ASPP.__repr__()
            • ASPP.add_module()
            • ASPP.apply()
            • ASPP.bfloat16()
            • ASPP.buffers()
            • ASPP.children()
            • ASPP.cpu()
            • ASPP.cuda()
            • ASPP.double()
            • ASPP.eval()
            • ASPP.extra_repr()
            • ASPP.float()
            • ASPP.forward()
            • ASPP.get_buffer()
            • ASPP.get_extra_state()
            • ASPP.get_parameter()
            • ASPP.get_submodule()
            • ASPP.half()
            • ASPP.ipu()
            • ASPP.load_state_dict()
            • ASPP.modules()
            • ASPP.named_buffers()
            • ASPP.named_children()
            • ASPP.named_modules()
            • ASPP.named_parameters()
            • ASPP.parameters()
            • ASPP.register_backward_hook()
            • ASPP.register_buffer()
            • ASPP.register_forward_hook()
            • ASPP.register_forward_pre_hook()
            • ASPP.register_full_backward_hook()
            • ASPP.register_full_backward_pre_hook()
            • ASPP.register_load_state_dict_post_hook()
            • ASPP.register_module()
            • ASPP.register_parameter()
            • ASPP.register_state_dict_pre_hook()
            • ASPP.requires_grad_()
            • ASPP.set_extra_state()
            • ASPP.share_memory()
            • ASPP.state_dict()
            • ASPP.to()
            • ASPP.to_empty()
            • ASPP.train()
            • ASPP.type()
            • ASPP.xpu()
            • ASPP.zero_grad()
      • towhee.models.layers.attention
        • towhee.models.layers.attention.Attention
          • Attention
            • Attention.__call__()
            • Attention.__init__()
            • Attention.__repr__()
            • Attention.add_module()
            • Attention.apply()
            • Attention.bfloat16()
            • Attention.buffers()
            • Attention.children()
            • Attention.cpu()
            • Attention.cuda()
            • Attention.double()
            • Attention.eval()
            • Attention.extra_repr()
            • Attention.float()
            • Attention.forward()
            • Attention.get_buffer()
            • Attention.get_extra_state()
            • Attention.get_parameter()
            • Attention.get_submodule()
            • Attention.half()
            • Attention.ipu()
            • Attention.load_state_dict()
            • Attention.modules()
            • Attention.named_buffers()
            • Attention.named_children()
            • Attention.named_modules()
            • Attention.named_parameters()
            • Attention.parameters()
            • Attention.register_backward_hook()
            • Attention.register_buffer()
            • Attention.register_forward_hook()
            • Attention.register_forward_pre_hook()
            • Attention.register_full_backward_hook()
            • Attention.register_full_backward_pre_hook()
            • Attention.register_load_state_dict_post_hook()
            • Attention.register_module()
            • Attention.register_parameter()
            • Attention.register_state_dict_pre_hook()
            • Attention.requires_grad_()
            • Attention.set_extra_state()
            • Attention.share_memory()
            • Attention.state_dict()
            • Attention.to()
            • Attention.to_empty()
            • Attention.train()
            • Attention.type()
            • Attention.xpu()
            • Attention.zero_grad()
        • towhee.models.layers.attention.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.layers.cond_conv2d
        • towhee.models.layers.cond_conv2d.get_condconv_initializer
          • get_condconv_initializer()
        • towhee.models.layers.cond_conv2d.CondConv2d
          • CondConv2d
            • CondConv2d.__call__()
            • CondConv2d.__init__()
            • CondConv2d.__repr__()
            • CondConv2d.add_module()
            • CondConv2d.apply()
            • CondConv2d.bfloat16()
            • CondConv2d.buffers()
            • CondConv2d.children()
            • CondConv2d.cpu()
            • CondConv2d.cuda()
            • CondConv2d.double()
            • CondConv2d.eval()
            • CondConv2d.extra_repr()
            • CondConv2d.float()
            • CondConv2d.forward()
            • CondConv2d.get_buffer()
            • CondConv2d.get_extra_state()
            • CondConv2d.get_parameter()
            • CondConv2d.get_submodule()
            • CondConv2d.half()
            • CondConv2d.ipu()
            • CondConv2d.load_state_dict()
            • CondConv2d.modules()
            • CondConv2d.named_buffers()
            • CondConv2d.named_children()
            • CondConv2d.named_modules()
            • CondConv2d.named_parameters()
            • CondConv2d.parameters()
            • CondConv2d.register_backward_hook()
            • CondConv2d.register_buffer()
            • CondConv2d.register_forward_hook()
            • CondConv2d.register_forward_pre_hook()
            • CondConv2d.register_full_backward_hook()
            • CondConv2d.register_full_backward_pre_hook()
            • CondConv2d.register_load_state_dict_post_hook()
            • CondConv2d.register_module()
            • CondConv2d.register_parameter()
            • CondConv2d.register_state_dict_pre_hook()
            • CondConv2d.requires_grad_()
            • CondConv2d.set_extra_state()
            • CondConv2d.share_memory()
            • CondConv2d.state_dict()
            • CondConv2d.to()
            • CondConv2d.to_empty()
            • CondConv2d.train()
            • CondConv2d.type()
            • CondConv2d.xpu()
            • CondConv2d.zero_grad()
      • towhee.models.layers.conv2d_same
        • towhee.models.layers.conv2d_same.conv2d_same
          • conv2d_same()
        • towhee.models.layers.conv2d_same.Conv2dSame
          • Conv2dSame
            • Conv2dSame.__call__()
            • Conv2dSame.__init__()
            • Conv2dSame.__repr__()
            • Conv2dSame.add_module()
            • Conv2dSame.apply()
            • Conv2dSame.bfloat16()
            • Conv2dSame.buffers()
            • Conv2dSame.children()
            • Conv2dSame.cpu()
            • Conv2dSame.cuda()
            • Conv2dSame.double()
            • Conv2dSame.eval()
            • Conv2dSame.extra_repr()
            • Conv2dSame.float()
            • Conv2dSame.forward()
            • Conv2dSame.get_buffer()
            • Conv2dSame.get_extra_state()
            • Conv2dSame.get_parameter()
            • Conv2dSame.get_submodule()
            • Conv2dSame.half()
            • Conv2dSame.ipu()
            • Conv2dSame.load_state_dict()
            • Conv2dSame.modules()
            • Conv2dSame.named_buffers()
            • Conv2dSame.named_children()
            • Conv2dSame.named_modules()
            • Conv2dSame.named_parameters()
            • Conv2dSame.parameters()
            • Conv2dSame.register_backward_hook()
            • Conv2dSame.register_buffer()
            • Conv2dSame.register_forward_hook()
            • Conv2dSame.register_forward_pre_hook()
            • Conv2dSame.register_full_backward_hook()
            • Conv2dSame.register_full_backward_pre_hook()
            • Conv2dSame.register_load_state_dict_post_hook()
            • Conv2dSame.register_module()
            • Conv2dSame.register_parameter()
            • Conv2dSame.register_state_dict_pre_hook()
            • Conv2dSame.requires_grad_()
            • Conv2dSame.set_extra_state()
            • Conv2dSame.share_memory()
            • Conv2dSame.state_dict()
            • Conv2dSame.to()
            • Conv2dSame.to_empty()
            • Conv2dSame.train()
            • Conv2dSame.type()
            • Conv2dSame.xpu()
            • Conv2dSame.zero_grad()
      • towhee.models.layers.conv2d_separable
        • towhee.models.layers.conv2d_separable.SeparableConv2d
          • SeparableConv2d
            • SeparableConv2d.__call__()
            • SeparableConv2d.__init__()
            • SeparableConv2d.__repr__()
            • SeparableConv2d.add_module()
            • SeparableConv2d.apply()
            • SeparableConv2d.bfloat16()
            • SeparableConv2d.buffers()
            • SeparableConv2d.children()
            • SeparableConv2d.cpu()
            • SeparableConv2d.cuda()
            • SeparableConv2d.double()
            • SeparableConv2d.eval()
            • SeparableConv2d.extra_repr()
            • SeparableConv2d.float()
            • SeparableConv2d.forward()
            • SeparableConv2d.get_buffer()
            • SeparableConv2d.get_extra_state()
            • SeparableConv2d.get_parameter()
            • SeparableConv2d.get_submodule()
            • SeparableConv2d.half()
            • SeparableConv2d.ipu()
            • SeparableConv2d.load_state_dict()
            • SeparableConv2d.modules()
            • SeparableConv2d.named_buffers()
            • SeparableConv2d.named_children()
            • SeparableConv2d.named_modules()
            • SeparableConv2d.named_parameters()
            • SeparableConv2d.parameters()
            • SeparableConv2d.register_backward_hook()
            • SeparableConv2d.register_buffer()
            • SeparableConv2d.register_forward_hook()
            • SeparableConv2d.register_forward_pre_hook()
            • SeparableConv2d.register_full_backward_hook()
            • SeparableConv2d.register_full_backward_pre_hook()
            • SeparableConv2d.register_load_state_dict_post_hook()
            • SeparableConv2d.register_module()
            • SeparableConv2d.register_parameter()
            • SeparableConv2d.register_state_dict_pre_hook()
            • SeparableConv2d.requires_grad_()
            • SeparableConv2d.set_extra_state()
            • SeparableConv2d.share_memory()
            • SeparableConv2d.state_dict()
            • SeparableConv2d.to()
            • SeparableConv2d.to_empty()
            • SeparableConv2d.train()
            • SeparableConv2d.type()
            • SeparableConv2d.xpu()
            • SeparableConv2d.zero_grad()
      • towhee.models.layers.conv4d
        • towhee.models.layers.conv4d.CenterPivotConv4d
          • CenterPivotConv4d
            • CenterPivotConv4d.__call__()
            • CenterPivotConv4d.__init__()
            • CenterPivotConv4d.__repr__()
            • CenterPivotConv4d.add_module()
            • CenterPivotConv4d.apply()
            • CenterPivotConv4d.bfloat16()
            • CenterPivotConv4d.buffers()
            • CenterPivotConv4d.children()
            • CenterPivotConv4d.cpu()
            • CenterPivotConv4d.cuda()
            • CenterPivotConv4d.double()
            • CenterPivotConv4d.eval()
            • CenterPivotConv4d.extra_repr()
            • CenterPivotConv4d.float()
            • CenterPivotConv4d.forward()
            • CenterPivotConv4d.get_buffer()
            • CenterPivotConv4d.get_extra_state()
            • CenterPivotConv4d.get_parameter()
            • CenterPivotConv4d.get_submodule()
            • CenterPivotConv4d.half()
            • CenterPivotConv4d.ipu()
            • CenterPivotConv4d.load_state_dict()
            • CenterPivotConv4d.modules()
            • CenterPivotConv4d.named_buffers()
            • CenterPivotConv4d.named_children()
            • CenterPivotConv4d.named_modules()
            • CenterPivotConv4d.named_parameters()
            • CenterPivotConv4d.parameters()
            • CenterPivotConv4d.register_backward_hook()
            • CenterPivotConv4d.register_buffer()
            • CenterPivotConv4d.register_forward_hook()
            • CenterPivotConv4d.register_forward_pre_hook()
            • CenterPivotConv4d.register_full_backward_hook()
            • CenterPivotConv4d.register_full_backward_pre_hook()
            • CenterPivotConv4d.register_load_state_dict_post_hook()
            • CenterPivotConv4d.register_module()
            • CenterPivotConv4d.register_parameter()
            • CenterPivotConv4d.register_state_dict_pre_hook()
            • CenterPivotConv4d.requires_grad_()
            • CenterPivotConv4d.set_extra_state()
            • CenterPivotConv4d.share_memory()
            • CenterPivotConv4d.state_dict()
            • CenterPivotConv4d.to()
            • CenterPivotConv4d.to_empty()
            • CenterPivotConv4d.train()
            • CenterPivotConv4d.type()
            • CenterPivotConv4d.xpu()
            • CenterPivotConv4d.zero_grad()
      • towhee.models.layers.conv_bn_activation
        • towhee.models.layers.conv_bn_activation.Conv2dBNActivation
          • Conv2dBNActivation
            • Conv2dBNActivation.__call__()
            • Conv2dBNActivation.__init__()
            • Conv2dBNActivation.__repr__()
            • Conv2dBNActivation.add_module()
            • Conv2dBNActivation.append()
            • Conv2dBNActivation.apply()
            • Conv2dBNActivation.bfloat16()
            • Conv2dBNActivation.buffers()
            • Conv2dBNActivation.children()
            • Conv2dBNActivation.cpu()
            • Conv2dBNActivation.cuda()
            • Conv2dBNActivation.double()
            • Conv2dBNActivation.eval()
            • Conv2dBNActivation.extra_repr()
            • Conv2dBNActivation.float()
            • Conv2dBNActivation.forward()
            • Conv2dBNActivation.get_buffer()
            • Conv2dBNActivation.get_extra_state()
            • Conv2dBNActivation.get_parameter()
            • Conv2dBNActivation.get_submodule()
            • Conv2dBNActivation.half()
            • Conv2dBNActivation.ipu()
            • Conv2dBNActivation.load_state_dict()
            • Conv2dBNActivation.modules()
            • Conv2dBNActivation.named_buffers()
            • Conv2dBNActivation.named_children()
            • Conv2dBNActivation.named_modules()
            • Conv2dBNActivation.named_parameters()
            • Conv2dBNActivation.parameters()
            • Conv2dBNActivation.register_backward_hook()
            • Conv2dBNActivation.register_buffer()
            • Conv2dBNActivation.register_forward_hook()
            • Conv2dBNActivation.register_forward_pre_hook()
            • Conv2dBNActivation.register_full_backward_hook()
            • Conv2dBNActivation.register_full_backward_pre_hook()
            • Conv2dBNActivation.register_load_state_dict_post_hook()
            • Conv2dBNActivation.register_module()
            • Conv2dBNActivation.register_parameter()
            • Conv2dBNActivation.register_state_dict_pre_hook()
            • Conv2dBNActivation.requires_grad_()
            • Conv2dBNActivation.set_extra_state()
            • Conv2dBNActivation.share_memory()
            • Conv2dBNActivation.state_dict()
            • Conv2dBNActivation.to()
            • Conv2dBNActivation.to_empty()
            • Conv2dBNActivation.train()
            • Conv2dBNActivation.type()
            • Conv2dBNActivation.xpu()
            • Conv2dBNActivation.zero_grad()
        • towhee.models.layers.conv_bn_activation.Conv3DBNActivation
          • Conv3DBNActivation
            • Conv3DBNActivation.__call__()
            • Conv3DBNActivation.__init__()
            • Conv3DBNActivation.__repr__()
            • Conv3DBNActivation.add_module()
            • Conv3DBNActivation.append()
            • Conv3DBNActivation.apply()
            • Conv3DBNActivation.bfloat16()
            • Conv3DBNActivation.buffers()
            • Conv3DBNActivation.children()
            • Conv3DBNActivation.cpu()
            • Conv3DBNActivation.cuda()
            • Conv3DBNActivation.double()
            • Conv3DBNActivation.eval()
            • Conv3DBNActivation.extra_repr()
            • Conv3DBNActivation.float()
            • Conv3DBNActivation.forward()
            • Conv3DBNActivation.get_buffer()
            • Conv3DBNActivation.get_extra_state()
            • Conv3DBNActivation.get_parameter()
            • Conv3DBNActivation.get_submodule()
            • Conv3DBNActivation.half()
            • Conv3DBNActivation.ipu()
            • Conv3DBNActivation.load_state_dict()
            • Conv3DBNActivation.modules()
            • Conv3DBNActivation.named_buffers()
            • Conv3DBNActivation.named_children()
            • Conv3DBNActivation.named_modules()
            • Conv3DBNActivation.named_parameters()
            • Conv3DBNActivation.parameters()
            • Conv3DBNActivation.register_backward_hook()
            • Conv3DBNActivation.register_buffer()
            • Conv3DBNActivation.register_forward_hook()
            • Conv3DBNActivation.register_forward_pre_hook()
            • Conv3DBNActivation.register_full_backward_hook()
            • Conv3DBNActivation.register_full_backward_pre_hook()
            • Conv3DBNActivation.register_load_state_dict_post_hook()
            • Conv3DBNActivation.register_module()
            • Conv3DBNActivation.register_parameter()
            • Conv3DBNActivation.register_state_dict_pre_hook()
            • Conv3DBNActivation.requires_grad_()
            • Conv3DBNActivation.set_extra_state()
            • Conv3DBNActivation.share_memory()
            • Conv3DBNActivation.state_dict()
            • Conv3DBNActivation.to()
            • Conv3DBNActivation.to_empty()
            • Conv3DBNActivation.train()
            • Conv3DBNActivation.type()
            • Conv3DBNActivation.xpu()
            • Conv3DBNActivation.zero_grad()
      • towhee.models.layers.convmlp
        • towhee.models.layers.convmlp.ConvMlp
          • ConvMlp
            • ConvMlp.__call__()
            • ConvMlp.__init__()
            • ConvMlp.__repr__()
            • ConvMlp.add_module()
            • ConvMlp.apply()
            • ConvMlp.bfloat16()
            • ConvMlp.buffers()
            • ConvMlp.children()
            • ConvMlp.cpu()
            • ConvMlp.cuda()
            • ConvMlp.double()
            • ConvMlp.eval()
            • ConvMlp.extra_repr()
            • ConvMlp.float()
            • ConvMlp.forward()
            • ConvMlp.get_buffer()
            • ConvMlp.get_extra_state()
            • ConvMlp.get_parameter()
            • ConvMlp.get_submodule()
            • ConvMlp.half()
            • ConvMlp.ipu()
            • ConvMlp.load_state_dict()
            • ConvMlp.modules()
            • ConvMlp.named_buffers()
            • ConvMlp.named_children()
            • ConvMlp.named_modules()
            • ConvMlp.named_parameters()
            • ConvMlp.parameters()
            • ConvMlp.register_backward_hook()
            • ConvMlp.register_buffer()
            • ConvMlp.register_forward_hook()
            • ConvMlp.register_forward_pre_hook()
            • ConvMlp.register_full_backward_hook()
            • ConvMlp.register_full_backward_pre_hook()
            • ConvMlp.register_load_state_dict_post_hook()
            • ConvMlp.register_module()
            • ConvMlp.register_parameter()
            • ConvMlp.register_state_dict_pre_hook()
            • ConvMlp.requires_grad_()
            • ConvMlp.set_extra_state()
            • ConvMlp.share_memory()
            • ConvMlp.state_dict()
            • ConvMlp.to()
            • ConvMlp.to_empty()
            • ConvMlp.train()
            • ConvMlp.type()
            • ConvMlp.xpu()
            • ConvMlp.zero_grad()
      • towhee.models.layers.cross_attention
        • towhee.models.layers.cross_attention.apply_rotary_pos_emb
          • apply_rotary_pos_emb()
        • towhee.models.layers.cross_attention.rotate_half
          • rotate_half()
        • towhee.models.layers.cross_attention.CrossAttention
          • CrossAttention
            • CrossAttention.__call__()
            • CrossAttention.__init__()
            • CrossAttention.__repr__()
            • CrossAttention.add_module()
            • CrossAttention.apply()
            • CrossAttention.bfloat16()
            • CrossAttention.buffers()
            • CrossAttention.children()
            • CrossAttention.cpu()
            • CrossAttention.cuda()
            • CrossAttention.double()
            • CrossAttention.eval()
            • CrossAttention.extra_repr()
            • CrossAttention.float()
            • CrossAttention.forward()
            • CrossAttention.get_buffer()
            • CrossAttention.get_extra_state()
            • CrossAttention.get_parameter()
            • CrossAttention.get_submodule()
            • CrossAttention.half()
            • CrossAttention.ipu()
            • CrossAttention.load_state_dict()
            • CrossAttention.modules()
            • CrossAttention.named_buffers()
            • CrossAttention.named_children()
            • CrossAttention.named_modules()
            • CrossAttention.named_parameters()
            • CrossAttention.parameters()
            • CrossAttention.register_backward_hook()
            • CrossAttention.register_buffer()
            • CrossAttention.register_forward_hook()
            • CrossAttention.register_forward_pre_hook()
            • CrossAttention.register_full_backward_hook()
            • CrossAttention.register_full_backward_pre_hook()
            • CrossAttention.register_load_state_dict_post_hook()
            • CrossAttention.register_module()
            • CrossAttention.register_parameter()
            • CrossAttention.register_state_dict_pre_hook()
            • CrossAttention.requires_grad_()
            • CrossAttention.set_extra_state()
            • CrossAttention.share_memory()
            • CrossAttention.state_dict()
            • CrossAttention.to()
            • CrossAttention.to_empty()
            • CrossAttention.train()
            • CrossAttention.type()
            • CrossAttention.xpu()
            • CrossAttention.zero_grad()
        • towhee.models.layers.cross_attention.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.layers.cross_attention.Residual
          • Residual
            • Residual.__call__()
            • Residual.__init__()
            • Residual.__repr__()
            • Residual.add_module()
            • Residual.apply()
            • Residual.bfloat16()
            • Residual.buffers()
            • Residual.children()
            • Residual.cpu()
            • Residual.cuda()
            • Residual.double()
            • Residual.eval()
            • Residual.extra_repr()
            • Residual.float()
            • Residual.forward()
            • Residual.get_buffer()
            • Residual.get_extra_state()
            • Residual.get_parameter()
            • Residual.get_submodule()
            • Residual.half()
            • Residual.ipu()
            • Residual.load_state_dict()
            • Residual.modules()
            • Residual.named_buffers()
            • Residual.named_children()
            • Residual.named_modules()
            • Residual.named_parameters()
            • Residual.parameters()
            • Residual.register_backward_hook()
            • Residual.register_buffer()
            • Residual.register_forward_hook()
            • Residual.register_forward_pre_hook()
            • Residual.register_full_backward_hook()
            • Residual.register_full_backward_pre_hook()
            • Residual.register_load_state_dict_post_hook()
            • Residual.register_module()
            • Residual.register_parameter()
            • Residual.register_state_dict_pre_hook()
            • Residual.requires_grad_()
            • Residual.set_extra_state()
            • Residual.share_memory()
            • Residual.state_dict()
            • Residual.to()
            • Residual.to_empty()
            • Residual.train()
            • Residual.type()
            • Residual.xpu()
            • Residual.zero_grad()
        • towhee.models.layers.cross_attention.RotaryEmbedding
          • RotaryEmbedding
            • RotaryEmbedding.__call__()
            • RotaryEmbedding.__init__()
            • RotaryEmbedding.__repr__()
            • RotaryEmbedding.add_module()
            • RotaryEmbedding.apply()
            • RotaryEmbedding.bfloat16()
            • RotaryEmbedding.buffers()
            • RotaryEmbedding.children()
            • RotaryEmbedding.cpu()
            • RotaryEmbedding.cuda()
            • RotaryEmbedding.double()
            • RotaryEmbedding.eval()
            • RotaryEmbedding.extra_repr()
            • RotaryEmbedding.float()
            • RotaryEmbedding.forward()
            • RotaryEmbedding.get_buffer()
            • RotaryEmbedding.get_extra_state()
            • RotaryEmbedding.get_parameter()
            • RotaryEmbedding.get_submodule()
            • RotaryEmbedding.half()
            • RotaryEmbedding.ipu()
            • RotaryEmbedding.load_state_dict()
            • RotaryEmbedding.modules()
            • RotaryEmbedding.named_buffers()
            • RotaryEmbedding.named_children()
            • RotaryEmbedding.named_modules()
            • RotaryEmbedding.named_parameters()
            • RotaryEmbedding.parameters()
            • RotaryEmbedding.register_backward_hook()
            • RotaryEmbedding.register_buffer()
            • RotaryEmbedding.register_forward_hook()
            • RotaryEmbedding.register_forward_pre_hook()
            • RotaryEmbedding.register_full_backward_hook()
            • RotaryEmbedding.register_full_backward_pre_hook()
            • RotaryEmbedding.register_load_state_dict_post_hook()
            • RotaryEmbedding.register_module()
            • RotaryEmbedding.register_parameter()
            • RotaryEmbedding.register_state_dict_pre_hook()
            • RotaryEmbedding.requires_grad_()
            • RotaryEmbedding.set_extra_state()
            • RotaryEmbedding.share_memory()
            • RotaryEmbedding.state_dict()
            • RotaryEmbedding.to()
            • RotaryEmbedding.to_empty()
            • RotaryEmbedding.train()
            • RotaryEmbedding.type()
            • RotaryEmbedding.xpu()
            • RotaryEmbedding.zero_grad()
      • towhee.models.layers.dropblock2d
        • towhee.models.layers.dropblock2d.drop_block_2d
          • drop_block_2d()
        • towhee.models.layers.dropblock2d.drop_block_fast_2d
          • drop_block_fast_2d()
        • towhee.models.layers.dropblock2d.DropBlock2d
          • DropBlock2d
            • DropBlock2d.__call__()
            • DropBlock2d.__init__()
            • DropBlock2d.__repr__()
            • DropBlock2d.add_module()
            • DropBlock2d.apply()
            • DropBlock2d.bfloat16()
            • DropBlock2d.buffers()
            • DropBlock2d.children()
            • DropBlock2d.cpu()
            • DropBlock2d.cuda()
            • DropBlock2d.double()
            • DropBlock2d.eval()
            • DropBlock2d.extra_repr()
            • DropBlock2d.float()
            • DropBlock2d.forward()
            • DropBlock2d.get_buffer()
            • DropBlock2d.get_extra_state()
            • DropBlock2d.get_parameter()
            • DropBlock2d.get_submodule()
            • DropBlock2d.half()
            • DropBlock2d.ipu()
            • DropBlock2d.load_state_dict()
            • DropBlock2d.modules()
            • DropBlock2d.named_buffers()
            • DropBlock2d.named_children()
            • DropBlock2d.named_modules()
            • DropBlock2d.named_parameters()
            • DropBlock2d.parameters()
            • DropBlock2d.register_backward_hook()
            • DropBlock2d.register_buffer()
            • DropBlock2d.register_forward_hook()
            • DropBlock2d.register_forward_pre_hook()
            • DropBlock2d.register_full_backward_hook()
            • DropBlock2d.register_full_backward_pre_hook()
            • DropBlock2d.register_load_state_dict_post_hook()
            • DropBlock2d.register_module()
            • DropBlock2d.register_parameter()
            • DropBlock2d.register_state_dict_pre_hook()
            • DropBlock2d.requires_grad_()
            • DropBlock2d.set_extra_state()
            • DropBlock2d.share_memory()
            • DropBlock2d.state_dict()
            • DropBlock2d.to()
            • DropBlock2d.to_empty()
            • DropBlock2d.train()
            • DropBlock2d.type()
            • DropBlock2d.xpu()
            • DropBlock2d.zero_grad()
      • towhee.models.layers.droppath
        • towhee.models.layers.droppath.drop_path
          • drop_path()
        • towhee.models.layers.droppath.DropPath
          • DropPath
            • DropPath.__call__()
            • DropPath.__init__()
            • DropPath.__repr__()
            • DropPath.add_module()
            • DropPath.apply()
            • DropPath.bfloat16()
            • DropPath.buffers()
            • DropPath.children()
            • DropPath.cpu()
            • DropPath.cuda()
            • DropPath.double()
            • DropPath.eval()
            • DropPath.extra_repr()
            • DropPath.float()
            • DropPath.forward()
            • DropPath.get_buffer()
            • DropPath.get_extra_state()
            • DropPath.get_parameter()
            • DropPath.get_submodule()
            • DropPath.half()
            • DropPath.ipu()
            • DropPath.load_state_dict()
            • DropPath.modules()
            • DropPath.named_buffers()
            • DropPath.named_children()
            • DropPath.named_modules()
            • DropPath.named_parameters()
            • DropPath.parameters()
            • DropPath.register_backward_hook()
            • DropPath.register_buffer()
            • DropPath.register_forward_hook()
            • DropPath.register_forward_pre_hook()
            • DropPath.register_full_backward_hook()
            • DropPath.register_full_backward_pre_hook()
            • DropPath.register_load_state_dict_post_hook()
            • DropPath.register_module()
            • DropPath.register_parameter()
            • DropPath.register_state_dict_pre_hook()
            • DropPath.requires_grad_()
            • DropPath.set_extra_state()
            • DropPath.share_memory()
            • DropPath.state_dict()
            • DropPath.to()
            • DropPath.to_empty()
            • DropPath.train()
            • DropPath.type()
            • DropPath.xpu()
            • DropPath.zero_grad()
      • towhee.models.layers.ffn
        • towhee.models.layers.ffn.FFNBlock
          • FFNBlock
            • FFNBlock.__call__()
            • FFNBlock.__init__()
            • FFNBlock.__repr__()
            • FFNBlock.add_module()
            • FFNBlock.apply()
            • FFNBlock.bfloat16()
            • FFNBlock.buffers()
            • FFNBlock.children()
            • FFNBlock.cpu()
            • FFNBlock.cuda()
            • FFNBlock.double()
            • FFNBlock.eval()
            • FFNBlock.extra_repr()
            • FFNBlock.float()
            • FFNBlock.forward()
            • FFNBlock.get_buffer()
            • FFNBlock.get_extra_state()
            • FFNBlock.get_parameter()
            • FFNBlock.get_submodule()
            • FFNBlock.half()
            • FFNBlock.ipu()
            • FFNBlock.load_state_dict()
            • FFNBlock.modules()
            • FFNBlock.named_buffers()
            • FFNBlock.named_children()
            • FFNBlock.named_modules()
            • FFNBlock.named_parameters()
            • FFNBlock.parameters()
            • FFNBlock.register_backward_hook()
            • FFNBlock.register_buffer()
            • FFNBlock.register_forward_hook()
            • FFNBlock.register_forward_pre_hook()
            • FFNBlock.register_full_backward_hook()
            • FFNBlock.register_full_backward_pre_hook()
            • FFNBlock.register_load_state_dict_post_hook()
            • FFNBlock.register_module()
            • FFNBlock.register_parameter()
            • FFNBlock.register_state_dict_pre_hook()
            • FFNBlock.requires_grad_()
            • FFNBlock.set_extra_state()
            • FFNBlock.share_memory()
            • FFNBlock.state_dict()
            • FFNBlock.to()
            • FFNBlock.to_empty()
            • FFNBlock.train()
            • FFNBlock.type()
            • FFNBlock.xpu()
            • FFNBlock.zero_grad()
      • towhee.models.layers.gatedmlp
        • towhee.models.layers.gatedmlp.GatedMlp
          • GatedMlp
            • GatedMlp.__call__()
            • GatedMlp.__init__()
            • GatedMlp.__repr__()
            • GatedMlp.add_module()
            • GatedMlp.apply()
            • GatedMlp.bfloat16()
            • GatedMlp.buffers()
            • GatedMlp.children()
            • GatedMlp.cpu()
            • GatedMlp.cuda()
            • GatedMlp.double()
            • GatedMlp.eval()
            • GatedMlp.extra_repr()
            • GatedMlp.float()
            • GatedMlp.forward()
            • GatedMlp.get_buffer()
            • GatedMlp.get_extra_state()
            • GatedMlp.get_parameter()
            • GatedMlp.get_submodule()
            • GatedMlp.half()
            • GatedMlp.ipu()
            • GatedMlp.load_state_dict()
            • GatedMlp.modules()
            • GatedMlp.named_buffers()
            • GatedMlp.named_children()
            • GatedMlp.named_modules()
            • GatedMlp.named_parameters()
            • GatedMlp.parameters()
            • GatedMlp.register_backward_hook()
            • GatedMlp.register_buffer()
            • GatedMlp.register_forward_hook()
            • GatedMlp.register_forward_pre_hook()
            • GatedMlp.register_full_backward_hook()
            • GatedMlp.register_full_backward_pre_hook()
            • GatedMlp.register_load_state_dict_post_hook()
            • GatedMlp.register_module()
            • GatedMlp.register_parameter()
            • GatedMlp.register_state_dict_pre_hook()
            • GatedMlp.requires_grad_()
            • GatedMlp.set_extra_state()
            • GatedMlp.share_memory()
            • GatedMlp.state_dict()
            • GatedMlp.to()
            • GatedMlp.to_empty()
            • GatedMlp.train()
            • GatedMlp.type()
            • GatedMlp.xpu()
            • GatedMlp.zero_grad()
      • towhee.models.layers.layers_with_relprop
        • towhee.models.layers.layers_with_relprop.backward_hook
          • backward_hook()
        • towhee.models.layers.layers_with_relprop.forward_hook
          • forward_hook()
        • towhee.models.layers.layers_with_relprop.safe_divide
          • safe_divide()
        • towhee.models.layers.layers_with_relprop.AdaptiveAvgPool2d
          • AdaptiveAvgPool2d
            • AdaptiveAvgPool2d.__call__()
            • AdaptiveAvgPool2d.__init__()
            • AdaptiveAvgPool2d.__repr__()
            • AdaptiveAvgPool2d.add_module()
            • AdaptiveAvgPool2d.apply()
            • AdaptiveAvgPool2d.bfloat16()
            • AdaptiveAvgPool2d.buffers()
            • AdaptiveAvgPool2d.children()
            • AdaptiveAvgPool2d.cpu()
            • AdaptiveAvgPool2d.cuda()
            • AdaptiveAvgPool2d.double()
            • AdaptiveAvgPool2d.eval()
            • AdaptiveAvgPool2d.extra_repr()
            • AdaptiveAvgPool2d.float()
            • AdaptiveAvgPool2d.forward()
            • AdaptiveAvgPool2d.get_buffer()
            • AdaptiveAvgPool2d.get_extra_state()
            • AdaptiveAvgPool2d.get_parameter()
            • AdaptiveAvgPool2d.get_submodule()
            • AdaptiveAvgPool2d.half()
            • AdaptiveAvgPool2d.ipu()
            • AdaptiveAvgPool2d.load_state_dict()
            • AdaptiveAvgPool2d.modules()
            • AdaptiveAvgPool2d.named_buffers()
            • AdaptiveAvgPool2d.named_children()
            • AdaptiveAvgPool2d.named_modules()
            • AdaptiveAvgPool2d.named_parameters()
            • AdaptiveAvgPool2d.parameters()
            • AdaptiveAvgPool2d.register_backward_hook()
            • AdaptiveAvgPool2d.register_buffer()
            • AdaptiveAvgPool2d.register_forward_hook()
            • AdaptiveAvgPool2d.register_forward_pre_hook()
            • AdaptiveAvgPool2d.register_full_backward_hook()
            • AdaptiveAvgPool2d.register_full_backward_pre_hook()
            • AdaptiveAvgPool2d.register_load_state_dict_post_hook()
            • AdaptiveAvgPool2d.register_module()
            • AdaptiveAvgPool2d.register_parameter()
            • AdaptiveAvgPool2d.register_state_dict_pre_hook()
            • AdaptiveAvgPool2d.requires_grad_()
            • AdaptiveAvgPool2d.set_extra_state()
            • AdaptiveAvgPool2d.share_memory()
            • AdaptiveAvgPool2d.state_dict()
            • AdaptiveAvgPool2d.to()
            • AdaptiveAvgPool2d.to_empty()
            • AdaptiveAvgPool2d.train()
            • AdaptiveAvgPool2d.type()
            • AdaptiveAvgPool2d.xpu()
            • AdaptiveAvgPool2d.zero_grad()
        • towhee.models.layers.layers_with_relprop.Add
          • Add
            • Add.__call__()
            • Add.__init__()
            • Add.__repr__()
            • Add.add_module()
            • Add.apply()
            • Add.bfloat16()
            • Add.buffers()
            • Add.children()
            • Add.cpu()
            • Add.cuda()
            • Add.double()
            • Add.eval()
            • Add.extra_repr()
            • Add.float()
            • Add.forward()
            • Add.get_buffer()
            • Add.get_extra_state()
            • Add.get_parameter()
            • Add.get_submodule()
            • Add.half()
            • Add.ipu()
            • Add.load_state_dict()
            • Add.modules()
            • Add.named_buffers()
            • Add.named_children()
            • Add.named_modules()
            • Add.named_parameters()
            • Add.parameters()
            • Add.register_backward_hook()
            • Add.register_buffer()
            • Add.register_forward_hook()
            • Add.register_forward_pre_hook()
            • Add.register_full_backward_hook()
            • Add.register_full_backward_pre_hook()
            • Add.register_load_state_dict_post_hook()
            • Add.register_module()
            • Add.register_parameter()
            • Add.register_state_dict_pre_hook()
            • Add.requires_grad_()
            • Add.set_extra_state()
            • Add.share_memory()
            • Add.state_dict()
            • Add.to()
            • Add.to_empty()
            • Add.train()
            • Add.type()
            • Add.xpu()
            • Add.zero_grad()
        • towhee.models.layers.layers_with_relprop.AddEye
          • AddEye
            • AddEye.__call__()
            • AddEye.__init__()
            • AddEye.__repr__()
            • AddEye.add_module()
            • AddEye.apply()
            • AddEye.bfloat16()
            • AddEye.buffers()
            • AddEye.children()
            • AddEye.cpu()
            • AddEye.cuda()
            • AddEye.double()
            • AddEye.eval()
            • AddEye.extra_repr()
            • AddEye.float()
            • AddEye.forward()
            • AddEye.get_buffer()
            • AddEye.get_extra_state()
            • AddEye.get_parameter()
            • AddEye.get_submodule()
            • AddEye.half()
            • AddEye.ipu()
            • AddEye.load_state_dict()
            • AddEye.modules()
            • AddEye.named_buffers()
            • AddEye.named_children()
            • AddEye.named_modules()
            • AddEye.named_parameters()
            • AddEye.parameters()
            • AddEye.register_backward_hook()
            • AddEye.register_buffer()
            • AddEye.register_forward_hook()
            • AddEye.register_forward_pre_hook()
            • AddEye.register_full_backward_hook()
            • AddEye.register_full_backward_pre_hook()
            • AddEye.register_load_state_dict_post_hook()
            • AddEye.register_module()
            • AddEye.register_parameter()
            • AddEye.register_state_dict_pre_hook()
            • AddEye.requires_grad_()
            • AddEye.set_extra_state()
            • AddEye.share_memory()
            • AddEye.state_dict()
            • AddEye.to()
            • AddEye.to_empty()
            • AddEye.train()
            • AddEye.type()
            • AddEye.xpu()
            • AddEye.zero_grad()
        • towhee.models.layers.layers_with_relprop.AvgPool2d
          • AvgPool2d
            • AvgPool2d.__call__()
            • AvgPool2d.__init__()
            • AvgPool2d.__repr__()
            • AvgPool2d.add_module()
            • AvgPool2d.apply()
            • AvgPool2d.bfloat16()
            • AvgPool2d.buffers()
            • AvgPool2d.children()
            • AvgPool2d.cpu()
            • AvgPool2d.cuda()
            • AvgPool2d.double()
            • AvgPool2d.eval()
            • AvgPool2d.extra_repr()
            • AvgPool2d.float()
            • AvgPool2d.forward()
            • AvgPool2d.get_buffer()
            • AvgPool2d.get_extra_state()
            • AvgPool2d.get_parameter()
            • AvgPool2d.get_submodule()
            • AvgPool2d.half()
            • AvgPool2d.ipu()
            • AvgPool2d.load_state_dict()
            • AvgPool2d.modules()
            • AvgPool2d.named_buffers()
            • AvgPool2d.named_children()
            • AvgPool2d.named_modules()
            • AvgPool2d.named_parameters()
            • AvgPool2d.parameters()
            • AvgPool2d.register_backward_hook()
            • AvgPool2d.register_buffer()
            • AvgPool2d.register_forward_hook()
            • AvgPool2d.register_forward_pre_hook()
            • AvgPool2d.register_full_backward_hook()
            • AvgPool2d.register_full_backward_pre_hook()
            • AvgPool2d.register_load_state_dict_post_hook()
            • AvgPool2d.register_module()
            • AvgPool2d.register_parameter()
            • AvgPool2d.register_state_dict_pre_hook()
            • AvgPool2d.requires_grad_()
            • AvgPool2d.set_extra_state()
            • AvgPool2d.share_memory()
            • AvgPool2d.state_dict()
            • AvgPool2d.to()
            • AvgPool2d.to_empty()
            • AvgPool2d.train()
            • AvgPool2d.type()
            • AvgPool2d.xpu()
            • AvgPool2d.zero_grad()
        • towhee.models.layers.layers_with_relprop.BatchNorm2d
          • BatchNorm2d
            • BatchNorm2d.__call__()
            • BatchNorm2d.__init__()
            • BatchNorm2d.__repr__()
            • BatchNorm2d.add_module()
            • BatchNorm2d.apply()
            • BatchNorm2d.bfloat16()
            • BatchNorm2d.buffers()
            • BatchNorm2d.children()
            • BatchNorm2d.cpu()
            • BatchNorm2d.cuda()
            • BatchNorm2d.double()
            • BatchNorm2d.eval()
            • BatchNorm2d.extra_repr()
            • BatchNorm2d.float()
            • BatchNorm2d.forward()
            • BatchNorm2d.get_buffer()
            • BatchNorm2d.get_extra_state()
            • BatchNorm2d.get_parameter()
            • BatchNorm2d.get_submodule()
            • BatchNorm2d.half()
            • BatchNorm2d.ipu()
            • BatchNorm2d.load_state_dict()
            • BatchNorm2d.modules()
            • BatchNorm2d.named_buffers()
            • BatchNorm2d.named_children()
            • BatchNorm2d.named_modules()
            • BatchNorm2d.named_parameters()
            • BatchNorm2d.parameters()
            • BatchNorm2d.register_backward_hook()
            • BatchNorm2d.register_buffer()
            • BatchNorm2d.register_forward_hook()
            • BatchNorm2d.register_forward_pre_hook()
            • BatchNorm2d.register_full_backward_hook()
            • BatchNorm2d.register_full_backward_pre_hook()
            • BatchNorm2d.register_load_state_dict_post_hook()
            • BatchNorm2d.register_module()
            • BatchNorm2d.register_parameter()
            • BatchNorm2d.register_state_dict_pre_hook()
            • BatchNorm2d.requires_grad_()
            • BatchNorm2d.set_extra_state()
            • BatchNorm2d.share_memory()
            • BatchNorm2d.state_dict()
            • BatchNorm2d.to()
            • BatchNorm2d.to_empty()
            • BatchNorm2d.train()
            • BatchNorm2d.type()
            • BatchNorm2d.xpu()
            • BatchNorm2d.zero_grad()
        • towhee.models.layers.layers_with_relprop.Cat
          • Cat
            • Cat.__call__()
            • Cat.__init__()
            • Cat.__repr__()
            • Cat.add_module()
            • Cat.apply()
            • Cat.bfloat16()
            • Cat.buffers()
            • Cat.children()
            • Cat.cpu()
            • Cat.cuda()
            • Cat.double()
            • Cat.eval()
            • Cat.extra_repr()
            • Cat.float()
            • Cat.forward()
            • Cat.get_buffer()
            • Cat.get_extra_state()
            • Cat.get_parameter()
            • Cat.get_submodule()
            • Cat.half()
            • Cat.ipu()
            • Cat.load_state_dict()
            • Cat.modules()
            • Cat.named_buffers()
            • Cat.named_children()
            • Cat.named_modules()
            • Cat.named_parameters()
            • Cat.parameters()
            • Cat.register_backward_hook()
            • Cat.register_buffer()
            • Cat.register_forward_hook()
            • Cat.register_forward_pre_hook()
            • Cat.register_full_backward_hook()
            • Cat.register_full_backward_pre_hook()
            • Cat.register_load_state_dict_post_hook()
            • Cat.register_module()
            • Cat.register_parameter()
            • Cat.register_state_dict_pre_hook()
            • Cat.requires_grad_()
            • Cat.set_extra_state()
            • Cat.share_memory()
            • Cat.state_dict()
            • Cat.to()
            • Cat.to_empty()
            • Cat.train()
            • Cat.type()
            • Cat.xpu()
            • Cat.zero_grad()
        • towhee.models.layers.layers_with_relprop.Clone
          • Clone
            • Clone.__call__()
            • Clone.__init__()
            • Clone.__repr__()
            • Clone.add_module()
            • Clone.apply()
            • Clone.bfloat16()
            • Clone.buffers()
            • Clone.children()
            • Clone.cpu()
            • Clone.cuda()
            • Clone.double()
            • Clone.eval()
            • Clone.extra_repr()
            • Clone.float()
            • Clone.forward()
            • Clone.get_buffer()
            • Clone.get_extra_state()
            • Clone.get_parameter()
            • Clone.get_submodule()
            • Clone.half()
            • Clone.ipu()
            • Clone.load_state_dict()
            • Clone.modules()
            • Clone.named_buffers()
            • Clone.named_children()
            • Clone.named_modules()
            • Clone.named_parameters()
            • Clone.parameters()
            • Clone.register_backward_hook()
            • Clone.register_buffer()
            • Clone.register_forward_hook()
            • Clone.register_forward_pre_hook()
            • Clone.register_full_backward_hook()
            • Clone.register_full_backward_pre_hook()
            • Clone.register_load_state_dict_post_hook()
            • Clone.register_module()
            • Clone.register_parameter()
            • Clone.register_state_dict_pre_hook()
            • Clone.requires_grad_()
            • Clone.set_extra_state()
            • Clone.share_memory()
            • Clone.state_dict()
            • Clone.to()
            • Clone.to_empty()
            • Clone.train()
            • Clone.type()
            • Clone.xpu()
            • Clone.zero_grad()
        • towhee.models.layers.layers_with_relprop.Conv2d
          • Conv2d
            • Conv2d.__call__()
            • Conv2d.__init__()
            • Conv2d.__repr__()
            • Conv2d.add_module()
            • Conv2d.apply()
            • Conv2d.bfloat16()
            • Conv2d.buffers()
            • Conv2d.children()
            • Conv2d.cpu()
            • Conv2d.cuda()
            • Conv2d.double()
            • Conv2d.eval()
            • Conv2d.extra_repr()
            • Conv2d.float()
            • Conv2d.forward()
            • Conv2d.get_buffer()
            • Conv2d.get_extra_state()
            • Conv2d.get_parameter()
            • Conv2d.get_submodule()
            • Conv2d.half()
            • Conv2d.ipu()
            • Conv2d.load_state_dict()
            • Conv2d.modules()
            • Conv2d.named_buffers()
            • Conv2d.named_children()
            • Conv2d.named_modules()
            • Conv2d.named_parameters()
            • Conv2d.parameters()
            • Conv2d.register_backward_hook()
            • Conv2d.register_buffer()
            • Conv2d.register_forward_hook()
            • Conv2d.register_forward_pre_hook()
            • Conv2d.register_full_backward_hook()
            • Conv2d.register_full_backward_pre_hook()
            • Conv2d.register_load_state_dict_post_hook()
            • Conv2d.register_module()
            • Conv2d.register_parameter()
            • Conv2d.register_state_dict_pre_hook()
            • Conv2d.requires_grad_()
            • Conv2d.set_extra_state()
            • Conv2d.share_memory()
            • Conv2d.state_dict()
            • Conv2d.to()
            • Conv2d.to_empty()
            • Conv2d.train()
            • Conv2d.type()
            • Conv2d.xpu()
            • Conv2d.zero_grad()
        • towhee.models.layers.layers_with_relprop.Conv3d
          • Conv3d
            • Conv3d.__call__()
            • Conv3d.__init__()
            • Conv3d.__repr__()
            • Conv3d.add_module()
            • Conv3d.apply()
            • Conv3d.bfloat16()
            • Conv3d.buffers()
            • Conv3d.children()
            • Conv3d.cpu()
            • Conv3d.cuda()
            • Conv3d.double()
            • Conv3d.eval()
            • Conv3d.extra_repr()
            • Conv3d.float()
            • Conv3d.forward()
            • Conv3d.get_buffer()
            • Conv3d.get_extra_state()
            • Conv3d.get_parameter()
            • Conv3d.get_submodule()
            • Conv3d.half()
            • Conv3d.ipu()
            • Conv3d.load_state_dict()
            • Conv3d.modules()
            • Conv3d.named_buffers()
            • Conv3d.named_children()
            • Conv3d.named_modules()
            • Conv3d.named_parameters()
            • Conv3d.parameters()
            • Conv3d.register_backward_hook()
            • Conv3d.register_buffer()
            • Conv3d.register_forward_hook()
            • Conv3d.register_forward_pre_hook()
            • Conv3d.register_full_backward_hook()
            • Conv3d.register_full_backward_pre_hook()
            • Conv3d.register_load_state_dict_post_hook()
            • Conv3d.register_module()
            • Conv3d.register_parameter()
            • Conv3d.register_state_dict_pre_hook()
            • Conv3d.requires_grad_()
            • Conv3d.set_extra_state()
            • Conv3d.share_memory()
            • Conv3d.state_dict()
            • Conv3d.to()
            • Conv3d.to_empty()
            • Conv3d.train()
            • Conv3d.type()
            • Conv3d.xpu()
            • Conv3d.zero_grad()
        • towhee.models.layers.layers_with_relprop.Dropout
          • Dropout
            • Dropout.__call__()
            • Dropout.__init__()
            • Dropout.__repr__()
            • Dropout.add_module()
            • Dropout.apply()
            • Dropout.bfloat16()
            • Dropout.buffers()
            • Dropout.children()
            • Dropout.cpu()
            • Dropout.cuda()
            • Dropout.double()
            • Dropout.eval()
            • Dropout.extra_repr()
            • Dropout.float()
            • Dropout.forward()
            • Dropout.get_buffer()
            • Dropout.get_extra_state()
            • Dropout.get_parameter()
            • Dropout.get_submodule()
            • Dropout.half()
            • Dropout.ipu()
            • Dropout.load_state_dict()
            • Dropout.modules()
            • Dropout.named_buffers()
            • Dropout.named_children()
            • Dropout.named_modules()
            • Dropout.named_parameters()
            • Dropout.parameters()
            • Dropout.register_backward_hook()
            • Dropout.register_buffer()
            • Dropout.register_forward_hook()
            • Dropout.register_forward_pre_hook()
            • Dropout.register_full_backward_hook()
            • Dropout.register_full_backward_pre_hook()
            • Dropout.register_load_state_dict_post_hook()
            • Dropout.register_module()
            • Dropout.register_parameter()
            • Dropout.register_state_dict_pre_hook()
            • Dropout.requires_grad_()
            • Dropout.set_extra_state()
            • Dropout.share_memory()
            • Dropout.state_dict()
            • Dropout.to()
            • Dropout.to_empty()
            • Dropout.train()
            • Dropout.type()
            • Dropout.xpu()
            • Dropout.zero_grad()
        • towhee.models.layers.layers_with_relprop.Einsum
          • Einsum
            • Einsum.__call__()
            • Einsum.__init__()
            • Einsum.__repr__()
            • Einsum.add_module()
            • Einsum.apply()
            • Einsum.bfloat16()
            • Einsum.buffers()
            • Einsum.children()
            • Einsum.cpu()
            • Einsum.cuda()
            • Einsum.double()
            • Einsum.eval()
            • Einsum.extra_repr()
            • Einsum.float()
            • Einsum.forward()
            • Einsum.get_buffer()
            • Einsum.get_extra_state()
            • Einsum.get_parameter()
            • Einsum.get_submodule()
            • Einsum.half()
            • Einsum.ipu()
            • Einsum.load_state_dict()
            • Einsum.modules()
            • Einsum.named_buffers()
            • Einsum.named_children()
            • Einsum.named_modules()
            • Einsum.named_parameters()
            • Einsum.parameters()
            • Einsum.register_backward_hook()
            • Einsum.register_buffer()
            • Einsum.register_forward_hook()
            • Einsum.register_forward_pre_hook()
            • Einsum.register_full_backward_hook()
            • Einsum.register_full_backward_pre_hook()
            • Einsum.register_load_state_dict_post_hook()
            • Einsum.register_module()
            • Einsum.register_parameter()
            • Einsum.register_state_dict_pre_hook()
            • Einsum.requires_grad_()
            • Einsum.set_extra_state()
            • Einsum.share_memory()
            • Einsum.state_dict()
            • Einsum.to()
            • Einsum.to_empty()
            • Einsum.train()
            • Einsum.type()
            • Einsum.xpu()
            • Einsum.zero_grad()
        • towhee.models.layers.layers_with_relprop.GELU
          • GELU
            • GELU.__call__()
            • GELU.__init__()
            • GELU.__repr__()
            • GELU.add_module()
            • GELU.apply()
            • GELU.bfloat16()
            • GELU.buffers()
            • GELU.children()
            • GELU.cpu()
            • GELU.cuda()
            • GELU.double()
            • GELU.eval()
            • GELU.extra_repr()
            • GELU.float()
            • GELU.forward()
            • GELU.get_buffer()
            • GELU.get_extra_state()
            • GELU.get_parameter()
            • GELU.get_submodule()
            • GELU.half()
            • GELU.ipu()
            • GELU.load_state_dict()
            • GELU.modules()
            • GELU.named_buffers()
            • GELU.named_children()
            • GELU.named_modules()
            • GELU.named_parameters()
            • GELU.parameters()
            • GELU.register_backward_hook()
            • GELU.register_buffer()
            • GELU.register_forward_hook()
            • GELU.register_forward_pre_hook()
            • GELU.register_full_backward_hook()
            • GELU.register_full_backward_pre_hook()
            • GELU.register_load_state_dict_post_hook()
            • GELU.register_module()
            • GELU.register_parameter()
            • GELU.register_state_dict_pre_hook()
            • GELU.requires_grad_()
            • GELU.set_extra_state()
            • GELU.share_memory()
            • GELU.state_dict()
            • GELU.to()
            • GELU.to_empty()
            • GELU.train()
            • GELU.type()
            • GELU.xpu()
            • GELU.zero_grad()
        • towhee.models.layers.layers_with_relprop.IndexSelect
          • IndexSelect
            • IndexSelect.__call__()
            • IndexSelect.__init__()
            • IndexSelect.__repr__()
            • IndexSelect.add_module()
            • IndexSelect.apply()
            • IndexSelect.bfloat16()
            • IndexSelect.buffers()
            • IndexSelect.children()
            • IndexSelect.cpu()
            • IndexSelect.cuda()
            • IndexSelect.double()
            • IndexSelect.eval()
            • IndexSelect.extra_repr()
            • IndexSelect.float()
            • IndexSelect.forward()
            • IndexSelect.get_buffer()
            • IndexSelect.get_extra_state()
            • IndexSelect.get_parameter()
            • IndexSelect.get_submodule()
            • IndexSelect.half()
            • IndexSelect.ipu()
            • IndexSelect.load_state_dict()
            • IndexSelect.modules()
            • IndexSelect.named_buffers()
            • IndexSelect.named_children()
            • IndexSelect.named_modules()
            • IndexSelect.named_parameters()
            • IndexSelect.parameters()
            • IndexSelect.register_backward_hook()
            • IndexSelect.register_buffer()
            • IndexSelect.register_forward_hook()
            • IndexSelect.register_forward_pre_hook()
            • IndexSelect.register_full_backward_hook()
            • IndexSelect.register_full_backward_pre_hook()
            • IndexSelect.register_load_state_dict_post_hook()
            • IndexSelect.register_module()
            • IndexSelect.register_parameter()
            • IndexSelect.register_state_dict_pre_hook()
            • IndexSelect.requires_grad_()
            • IndexSelect.set_extra_state()
            • IndexSelect.share_memory()
            • IndexSelect.state_dict()
            • IndexSelect.to()
            • IndexSelect.to_empty()
            • IndexSelect.train()
            • IndexSelect.type()
            • IndexSelect.xpu()
            • IndexSelect.zero_grad()
        • towhee.models.layers.layers_with_relprop.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.layers.layers_with_relprop.Linear
          • Linear
            • Linear.__call__()
            • Linear.__init__()
            • Linear.__repr__()
            • Linear.add_module()
            • Linear.apply()
            • Linear.bfloat16()
            • Linear.buffers()
            • Linear.children()
            • Linear.cpu()
            • Linear.cuda()
            • Linear.double()
            • Linear.eval()
            • Linear.extra_repr()
            • Linear.float()
            • Linear.forward()
            • Linear.get_buffer()
            • Linear.get_extra_state()
            • Linear.get_parameter()
            • Linear.get_submodule()
            • Linear.half()
            • Linear.ipu()
            • Linear.load_state_dict()
            • Linear.modules()
            • Linear.named_buffers()
            • Linear.named_children()
            • Linear.named_modules()
            • Linear.named_parameters()
            • Linear.parameters()
            • Linear.register_backward_hook()
            • Linear.register_buffer()
            • Linear.register_forward_hook()
            • Linear.register_forward_pre_hook()
            • Linear.register_full_backward_hook()
            • Linear.register_full_backward_pre_hook()
            • Linear.register_load_state_dict_post_hook()
            • Linear.register_module()
            • Linear.register_parameter()
            • Linear.register_state_dict_pre_hook()
            • Linear.requires_grad_()
            • Linear.set_extra_state()
            • Linear.share_memory()
            • Linear.state_dict()
            • Linear.to()
            • Linear.to_empty()
            • Linear.train()
            • Linear.type()
            • Linear.xpu()
            • Linear.zero_grad()
        • towhee.models.layers.layers_with_relprop.MaxPool2d
          • MaxPool2d
            • MaxPool2d.__call__()
            • MaxPool2d.__init__()
            • MaxPool2d.__repr__()
            • MaxPool2d.add_module()
            • MaxPool2d.apply()
            • MaxPool2d.bfloat16()
            • MaxPool2d.buffers()
            • MaxPool2d.children()
            • MaxPool2d.cpu()
            • MaxPool2d.cuda()
            • MaxPool2d.double()
            • MaxPool2d.eval()
            • MaxPool2d.extra_repr()
            • MaxPool2d.float()
            • MaxPool2d.forward()
            • MaxPool2d.get_buffer()
            • MaxPool2d.get_extra_state()
            • MaxPool2d.get_parameter()
            • MaxPool2d.get_submodule()
            • MaxPool2d.half()
            • MaxPool2d.ipu()
            • MaxPool2d.load_state_dict()
            • MaxPool2d.modules()
            • MaxPool2d.named_buffers()
            • MaxPool2d.named_children()
            • MaxPool2d.named_modules()
            • MaxPool2d.named_parameters()
            • MaxPool2d.parameters()
            • MaxPool2d.register_backward_hook()
            • MaxPool2d.register_buffer()
            • MaxPool2d.register_forward_hook()
            • MaxPool2d.register_forward_pre_hook()
            • MaxPool2d.register_full_backward_hook()
            • MaxPool2d.register_full_backward_pre_hook()
            • MaxPool2d.register_load_state_dict_post_hook()
            • MaxPool2d.register_module()
            • MaxPool2d.register_parameter()
            • MaxPool2d.register_state_dict_pre_hook()
            • MaxPool2d.requires_grad_()
            • MaxPool2d.set_extra_state()
            • MaxPool2d.share_memory()
            • MaxPool2d.state_dict()
            • MaxPool2d.to()
            • MaxPool2d.to_empty()
            • MaxPool2d.train()
            • MaxPool2d.type()
            • MaxPool2d.xpu()
            • MaxPool2d.zero_grad()
        • towhee.models.layers.layers_with_relprop.MaxPool3d
          • MaxPool3d
            • MaxPool3d.__call__()
            • MaxPool3d.__init__()
            • MaxPool3d.__repr__()
            • MaxPool3d.add_module()
            • MaxPool3d.apply()
            • MaxPool3d.bfloat16()
            • MaxPool3d.buffers()
            • MaxPool3d.children()
            • MaxPool3d.cpu()
            • MaxPool3d.cuda()
            • MaxPool3d.double()
            • MaxPool3d.eval()
            • MaxPool3d.extra_repr()
            • MaxPool3d.float()
            • MaxPool3d.forward()
            • MaxPool3d.get_buffer()
            • MaxPool3d.get_extra_state()
            • MaxPool3d.get_parameter()
            • MaxPool3d.get_submodule()
            • MaxPool3d.half()
            • MaxPool3d.ipu()
            • MaxPool3d.load_state_dict()
            • MaxPool3d.modules()
            • MaxPool3d.named_buffers()
            • MaxPool3d.named_children()
            • MaxPool3d.named_modules()
            • MaxPool3d.named_parameters()
            • MaxPool3d.parameters()
            • MaxPool3d.register_backward_hook()
            • MaxPool3d.register_buffer()
            • MaxPool3d.register_forward_hook()
            • MaxPool3d.register_forward_pre_hook()
            • MaxPool3d.register_full_backward_hook()
            • MaxPool3d.register_full_backward_pre_hook()
            • MaxPool3d.register_load_state_dict_post_hook()
            • MaxPool3d.register_module()
            • MaxPool3d.register_parameter()
            • MaxPool3d.register_state_dict_pre_hook()
            • MaxPool3d.requires_grad_()
            • MaxPool3d.set_extra_state()
            • MaxPool3d.share_memory()
            • MaxPool3d.state_dict()
            • MaxPool3d.to()
            • MaxPool3d.to_empty()
            • MaxPool3d.train()
            • MaxPool3d.type()
            • MaxPool3d.xpu()
            • MaxPool3d.zero_grad()
        • towhee.models.layers.layers_with_relprop.ReLU
          • ReLU
            • ReLU.__call__()
            • ReLU.__init__()
            • ReLU.__repr__()
            • ReLU.add_module()
            • ReLU.apply()
            • ReLU.bfloat16()
            • ReLU.buffers()
            • ReLU.children()
            • ReLU.cpu()
            • ReLU.cuda()
            • ReLU.double()
            • ReLU.eval()
            • ReLU.extra_repr()
            • ReLU.float()
            • ReLU.forward()
            • ReLU.get_buffer()
            • ReLU.get_extra_state()
            • ReLU.get_parameter()
            • ReLU.get_submodule()
            • ReLU.half()
            • ReLU.ipu()
            • ReLU.load_state_dict()
            • ReLU.modules()
            • ReLU.named_buffers()
            • ReLU.named_children()
            • ReLU.named_modules()
            • ReLU.named_parameters()
            • ReLU.parameters()
            • ReLU.register_backward_hook()
            • ReLU.register_buffer()
            • ReLU.register_forward_hook()
            • ReLU.register_forward_pre_hook()
            • ReLU.register_full_backward_hook()
            • ReLU.register_full_backward_pre_hook()
            • ReLU.register_load_state_dict_post_hook()
            • ReLU.register_module()
            • ReLU.register_parameter()
            • ReLU.register_state_dict_pre_hook()
            • ReLU.requires_grad_()
            • ReLU.set_extra_state()
            • ReLU.share_memory()
            • ReLU.state_dict()
            • ReLU.to()
            • ReLU.to_empty()
            • ReLU.train()
            • ReLU.type()
            • ReLU.xpu()
            • ReLU.zero_grad()
        • towhee.models.layers.layers_with_relprop.RelProp
          • RelProp
            • RelProp.__call__()
            • RelProp.__init__()
            • RelProp.__repr__()
            • RelProp.add_module()
            • RelProp.apply()
            • RelProp.bfloat16()
            • RelProp.buffers()
            • RelProp.children()
            • RelProp.cpu()
            • RelProp.cuda()
            • RelProp.double()
            • RelProp.eval()
            • RelProp.extra_repr()
            • RelProp.float()
            • RelProp.forward()
            • RelProp.get_buffer()
            • RelProp.get_extra_state()
            • RelProp.get_parameter()
            • RelProp.get_submodule()
            • RelProp.half()
            • RelProp.ipu()
            • RelProp.load_state_dict()
            • RelProp.modules()
            • RelProp.named_buffers()
            • RelProp.named_children()
            • RelProp.named_modules()
            • RelProp.named_parameters()
            • RelProp.parameters()
            • RelProp.register_backward_hook()
            • RelProp.register_buffer()
            • RelProp.register_forward_hook()
            • RelProp.register_forward_pre_hook()
            • RelProp.register_full_backward_hook()
            • RelProp.register_full_backward_pre_hook()
            • RelProp.register_load_state_dict_post_hook()
            • RelProp.register_module()
            • RelProp.register_parameter()
            • RelProp.register_state_dict_pre_hook()
            • RelProp.requires_grad_()
            • RelProp.set_extra_state()
            • RelProp.share_memory()
            • RelProp.state_dict()
            • RelProp.to()
            • RelProp.to_empty()
            • RelProp.train()
            • RelProp.type()
            • RelProp.xpu()
            • RelProp.zero_grad()
        • towhee.models.layers.layers_with_relprop.RelPropSimple
          • RelPropSimple
            • RelPropSimple.__call__()
            • RelPropSimple.__init__()
            • RelPropSimple.__repr__()
            • RelPropSimple.add_module()
            • RelPropSimple.apply()
            • RelPropSimple.bfloat16()
            • RelPropSimple.buffers()
            • RelPropSimple.children()
            • RelPropSimple.cpu()
            • RelPropSimple.cuda()
            • RelPropSimple.double()
            • RelPropSimple.eval()
            • RelPropSimple.extra_repr()
            • RelPropSimple.float()
            • RelPropSimple.forward()
            • RelPropSimple.get_buffer()
            • RelPropSimple.get_extra_state()
            • RelPropSimple.get_parameter()
            • RelPropSimple.get_submodule()
            • RelPropSimple.half()
            • RelPropSimple.ipu()
            • RelPropSimple.load_state_dict()
            • RelPropSimple.modules()
            • RelPropSimple.named_buffers()
            • RelPropSimple.named_children()
            • RelPropSimple.named_modules()
            • RelPropSimple.named_parameters()
            • RelPropSimple.parameters()
            • RelPropSimple.register_backward_hook()
            • RelPropSimple.register_buffer()
            • RelPropSimple.register_forward_hook()
            • RelPropSimple.register_forward_pre_hook()
            • RelPropSimple.register_full_backward_hook()
            • RelPropSimple.register_full_backward_pre_hook()
            • RelPropSimple.register_load_state_dict_post_hook()
            • RelPropSimple.register_module()
            • RelPropSimple.register_parameter()
            • RelPropSimple.register_state_dict_pre_hook()
            • RelPropSimple.requires_grad_()
            • RelPropSimple.set_extra_state()
            • RelPropSimple.share_memory()
            • RelPropSimple.state_dict()
            • RelPropSimple.to()
            • RelPropSimple.to_empty()
            • RelPropSimple.train()
            • RelPropSimple.type()
            • RelPropSimple.xpu()
            • RelPropSimple.zero_grad()
        • towhee.models.layers.layers_with_relprop.Sequential
          • Sequential
            • Sequential.__call__()
            • Sequential.__init__()
            • Sequential.__repr__()
            • Sequential.add_module()
            • Sequential.append()
            • Sequential.apply()
            • Sequential.bfloat16()
            • Sequential.buffers()
            • Sequential.children()
            • Sequential.cpu()
            • Sequential.cuda()
            • Sequential.double()
            • Sequential.eval()
            • Sequential.extra_repr()
            • Sequential.float()
            • Sequential.forward()
            • Sequential.get_buffer()
            • Sequential.get_extra_state()
            • Sequential.get_parameter()
            • Sequential.get_submodule()
            • Sequential.half()
            • Sequential.ipu()
            • Sequential.load_state_dict()
            • Sequential.modules()
            • Sequential.named_buffers()
            • Sequential.named_children()
            • Sequential.named_modules()
            • Sequential.named_parameters()
            • Sequential.parameters()
            • Sequential.register_backward_hook()
            • Sequential.register_buffer()
            • Sequential.register_forward_hook()
            • Sequential.register_forward_pre_hook()
            • Sequential.register_full_backward_hook()
            • Sequential.register_full_backward_pre_hook()
            • Sequential.register_load_state_dict_post_hook()
            • Sequential.register_module()
            • Sequential.register_parameter()
            • Sequential.register_state_dict_pre_hook()
            • Sequential.requires_grad_()
            • Sequential.set_extra_state()
            • Sequential.share_memory()
            • Sequential.state_dict()
            • Sequential.to()
            • Sequential.to_empty()
            • Sequential.train()
            • Sequential.type()
            • Sequential.xpu()
            • Sequential.zero_grad()
        • towhee.models.layers.layers_with_relprop.Sigmoid
          • Sigmoid
            • Sigmoid.__call__()
            • Sigmoid.__init__()
            • Sigmoid.__repr__()
            • Sigmoid.add_module()
            • Sigmoid.apply()
            • Sigmoid.bfloat16()
            • Sigmoid.buffers()
            • Sigmoid.children()
            • Sigmoid.cpu()
            • Sigmoid.cuda()
            • Sigmoid.double()
            • Sigmoid.eval()
            • Sigmoid.extra_repr()
            • Sigmoid.float()
            • Sigmoid.forward()
            • Sigmoid.get_buffer()
            • Sigmoid.get_extra_state()
            • Sigmoid.get_parameter()
            • Sigmoid.get_submodule()
            • Sigmoid.half()
            • Sigmoid.ipu()
            • Sigmoid.load_state_dict()
            • Sigmoid.modules()
            • Sigmoid.named_buffers()
            • Sigmoid.named_children()
            • Sigmoid.named_modules()
            • Sigmoid.named_parameters()
            • Sigmoid.parameters()
            • Sigmoid.register_backward_hook()
            • Sigmoid.register_buffer()
            • Sigmoid.register_forward_hook()
            • Sigmoid.register_forward_pre_hook()
            • Sigmoid.register_full_backward_hook()
            • Sigmoid.register_full_backward_pre_hook()
            • Sigmoid.register_load_state_dict_post_hook()
            • Sigmoid.register_module()
            • Sigmoid.register_parameter()
            • Sigmoid.register_state_dict_pre_hook()
            • Sigmoid.requires_grad_()
            • Sigmoid.set_extra_state()
            • Sigmoid.share_memory()
            • Sigmoid.state_dict()
            • Sigmoid.to()
            • Sigmoid.to_empty()
            • Sigmoid.train()
            • Sigmoid.type()
            • Sigmoid.xpu()
            • Sigmoid.zero_grad()
        • towhee.models.layers.layers_with_relprop.Softmax
          • Softmax
            • Softmax.__call__()
            • Softmax.__init__()
            • Softmax.__repr__()
            • Softmax.add_module()
            • Softmax.apply()
            • Softmax.bfloat16()
            • Softmax.buffers()
            • Softmax.children()
            • Softmax.cpu()
            • Softmax.cuda()
            • Softmax.double()
            • Softmax.eval()
            • Softmax.extra_repr()
            • Softmax.float()
            • Softmax.forward()
            • Softmax.get_buffer()
            • Softmax.get_extra_state()
            • Softmax.get_parameter()
            • Softmax.get_submodule()
            • Softmax.half()
            • Softmax.ipu()
            • Softmax.load_state_dict()
            • Softmax.modules()
            • Softmax.named_buffers()
            • Softmax.named_children()
            • Softmax.named_modules()
            • Softmax.named_parameters()
            • Softmax.parameters()
            • Softmax.register_backward_hook()
            • Softmax.register_buffer()
            • Softmax.register_forward_hook()
            • Softmax.register_forward_pre_hook()
            • Softmax.register_full_backward_hook()
            • Softmax.register_full_backward_pre_hook()
            • Softmax.register_load_state_dict_post_hook()
            • Softmax.register_module()
            • Softmax.register_parameter()
            • Softmax.register_state_dict_pre_hook()
            • Softmax.requires_grad_()
            • Softmax.set_extra_state()
            • Softmax.share_memory()
            • Softmax.state_dict()
            • Softmax.to()
            • Softmax.to_empty()
            • Softmax.train()
            • Softmax.type()
            • Softmax.xpu()
            • Softmax.zero_grad()
      • towhee.models.layers.mixed_conv2d
        • towhee.models.layers.mixed_conv2d.MixedConv2d
          • MixedConv2d
            • MixedConv2d.__call__()
            • MixedConv2d.__init__()
            • MixedConv2d.__repr__()
            • MixedConv2d.add_module()
            • MixedConv2d.apply()
            • MixedConv2d.bfloat16()
            • MixedConv2d.buffers()
            • MixedConv2d.children()
            • MixedConv2d.clear()
            • MixedConv2d.cpu()
            • MixedConv2d.cuda()
            • MixedConv2d.double()
            • MixedConv2d.eval()
            • MixedConv2d.extra_repr()
            • MixedConv2d.float()
            • MixedConv2d.forward()
            • MixedConv2d.get_buffer()
            • MixedConv2d.get_extra_state()
            • MixedConv2d.get_parameter()
            • MixedConv2d.get_submodule()
            • MixedConv2d.half()
            • MixedConv2d.ipu()
            • MixedConv2d.items()
            • MixedConv2d.keys()
            • MixedConv2d.load_state_dict()
            • MixedConv2d.modules()
            • MixedConv2d.named_buffers()
            • MixedConv2d.named_children()
            • MixedConv2d.named_modules()
            • MixedConv2d.named_parameters()
            • MixedConv2d.parameters()
            • MixedConv2d.pop()
            • MixedConv2d.register_backward_hook()
            • MixedConv2d.register_buffer()
            • MixedConv2d.register_forward_hook()
            • MixedConv2d.register_forward_pre_hook()
            • MixedConv2d.register_full_backward_hook()
            • MixedConv2d.register_full_backward_pre_hook()
            • MixedConv2d.register_load_state_dict_post_hook()
            • MixedConv2d.register_module()
            • MixedConv2d.register_parameter()
            • MixedConv2d.register_state_dict_pre_hook()
            • MixedConv2d.requires_grad_()
            • MixedConv2d.set_extra_state()
            • MixedConv2d.share_memory()
            • MixedConv2d.state_dict()
            • MixedConv2d.to()
            • MixedConv2d.to_empty()
            • MixedConv2d.train()
            • MixedConv2d.type()
            • MixedConv2d.update()
            • MixedConv2d.values()
            • MixedConv2d.xpu()
            • MixedConv2d.zero_grad()
      • towhee.models.layers.mlp
        • towhee.models.layers.mlp.Mlp
          • Mlp
            • Mlp.__call__()
            • Mlp.__init__()
            • Mlp.__repr__()
            • Mlp.add_module()
            • Mlp.apply()
            • Mlp.bfloat16()
            • Mlp.buffers()
            • Mlp.children()
            • Mlp.cpu()
            • Mlp.cuda()
            • Mlp.double()
            • Mlp.eval()
            • Mlp.extra_repr()
            • Mlp.float()
            • Mlp.forward()
            • Mlp.get_buffer()
            • Mlp.get_extra_state()
            • Mlp.get_parameter()
            • Mlp.get_submodule()
            • Mlp.half()
            • Mlp.ipu()
            • Mlp.load_state_dict()
            • Mlp.modules()
            • Mlp.named_buffers()
            • Mlp.named_children()
            • Mlp.named_modules()
            • Mlp.named_parameters()
            • Mlp.parameters()
            • Mlp.register_backward_hook()
            • Mlp.register_buffer()
            • Mlp.register_forward_hook()
            • Mlp.register_forward_pre_hook()
            • Mlp.register_full_backward_hook()
            • Mlp.register_full_backward_pre_hook()
            • Mlp.register_load_state_dict_post_hook()
            • Mlp.register_module()
            • Mlp.register_parameter()
            • Mlp.register_state_dict_pre_hook()
            • Mlp.requires_grad_()
            • Mlp.set_extra_state()
            • Mlp.share_memory()
            • Mlp.state_dict()
            • Mlp.to()
            • Mlp.to_empty()
            • Mlp.train()
            • Mlp.type()
            • Mlp.xpu()
            • Mlp.zero_grad()
      • towhee.models.layers.multi_scale_attention
        • towhee.models.layers.multi_scale_attention.MultiScaleAttention
          • MultiScaleAttention
            • MultiScaleAttention.__call__()
            • MultiScaleAttention.__init__()
            • MultiScaleAttention.__repr__()
            • MultiScaleAttention.add_module()
            • MultiScaleAttention.apply()
            • MultiScaleAttention.bfloat16()
            • MultiScaleAttention.buffers()
            • MultiScaleAttention.children()
            • MultiScaleAttention.cpu()
            • MultiScaleAttention.cuda()
            • MultiScaleAttention.double()
            • MultiScaleAttention.eval()
            • MultiScaleAttention.extra_repr()
            • MultiScaleAttention.float()
            • MultiScaleAttention.forward()
            • MultiScaleAttention.get_buffer()
            • MultiScaleAttention.get_extra_state()
            • MultiScaleAttention.get_parameter()
            • MultiScaleAttention.get_qkv_length()
            • MultiScaleAttention.get_submodule()
            • MultiScaleAttention.half()
            • MultiScaleAttention.ipu()
            • MultiScaleAttention.load_state_dict()
            • MultiScaleAttention.modules()
            • MultiScaleAttention.named_buffers()
            • MultiScaleAttention.named_children()
            • MultiScaleAttention.named_modules()
            • MultiScaleAttention.named_parameters()
            • MultiScaleAttention.parameters()
            • MultiScaleAttention.qkv_pool()
            • MultiScaleAttention.qkv_proj()
            • MultiScaleAttention.register_backward_hook()
            • MultiScaleAttention.register_buffer()
            • MultiScaleAttention.register_forward_hook()
            • MultiScaleAttention.register_forward_pre_hook()
            • MultiScaleAttention.register_full_backward_hook()
            • MultiScaleAttention.register_full_backward_pre_hook()
            • MultiScaleAttention.register_load_state_dict_post_hook()
            • MultiScaleAttention.register_module()
            • MultiScaleAttention.register_parameter()
            • MultiScaleAttention.register_state_dict_pre_hook()
            • MultiScaleAttention.requires_grad_()
            • MultiScaleAttention.reshape_qkv_to_seq()
            • MultiScaleAttention.set_extra_state()
            • MultiScaleAttention.share_memory()
            • MultiScaleAttention.state_dict()
            • MultiScaleAttention.to()
            • MultiScaleAttention.to_empty()
            • MultiScaleAttention.train()
            • MultiScaleAttention.type()
            • MultiScaleAttention.xpu()
            • MultiScaleAttention.zero_grad()
      • towhee.models.layers.multi_scale_transformer_block
        • towhee.models.layers.multi_scale_transformer_block.MultiScaleBlock
          • MultiScaleBlock
            • MultiScaleBlock.__call__()
            • MultiScaleBlock.__init__()
            • MultiScaleBlock.__repr__()
            • MultiScaleBlock.add_module()
            • MultiScaleBlock.apply()
            • MultiScaleBlock.bfloat16()
            • MultiScaleBlock.buffers()
            • MultiScaleBlock.children()
            • MultiScaleBlock.cpu()
            • MultiScaleBlock.cuda()
            • MultiScaleBlock.double()
            • MultiScaleBlock.eval()
            • MultiScaleBlock.extra_repr()
            • MultiScaleBlock.float()
            • MultiScaleBlock.forward()
            • MultiScaleBlock.get_buffer()
            • MultiScaleBlock.get_extra_state()
            • MultiScaleBlock.get_parameter()
            • MultiScaleBlock.get_submodule()
            • MultiScaleBlock.half()
            • MultiScaleBlock.ipu()
            • MultiScaleBlock.load_state_dict()
            • MultiScaleBlock.modules()
            • MultiScaleBlock.named_buffers()
            • MultiScaleBlock.named_children()
            • MultiScaleBlock.named_modules()
            • MultiScaleBlock.named_parameters()
            • MultiScaleBlock.parameters()
            • MultiScaleBlock.register_backward_hook()
            • MultiScaleBlock.register_buffer()
            • MultiScaleBlock.register_forward_hook()
            • MultiScaleBlock.register_forward_pre_hook()
            • MultiScaleBlock.register_full_backward_hook()
            • MultiScaleBlock.register_full_backward_pre_hook()
            • MultiScaleBlock.register_load_state_dict_post_hook()
            • MultiScaleBlock.register_module()
            • MultiScaleBlock.register_parameter()
            • MultiScaleBlock.register_state_dict_pre_hook()
            • MultiScaleBlock.requires_grad_()
            • MultiScaleBlock.set_extra_state()
            • MultiScaleBlock.share_memory()
            • MultiScaleBlock.state_dict()
            • MultiScaleBlock.to()
            • MultiScaleBlock.to_empty()
            • MultiScaleBlock.train()
            • MultiScaleBlock.type()
            • MultiScaleBlock.xpu()
            • MultiScaleBlock.zero_grad()
      • towhee.models.layers.netvlad
        • towhee.models.layers.netvlad.EmbedNet
          • EmbedNet
            • EmbedNet.__call__()
            • EmbedNet.__init__()
            • EmbedNet.__repr__()
            • EmbedNet.add_module()
            • EmbedNet.apply()
            • EmbedNet.bfloat16()
            • EmbedNet.buffers()
            • EmbedNet.children()
            • EmbedNet.cpu()
            • EmbedNet.cuda()
            • EmbedNet.double()
            • EmbedNet.eval()
            • EmbedNet.extra_repr()
            • EmbedNet.float()
            • EmbedNet.forward()
            • EmbedNet.get_buffer()
            • EmbedNet.get_extra_state()
            • EmbedNet.get_parameter()
            • EmbedNet.get_submodule()
            • EmbedNet.half()
            • EmbedNet.ipu()
            • EmbedNet.load_state_dict()
            • EmbedNet.modules()
            • EmbedNet.named_buffers()
            • EmbedNet.named_children()
            • EmbedNet.named_modules()
            • EmbedNet.named_parameters()
            • EmbedNet.parameters()
            • EmbedNet.register_backward_hook()
            • EmbedNet.register_buffer()
            • EmbedNet.register_forward_hook()
            • EmbedNet.register_forward_pre_hook()
            • EmbedNet.register_full_backward_hook()
            • EmbedNet.register_full_backward_pre_hook()
            • EmbedNet.register_load_state_dict_post_hook()
            • EmbedNet.register_module()
            • EmbedNet.register_parameter()
            • EmbedNet.register_state_dict_pre_hook()
            • EmbedNet.requires_grad_()
            • EmbedNet.set_extra_state()
            • EmbedNet.share_memory()
            • EmbedNet.state_dict()
            • EmbedNet.to()
            • EmbedNet.to_empty()
            • EmbedNet.train()
            • EmbedNet.type()
            • EmbedNet.xpu()
            • EmbedNet.zero_grad()
        • towhee.models.layers.netvlad.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.layers.non_local
        • towhee.models.layers.non_local.make_non_local
          • make_non_local()
        • towhee.models.layers.non_local.NL3DWrapper
          • NL3DWrapper
            • NL3DWrapper.__call__()
            • NL3DWrapper.__init__()
            • NL3DWrapper.__repr__()
            • NL3DWrapper.add_module()
            • NL3DWrapper.apply()
            • NL3DWrapper.bfloat16()
            • NL3DWrapper.buffers()
            • NL3DWrapper.children()
            • NL3DWrapper.cpu()
            • NL3DWrapper.cuda()
            • NL3DWrapper.double()
            • NL3DWrapper.eval()
            • NL3DWrapper.extra_repr()
            • NL3DWrapper.float()
            • NL3DWrapper.forward()
            • NL3DWrapper.get_buffer()
            • NL3DWrapper.get_extra_state()
            • NL3DWrapper.get_parameter()
            • NL3DWrapper.get_submodule()
            • NL3DWrapper.half()
            • NL3DWrapper.ipu()
            • NL3DWrapper.load_state_dict()
            • NL3DWrapper.modules()
            • NL3DWrapper.named_buffers()
            • NL3DWrapper.named_children()
            • NL3DWrapper.named_modules()
            • NL3DWrapper.named_parameters()
            • NL3DWrapper.parameters()
            • NL3DWrapper.register_backward_hook()
            • NL3DWrapper.register_buffer()
            • NL3DWrapper.register_forward_hook()
            • NL3DWrapper.register_forward_pre_hook()
            • NL3DWrapper.register_full_backward_hook()
            • NL3DWrapper.register_full_backward_pre_hook()
            • NL3DWrapper.register_load_state_dict_post_hook()
            • NL3DWrapper.register_module()
            • NL3DWrapper.register_parameter()
            • NL3DWrapper.register_state_dict_pre_hook()
            • NL3DWrapper.requires_grad_()
            • NL3DWrapper.set_extra_state()
            • NL3DWrapper.share_memory()
            • NL3DWrapper.state_dict()
            • NL3DWrapper.to()
            • NL3DWrapper.to_empty()
            • NL3DWrapper.train()
            • NL3DWrapper.type()
            • NL3DWrapper.xpu()
            • NL3DWrapper.zero_grad()
        • towhee.models.layers.non_local.NONLocalBlock1D
          • NONLocalBlock1D
            • NONLocalBlock1D.__call__()
            • NONLocalBlock1D.__init__()
            • NONLocalBlock1D.__repr__()
            • NONLocalBlock1D.add_module()
            • NONLocalBlock1D.apply()
            • NONLocalBlock1D.bfloat16()
            • NONLocalBlock1D.buffers()
            • NONLocalBlock1D.children()
            • NONLocalBlock1D.cpu()
            • NONLocalBlock1D.cuda()
            • NONLocalBlock1D.double()
            • NONLocalBlock1D.eval()
            • NONLocalBlock1D.extra_repr()
            • NONLocalBlock1D.float()
            • NONLocalBlock1D.forward()
            • NONLocalBlock1D.get_buffer()
            • NONLocalBlock1D.get_extra_state()
            • NONLocalBlock1D.get_parameter()
            • NONLocalBlock1D.get_submodule()
            • NONLocalBlock1D.half()
            • NONLocalBlock1D.ipu()
            • NONLocalBlock1D.load_state_dict()
            • NONLocalBlock1D.modules()
            • NONLocalBlock1D.named_buffers()
            • NONLocalBlock1D.named_children()
            • NONLocalBlock1D.named_modules()
            • NONLocalBlock1D.named_parameters()
            • NONLocalBlock1D.parameters()
            • NONLocalBlock1D.register_backward_hook()
            • NONLocalBlock1D.register_buffer()
            • NONLocalBlock1D.register_forward_hook()
            • NONLocalBlock1D.register_forward_pre_hook()
            • NONLocalBlock1D.register_full_backward_hook()
            • NONLocalBlock1D.register_full_backward_pre_hook()
            • NONLocalBlock1D.register_load_state_dict_post_hook()
            • NONLocalBlock1D.register_module()
            • NONLocalBlock1D.register_parameter()
            • NONLocalBlock1D.register_state_dict_pre_hook()
            • NONLocalBlock1D.requires_grad_()
            • NONLocalBlock1D.set_extra_state()
            • NONLocalBlock1D.share_memory()
            • NONLocalBlock1D.state_dict()
            • NONLocalBlock1D.to()
            • NONLocalBlock1D.to_empty()
            • NONLocalBlock1D.train()
            • NONLocalBlock1D.type()
            • NONLocalBlock1D.xpu()
            • NONLocalBlock1D.zero_grad()
        • towhee.models.layers.non_local.NONLocalBlock2D
          • NONLocalBlock2D
            • NONLocalBlock2D.__call__()
            • NONLocalBlock2D.__init__()
            • NONLocalBlock2D.__repr__()
            • NONLocalBlock2D.add_module()
            • NONLocalBlock2D.apply()
            • NONLocalBlock2D.bfloat16()
            • NONLocalBlock2D.buffers()
            • NONLocalBlock2D.children()
            • NONLocalBlock2D.cpu()
            • NONLocalBlock2D.cuda()
            • NONLocalBlock2D.double()
            • NONLocalBlock2D.eval()
            • NONLocalBlock2D.extra_repr()
            • NONLocalBlock2D.float()
            • NONLocalBlock2D.forward()
            • NONLocalBlock2D.get_buffer()
            • NONLocalBlock2D.get_extra_state()
            • NONLocalBlock2D.get_parameter()
            • NONLocalBlock2D.get_submodule()
            • NONLocalBlock2D.half()
            • NONLocalBlock2D.ipu()
            • NONLocalBlock2D.load_state_dict()
            • NONLocalBlock2D.modules()
            • NONLocalBlock2D.named_buffers()
            • NONLocalBlock2D.named_children()
            • NONLocalBlock2D.named_modules()
            • NONLocalBlock2D.named_parameters()
            • NONLocalBlock2D.parameters()
            • NONLocalBlock2D.register_backward_hook()
            • NONLocalBlock2D.register_buffer()
            • NONLocalBlock2D.register_forward_hook()
            • NONLocalBlock2D.register_forward_pre_hook()
            • NONLocalBlock2D.register_full_backward_hook()
            • NONLocalBlock2D.register_full_backward_pre_hook()
            • NONLocalBlock2D.register_load_state_dict_post_hook()
            • NONLocalBlock2D.register_module()
            • NONLocalBlock2D.register_parameter()
            • NONLocalBlock2D.register_state_dict_pre_hook()
            • NONLocalBlock2D.requires_grad_()
            • NONLocalBlock2D.set_extra_state()
            • NONLocalBlock2D.share_memory()
            • NONLocalBlock2D.state_dict()
            • NONLocalBlock2D.to()
            • NONLocalBlock2D.to_empty()
            • NONLocalBlock2D.train()
            • NONLocalBlock2D.type()
            • NONLocalBlock2D.xpu()
            • NONLocalBlock2D.zero_grad()
        • towhee.models.layers.non_local.NONLocalBlock3D
          • NONLocalBlock3D
            • NONLocalBlock3D.__call__()
            • NONLocalBlock3D.__init__()
            • NONLocalBlock3D.__repr__()
            • NONLocalBlock3D.add_module()
            • NONLocalBlock3D.apply()
            • NONLocalBlock3D.bfloat16()
            • NONLocalBlock3D.buffers()
            • NONLocalBlock3D.children()
            • NONLocalBlock3D.cpu()
            • NONLocalBlock3D.cuda()
            • NONLocalBlock3D.double()
            • NONLocalBlock3D.eval()
            • NONLocalBlock3D.extra_repr()
            • NONLocalBlock3D.float()
            • NONLocalBlock3D.forward()
            • NONLocalBlock3D.get_buffer()
            • NONLocalBlock3D.get_extra_state()
            • NONLocalBlock3D.get_parameter()
            • NONLocalBlock3D.get_submodule()
            • NONLocalBlock3D.half()
            • NONLocalBlock3D.ipu()
            • NONLocalBlock3D.load_state_dict()
            • NONLocalBlock3D.modules()
            • NONLocalBlock3D.named_buffers()
            • NONLocalBlock3D.named_children()
            • NONLocalBlock3D.named_modules()
            • NONLocalBlock3D.named_parameters()
            • NONLocalBlock3D.parameters()
            • NONLocalBlock3D.register_backward_hook()
            • NONLocalBlock3D.register_buffer()
            • NONLocalBlock3D.register_forward_hook()
            • NONLocalBlock3D.register_forward_pre_hook()
            • NONLocalBlock3D.register_full_backward_hook()
            • NONLocalBlock3D.register_full_backward_pre_hook()
            • NONLocalBlock3D.register_load_state_dict_post_hook()
            • NONLocalBlock3D.register_module()
            • NONLocalBlock3D.register_parameter()
            • NONLocalBlock3D.register_state_dict_pre_hook()
            • NONLocalBlock3D.requires_grad_()
            • NONLocalBlock3D.set_extra_state()
            • NONLocalBlock3D.share_memory()
            • NONLocalBlock3D.state_dict()
            • NONLocalBlock3D.to()
            • NONLocalBlock3D.to_empty()
            • NONLocalBlock3D.train()
            • NONLocalBlock3D.type()
            • NONLocalBlock3D.xpu()
            • NONLocalBlock3D.zero_grad()
      • towhee.models.layers.padding_functions
        • towhee.models.layers.padding_functions.get_padding
          • get_padding()
        • towhee.models.layers.padding_functions.get_padding_value
          • get_padding_value()
        • towhee.models.layers.padding_functions.get_same_padding
          • get_same_padding()
        • towhee.models.layers.padding_functions.is_static_pad
          • is_static_pad()
        • towhee.models.layers.padding_functions.pad_same
          • pad_same()
        • towhee.models.layers.padding_functions.same_padding
          • same_padding()
      • towhee.models.layers.patch_embed2d
        • towhee.models.layers.patch_embed2d.PatchEmbed2D
          • PatchEmbed2D
            • PatchEmbed2D.__call__()
            • PatchEmbed2D.__init__()
            • PatchEmbed2D.__repr__()
            • PatchEmbed2D.add_module()
            • PatchEmbed2D.apply()
            • PatchEmbed2D.bfloat16()
            • PatchEmbed2D.buffers()
            • PatchEmbed2D.children()
            • PatchEmbed2D.cpu()
            • PatchEmbed2D.cuda()
            • PatchEmbed2D.double()
            • PatchEmbed2D.eval()
            • PatchEmbed2D.extra_repr()
            • PatchEmbed2D.float()
            • PatchEmbed2D.forward()
            • PatchEmbed2D.get_buffer()
            • PatchEmbed2D.get_extra_state()
            • PatchEmbed2D.get_parameter()
            • PatchEmbed2D.get_submodule()
            • PatchEmbed2D.half()
            • PatchEmbed2D.ipu()
            • PatchEmbed2D.load_state_dict()
            • PatchEmbed2D.modules()
            • PatchEmbed2D.named_buffers()
            • PatchEmbed2D.named_children()
            • PatchEmbed2D.named_modules()
            • PatchEmbed2D.named_parameters()
            • PatchEmbed2D.parameters()
            • PatchEmbed2D.register_backward_hook()
            • PatchEmbed2D.register_buffer()
            • PatchEmbed2D.register_forward_hook()
            • PatchEmbed2D.register_forward_pre_hook()
            • PatchEmbed2D.register_full_backward_hook()
            • PatchEmbed2D.register_full_backward_pre_hook()
            • PatchEmbed2D.register_load_state_dict_post_hook()
            • PatchEmbed2D.register_module()
            • PatchEmbed2D.register_parameter()
            • PatchEmbed2D.register_state_dict_pre_hook()
            • PatchEmbed2D.requires_grad_()
            • PatchEmbed2D.set_extra_state()
            • PatchEmbed2D.share_memory()
            • PatchEmbed2D.state_dict()
            • PatchEmbed2D.to()
            • PatchEmbed2D.to_empty()
            • PatchEmbed2D.train()
            • PatchEmbed2D.type()
            • PatchEmbed2D.xpu()
            • PatchEmbed2D.zero_grad()
      • towhee.models.layers.patch_embed3d
        • towhee.models.layers.patch_embed3d.PatchEmbed3D
          • PatchEmbed3D
            • PatchEmbed3D.__call__()
            • PatchEmbed3D.__init__()
            • PatchEmbed3D.__repr__()
            • PatchEmbed3D.add_module()
            • PatchEmbed3D.apply()
            • PatchEmbed3D.bfloat16()
            • PatchEmbed3D.buffers()
            • PatchEmbed3D.children()
            • PatchEmbed3D.cpu()
            • PatchEmbed3D.cuda()
            • PatchEmbed3D.double()
            • PatchEmbed3D.eval()
            • PatchEmbed3D.extra_repr()
            • PatchEmbed3D.float()
            • PatchEmbed3D.forward()
            • PatchEmbed3D.get_buffer()
            • PatchEmbed3D.get_extra_state()
            • PatchEmbed3D.get_parameter()
            • PatchEmbed3D.get_submodule()
            • PatchEmbed3D.half()
            • PatchEmbed3D.ipu()
            • PatchEmbed3D.load_state_dict()
            • PatchEmbed3D.modules()
            • PatchEmbed3D.named_buffers()
            • PatchEmbed3D.named_children()
            • PatchEmbed3D.named_modules()
            • PatchEmbed3D.named_parameters()
            • PatchEmbed3D.parameters()
            • PatchEmbed3D.register_backward_hook()
            • PatchEmbed3D.register_buffer()
            • PatchEmbed3D.register_forward_hook()
            • PatchEmbed3D.register_forward_pre_hook()
            • PatchEmbed3D.register_full_backward_hook()
            • PatchEmbed3D.register_full_backward_pre_hook()
            • PatchEmbed3D.register_load_state_dict_post_hook()
            • PatchEmbed3D.register_module()
            • PatchEmbed3D.register_parameter()
            • PatchEmbed3D.register_state_dict_pre_hook()
            • PatchEmbed3D.requires_grad_()
            • PatchEmbed3D.set_extra_state()
            • PatchEmbed3D.share_memory()
            • PatchEmbed3D.state_dict()
            • PatchEmbed3D.to()
            • PatchEmbed3D.to_empty()
            • PatchEmbed3D.train()
            • PatchEmbed3D.type()
            • PatchEmbed3D.xpu()
            • PatchEmbed3D.zero_grad()
      • towhee.models.layers.patch_merging
        • towhee.models.layers.patch_merging.PatchMerging
          • PatchMerging
            • PatchMerging.__call__()
            • PatchMerging.__init__()
            • PatchMerging.__repr__()
            • PatchMerging.add_module()
            • PatchMerging.apply()
            • PatchMerging.bfloat16()
            • PatchMerging.buffers()
            • PatchMerging.children()
            • PatchMerging.cpu()
            • PatchMerging.cuda()
            • PatchMerging.double()
            • PatchMerging.eval()
            • PatchMerging.extra_repr()
            • PatchMerging.float()
            • PatchMerging.forward()
            • PatchMerging.get_buffer()
            • PatchMerging.get_extra_state()
            • PatchMerging.get_parameter()
            • PatchMerging.get_submodule()
            • PatchMerging.half()
            • PatchMerging.ipu()
            • PatchMerging.load_state_dict()
            • PatchMerging.modules()
            • PatchMerging.named_buffers()
            • PatchMerging.named_children()
            • PatchMerging.named_modules()
            • PatchMerging.named_parameters()
            • PatchMerging.parameters()
            • PatchMerging.register_backward_hook()
            • PatchMerging.register_buffer()
            • PatchMerging.register_forward_hook()
            • PatchMerging.register_forward_pre_hook()
            • PatchMerging.register_full_backward_hook()
            • PatchMerging.register_full_backward_pre_hook()
            • PatchMerging.register_load_state_dict_post_hook()
            • PatchMerging.register_module()
            • PatchMerging.register_parameter()
            • PatchMerging.register_state_dict_pre_hook()
            • PatchMerging.requires_grad_()
            • PatchMerging.set_extra_state()
            • PatchMerging.share_memory()
            • PatchMerging.state_dict()
            • PatchMerging.to()
            • PatchMerging.to_empty()
            • PatchMerging.train()
            • PatchMerging.type()
            • PatchMerging.xpu()
            • PatchMerging.zero_grad()
      • towhee.models.layers.patch_merging3d
        • towhee.models.layers.patch_merging3d.PatchMerging
          • PatchMerging
            • PatchMerging.__call__()
            • PatchMerging.__init__()
            • PatchMerging.__repr__()
            • PatchMerging.add_module()
            • PatchMerging.apply()
            • PatchMerging.bfloat16()
            • PatchMerging.buffers()
            • PatchMerging.children()
            • PatchMerging.cpu()
            • PatchMerging.cuda()
            • PatchMerging.double()
            • PatchMerging.eval()
            • PatchMerging.extra_repr()
            • PatchMerging.float()
            • PatchMerging.forward()
            • PatchMerging.get_buffer()
            • PatchMerging.get_extra_state()
            • PatchMerging.get_parameter()
            • PatchMerging.get_submodule()
            • PatchMerging.half()
            • PatchMerging.ipu()
            • PatchMerging.load_state_dict()
            • PatchMerging.modules()
            • PatchMerging.named_buffers()
            • PatchMerging.named_children()
            • PatchMerging.named_modules()
            • PatchMerging.named_parameters()
            • PatchMerging.parameters()
            • PatchMerging.register_backward_hook()
            • PatchMerging.register_buffer()
            • PatchMerging.register_forward_hook()
            • PatchMerging.register_forward_pre_hook()
            • PatchMerging.register_full_backward_hook()
            • PatchMerging.register_full_backward_pre_hook()
            • PatchMerging.register_load_state_dict_post_hook()
            • PatchMerging.register_module()
            • PatchMerging.register_parameter()
            • PatchMerging.register_state_dict_pre_hook()
            • PatchMerging.requires_grad_()
            • PatchMerging.set_extra_state()
            • PatchMerging.share_memory()
            • PatchMerging.state_dict()
            • PatchMerging.to()
            • PatchMerging.to_empty()
            • PatchMerging.train()
            • PatchMerging.type()
            • PatchMerging.xpu()
            • PatchMerging.zero_grad()
        • towhee.models.layers.patch_merging3d.PatchMerging3D
          • PatchMerging3D
            • PatchMerging3D.__call__()
            • PatchMerging3D.__init__()
            • PatchMerging3D.__repr__()
            • PatchMerging3D.add_module()
            • PatchMerging3D.apply()
            • PatchMerging3D.bfloat16()
            • PatchMerging3D.buffers()
            • PatchMerging3D.children()
            • PatchMerging3D.cpu()
            • PatchMerging3D.cuda()
            • PatchMerging3D.double()
            • PatchMerging3D.eval()
            • PatchMerging3D.extra_repr()
            • PatchMerging3D.float()
            • PatchMerging3D.forward()
            • PatchMerging3D.get_buffer()
            • PatchMerging3D.get_extra_state()
            • PatchMerging3D.get_parameter()
            • PatchMerging3D.get_submodule()
            • PatchMerging3D.half()
            • PatchMerging3D.ipu()
            • PatchMerging3D.load_state_dict()
            • PatchMerging3D.modules()
            • PatchMerging3D.named_buffers()
            • PatchMerging3D.named_children()
            • PatchMerging3D.named_modules()
            • PatchMerging3D.named_parameters()
            • PatchMerging3D.parameters()
            • PatchMerging3D.register_backward_hook()
            • PatchMerging3D.register_buffer()
            • PatchMerging3D.register_forward_hook()
            • PatchMerging3D.register_forward_pre_hook()
            • PatchMerging3D.register_full_backward_hook()
            • PatchMerging3D.register_full_backward_pre_hook()
            • PatchMerging3D.register_load_state_dict_post_hook()
            • PatchMerging3D.register_module()
            • PatchMerging3D.register_parameter()
            • PatchMerging3D.register_state_dict_pre_hook()
            • PatchMerging3D.requires_grad_()
            • PatchMerging3D.set_extra_state()
            • PatchMerging3D.share_memory()
            • PatchMerging3D.state_dict()
            • PatchMerging3D.to()
            • PatchMerging3D.to_empty()
            • PatchMerging3D.train()
            • PatchMerging3D.type()
            • PatchMerging3D.xpu()
            • PatchMerging3D.zero_grad()
      • towhee.models.layers.pool_attention
        • towhee.models.layers.pool_attention.AttentionPool
          • AttentionPool
            • AttentionPool.__call__()
            • AttentionPool.__init__()
            • AttentionPool.__repr__()
            • AttentionPool.add_module()
            • AttentionPool.apply()
            • AttentionPool.bfloat16()
            • AttentionPool.buffers()
            • AttentionPool.children()
            • AttentionPool.cpu()
            • AttentionPool.cuda()
            • AttentionPool.double()
            • AttentionPool.eval()
            • AttentionPool.extra_repr()
            • AttentionPool.float()
            • AttentionPool.forward()
            • AttentionPool.get_buffer()
            • AttentionPool.get_extra_state()
            • AttentionPool.get_parameter()
            • AttentionPool.get_submodule()
            • AttentionPool.half()
            • AttentionPool.ipu()
            • AttentionPool.load_state_dict()
            • AttentionPool.modules()
            • AttentionPool.named_buffers()
            • AttentionPool.named_children()
            • AttentionPool.named_modules()
            • AttentionPool.named_parameters()
            • AttentionPool.parameters()
            • AttentionPool.register_backward_hook()
            • AttentionPool.register_buffer()
            • AttentionPool.register_forward_hook()
            • AttentionPool.register_forward_pre_hook()
            • AttentionPool.register_full_backward_hook()
            • AttentionPool.register_full_backward_pre_hook()
            • AttentionPool.register_load_state_dict_post_hook()
            • AttentionPool.register_module()
            • AttentionPool.register_parameter()
            • AttentionPool.register_state_dict_pre_hook()
            • AttentionPool.requires_grad_()
            • AttentionPool.set_extra_state()
            • AttentionPool.share_memory()
            • AttentionPool.state_dict()
            • AttentionPool.to()
            • AttentionPool.to_empty()
            • AttentionPool.train()
            • AttentionPool.type()
            • AttentionPool.xpu()
            • AttentionPool.zero_grad()
      • towhee.models.layers.position_encoding
        • towhee.models.layers.position_encoding.build_position_encoding
          • build_position_encoding()
        • towhee.models.layers.position_encoding.PositionEmbedding
          • PositionEmbedding
            • PositionEmbedding.__call__()
            • PositionEmbedding.__init__()
            • PositionEmbedding.__repr__()
            • PositionEmbedding.add_module()
            • PositionEmbedding.apply()
            • PositionEmbedding.bfloat16()
            • PositionEmbedding.buffers()
            • PositionEmbedding.children()
            • PositionEmbedding.cpu()
            • PositionEmbedding.cuda()
            • PositionEmbedding.double()
            • PositionEmbedding.eval()
            • PositionEmbedding.extra_repr()
            • PositionEmbedding.float()
            • PositionEmbedding.forward()
            • PositionEmbedding.get_buffer()
            • PositionEmbedding.get_extra_state()
            • PositionEmbedding.get_parameter()
            • PositionEmbedding.get_submodule()
            • PositionEmbedding.half()
            • PositionEmbedding.ipu()
            • PositionEmbedding.load_state_dict()
            • PositionEmbedding.modules()
            • PositionEmbedding.named_buffers()
            • PositionEmbedding.named_children()
            • PositionEmbedding.named_modules()
            • PositionEmbedding.named_parameters()
            • PositionEmbedding.parameters()
            • PositionEmbedding.register_backward_hook()
            • PositionEmbedding.register_buffer()
            • PositionEmbedding.register_forward_hook()
            • PositionEmbedding.register_forward_pre_hook()
            • PositionEmbedding.register_full_backward_hook()
            • PositionEmbedding.register_full_backward_pre_hook()
            • PositionEmbedding.register_load_state_dict_post_hook()
            • PositionEmbedding.register_module()
            • PositionEmbedding.register_parameter()
            • PositionEmbedding.register_state_dict_pre_hook()
            • PositionEmbedding.requires_grad_()
            • PositionEmbedding.set_extra_state()
            • PositionEmbedding.share_memory()
            • PositionEmbedding.state_dict()
            • PositionEmbedding.to()
            • PositionEmbedding.to_empty()
            • PositionEmbedding.train()
            • PositionEmbedding.type()
            • PositionEmbedding.xpu()
            • PositionEmbedding.zero_grad()
        • towhee.models.layers.position_encoding.PositionEmbeddingLearned
          • PositionEmbeddingLearned
            • PositionEmbeddingLearned.__call__()
            • PositionEmbeddingLearned.__init__()
            • PositionEmbeddingLearned.__repr__()
            • PositionEmbeddingLearned.add_module()
            • PositionEmbeddingLearned.apply()
            • PositionEmbeddingLearned.bfloat16()
            • PositionEmbeddingLearned.buffers()
            • PositionEmbeddingLearned.children()
            • PositionEmbeddingLearned.cpu()
            • PositionEmbeddingLearned.cuda()
            • PositionEmbeddingLearned.double()
            • PositionEmbeddingLearned.eval()
            • PositionEmbeddingLearned.extra_repr()
            • PositionEmbeddingLearned.float()
            • PositionEmbeddingLearned.forward()
            • PositionEmbeddingLearned.get_buffer()
            • PositionEmbeddingLearned.get_extra_state()
            • PositionEmbeddingLearned.get_parameter()
            • PositionEmbeddingLearned.get_submodule()
            • PositionEmbeddingLearned.half()
            • PositionEmbeddingLearned.ipu()
            • PositionEmbeddingLearned.load_state_dict()
            • PositionEmbeddingLearned.modules()
            • PositionEmbeddingLearned.named_buffers()
            • PositionEmbeddingLearned.named_children()
            • PositionEmbeddingLearned.named_modules()
            • PositionEmbeddingLearned.named_parameters()
            • PositionEmbeddingLearned.parameters()
            • PositionEmbeddingLearned.register_backward_hook()
            • PositionEmbeddingLearned.register_buffer()
            • PositionEmbeddingLearned.register_forward_hook()
            • PositionEmbeddingLearned.register_forward_pre_hook()
            • PositionEmbeddingLearned.register_full_backward_hook()
            • PositionEmbeddingLearned.register_full_backward_pre_hook()
            • PositionEmbeddingLearned.register_load_state_dict_post_hook()
            • PositionEmbeddingLearned.register_module()
            • PositionEmbeddingLearned.register_parameter()
            • PositionEmbeddingLearned.register_state_dict_pre_hook()
            • PositionEmbeddingLearned.requires_grad_()
            • PositionEmbeddingLearned.set_extra_state()
            • PositionEmbeddingLearned.share_memory()
            • PositionEmbeddingLearned.state_dict()
            • PositionEmbeddingLearned.to()
            • PositionEmbeddingLearned.to_empty()
            • PositionEmbeddingLearned.train()
            • PositionEmbeddingLearned.type()
            • PositionEmbeddingLearned.xpu()
            • PositionEmbeddingLearned.zero_grad()
      • towhee.models.layers.relative_self_attention
        • towhee.models.layers.relative_self_attention.RelativeSelfAttention
          • RelativeSelfAttention
            • RelativeSelfAttention.__call__()
            • RelativeSelfAttention.__init__()
            • RelativeSelfAttention.__repr__()
            • RelativeSelfAttention.add_module()
            • RelativeSelfAttention.apply()
            • RelativeSelfAttention.bfloat16()
            • RelativeSelfAttention.buffers()
            • RelativeSelfAttention.children()
            • RelativeSelfAttention.cpu()
            • RelativeSelfAttention.cuda()
            • RelativeSelfAttention.double()
            • RelativeSelfAttention.eval()
            • RelativeSelfAttention.extra_repr()
            • RelativeSelfAttention.float()
            • RelativeSelfAttention.forward()
            • RelativeSelfAttention.get_buffer()
            • RelativeSelfAttention.get_extra_state()
            • RelativeSelfAttention.get_parameter()
            • RelativeSelfAttention.get_submodule()
            • RelativeSelfAttention.half()
            • RelativeSelfAttention.ipu()
            • RelativeSelfAttention.load_state_dict()
            • RelativeSelfAttention.modules()
            • RelativeSelfAttention.named_buffers()
            • RelativeSelfAttention.named_children()
            • RelativeSelfAttention.named_modules()
            • RelativeSelfAttention.named_parameters()
            • RelativeSelfAttention.parameters()
            • RelativeSelfAttention.register_backward_hook()
            • RelativeSelfAttention.register_buffer()
            • RelativeSelfAttention.register_forward_hook()
            • RelativeSelfAttention.register_forward_pre_hook()
            • RelativeSelfAttention.register_full_backward_hook()
            • RelativeSelfAttention.register_full_backward_pre_hook()
            • RelativeSelfAttention.register_load_state_dict_post_hook()
            • RelativeSelfAttention.register_module()
            • RelativeSelfAttention.register_parameter()
            • RelativeSelfAttention.register_state_dict_pre_hook()
            • RelativeSelfAttention.requires_grad_()
            • RelativeSelfAttention.set_extra_state()
            • RelativeSelfAttention.share_memory()
            • RelativeSelfAttention.state_dict()
            • RelativeSelfAttention.to()
            • RelativeSelfAttention.to_empty()
            • RelativeSelfAttention.train()
            • RelativeSelfAttention.type()
            • RelativeSelfAttention.xpu()
            • RelativeSelfAttention.zero_grad()
      • towhee.models.layers.resnet_basic_3d_module
        • towhee.models.layers.resnet_basic_3d_module.ResNetBasic3DModule
          • ResNetBasic3DModule
            • ResNetBasic3DModule.__call__()
            • ResNetBasic3DModule.__init__()
            • ResNetBasic3DModule.__repr__()
            • ResNetBasic3DModule.add_module()
            • ResNetBasic3DModule.apply()
            • ResNetBasic3DModule.bfloat16()
            • ResNetBasic3DModule.buffers()
            • ResNetBasic3DModule.children()
            • ResNetBasic3DModule.cpu()
            • ResNetBasic3DModule.cuda()
            • ResNetBasic3DModule.double()
            • ResNetBasic3DModule.eval()
            • ResNetBasic3DModule.extra_repr()
            • ResNetBasic3DModule.float()
            • ResNetBasic3DModule.forward()
            • ResNetBasic3DModule.get_buffer()
            • ResNetBasic3DModule.get_extra_state()
            • ResNetBasic3DModule.get_parameter()
            • ResNetBasic3DModule.get_submodule()
            • ResNetBasic3DModule.half()
            • ResNetBasic3DModule.ipu()
            • ResNetBasic3DModule.load_state_dict()
            • ResNetBasic3DModule.modules()
            • ResNetBasic3DModule.named_buffers()
            • ResNetBasic3DModule.named_children()
            • ResNetBasic3DModule.named_modules()
            • ResNetBasic3DModule.named_parameters()
            • ResNetBasic3DModule.parameters()
            • ResNetBasic3DModule.register_backward_hook()
            • ResNetBasic3DModule.register_buffer()
            • ResNetBasic3DModule.register_forward_hook()
            • ResNetBasic3DModule.register_forward_pre_hook()
            • ResNetBasic3DModule.register_full_backward_hook()
            • ResNetBasic3DModule.register_full_backward_pre_hook()
            • ResNetBasic3DModule.register_load_state_dict_post_hook()
            • ResNetBasic3DModule.register_module()
            • ResNetBasic3DModule.register_parameter()
            • ResNetBasic3DModule.register_state_dict_pre_hook()
            • ResNetBasic3DModule.requires_grad_()
            • ResNetBasic3DModule.set_extra_state()
            • ResNetBasic3DModule.share_memory()
            • ResNetBasic3DModule.state_dict()
            • ResNetBasic3DModule.to()
            • ResNetBasic3DModule.to_empty()
            • ResNetBasic3DModule.train()
            • ResNetBasic3DModule.type()
            • ResNetBasic3DModule.xpu()
            • ResNetBasic3DModule.zero_grad()
      • towhee.models.layers.sam
        • towhee.models.layers.sam.SAM
          • SAM
            • SAM.__init__()
            • SAM.__repr__()
            • SAM.add_param_group()
            • SAM.load_state_dict()
            • SAM.register_step_post_hook()
            • SAM.register_step_pre_hook()
            • SAM.state_dict()
            • SAM.step()
            • SAM.zero_grad()
      • towhee.models.layers.sequence_pool
        • towhee.models.layers.sequence_pool.SequencePool
          • SequencePool
            • SequencePool.__call__()
            • SequencePool.__init__()
            • SequencePool.__repr__()
            • SequencePool.add_module()
            • SequencePool.apply()
            • SequencePool.bfloat16()
            • SequencePool.buffers()
            • SequencePool.children()
            • SequencePool.cpu()
            • SequencePool.cuda()
            • SequencePool.double()
            • SequencePool.eval()
            • SequencePool.extra_repr()
            • SequencePool.float()
            • SequencePool.forward()
            • SequencePool.get_buffer()
            • SequencePool.get_extra_state()
            • SequencePool.get_parameter()
            • SequencePool.get_submodule()
            • SequencePool.half()
            • SequencePool.ipu()
            • SequencePool.load_state_dict()
            • SequencePool.modules()
            • SequencePool.named_buffers()
            • SequencePool.named_children()
            • SequencePool.named_modules()
            • SequencePool.named_parameters()
            • SequencePool.parameters()
            • SequencePool.register_backward_hook()
            • SequencePool.register_buffer()
            • SequencePool.register_forward_hook()
            • SequencePool.register_forward_pre_hook()
            • SequencePool.register_full_backward_hook()
            • SequencePool.register_full_backward_pre_hook()
            • SequencePool.register_load_state_dict_post_hook()
            • SequencePool.register_module()
            • SequencePool.register_parameter()
            • SequencePool.register_state_dict_pre_hook()
            • SequencePool.requires_grad_()
            • SequencePool.set_extra_state()
            • SequencePool.share_memory()
            • SequencePool.state_dict()
            • SequencePool.to()
            • SequencePool.to_empty()
            • SequencePool.train()
            • SequencePool.type()
            • SequencePool.xpu()
            • SequencePool.zero_grad()
      • towhee.models.layers.spatial_temporal_cls_positional_encoding
        • towhee.models.layers.spatial_temporal_cls_positional_encoding.SpatialTemporalClsPositionalEncoding
          • SpatialTemporalClsPositionalEncoding
            • SpatialTemporalClsPositionalEncoding.__call__()
            • SpatialTemporalClsPositionalEncoding.__init__()
            • SpatialTemporalClsPositionalEncoding.__repr__()
            • SpatialTemporalClsPositionalEncoding.add_module()
            • SpatialTemporalClsPositionalEncoding.apply()
            • SpatialTemporalClsPositionalEncoding.bfloat16()
            • SpatialTemporalClsPositionalEncoding.buffers()
            • SpatialTemporalClsPositionalEncoding.children()
            • SpatialTemporalClsPositionalEncoding.cpu()
            • SpatialTemporalClsPositionalEncoding.cuda()
            • SpatialTemporalClsPositionalEncoding.double()
            • SpatialTemporalClsPositionalEncoding.eval()
            • SpatialTemporalClsPositionalEncoding.extra_repr()
            • SpatialTemporalClsPositionalEncoding.float()
            • SpatialTemporalClsPositionalEncoding.forward()
            • SpatialTemporalClsPositionalEncoding.get_buffer()
            • SpatialTemporalClsPositionalEncoding.get_extra_state()
            • SpatialTemporalClsPositionalEncoding.get_parameter()
            • SpatialTemporalClsPositionalEncoding.get_submodule()
            • SpatialTemporalClsPositionalEncoding.half()
            • SpatialTemporalClsPositionalEncoding.ipu()
            • SpatialTemporalClsPositionalEncoding.load_state_dict()
            • SpatialTemporalClsPositionalEncoding.modules()
            • SpatialTemporalClsPositionalEncoding.named_buffers()
            • SpatialTemporalClsPositionalEncoding.named_children()
            • SpatialTemporalClsPositionalEncoding.named_modules()
            • SpatialTemporalClsPositionalEncoding.named_parameters()
            • SpatialTemporalClsPositionalEncoding.parameters()
            • SpatialTemporalClsPositionalEncoding.register_backward_hook()
            • SpatialTemporalClsPositionalEncoding.register_buffer()
            • SpatialTemporalClsPositionalEncoding.register_forward_hook()
            • SpatialTemporalClsPositionalEncoding.register_forward_pre_hook()
            • SpatialTemporalClsPositionalEncoding.register_full_backward_hook()
            • SpatialTemporalClsPositionalEncoding.register_full_backward_pre_hook()
            • SpatialTemporalClsPositionalEncoding.register_load_state_dict_post_hook()
            • SpatialTemporalClsPositionalEncoding.register_module()
            • SpatialTemporalClsPositionalEncoding.register_parameter()
            • SpatialTemporalClsPositionalEncoding.register_state_dict_pre_hook()
            • SpatialTemporalClsPositionalEncoding.requires_grad_()
            • SpatialTemporalClsPositionalEncoding.set_extra_state()
            • SpatialTemporalClsPositionalEncoding.share_memory()
            • SpatialTemporalClsPositionalEncoding.state_dict()
            • SpatialTemporalClsPositionalEncoding.to()
            • SpatialTemporalClsPositionalEncoding.to_empty()
            • SpatialTemporalClsPositionalEncoding.train()
            • SpatialTemporalClsPositionalEncoding.type()
            • SpatialTemporalClsPositionalEncoding.xpu()
            • SpatialTemporalClsPositionalEncoding.zero_grad()
      • towhee.models.layers.spp
        • towhee.models.layers.spp.SPP
          • SPP
            • SPP.__call__()
            • SPP.__init__()
            • SPP.__repr__()
            • SPP.add_module()
            • SPP.apply()
            • SPP.bfloat16()
            • SPP.buffers()
            • SPP.children()
            • SPP.cpu()
            • SPP.cuda()
            • SPP.double()
            • SPP.eval()
            • SPP.extra_repr()
            • SPP.float()
            • SPP.forward()
            • SPP.get_buffer()
            • SPP.get_extra_state()
            • SPP.get_parameter()
            • SPP.get_submodule()
            • SPP.half()
            • SPP.ipu()
            • SPP.load_state_dict()
            • SPP.modules()
            • SPP.named_buffers()
            • SPP.named_children()
            • SPP.named_modules()
            • SPP.named_parameters()
            • SPP.parameters()
            • SPP.register_backward_hook()
            • SPP.register_buffer()
            • SPP.register_forward_hook()
            • SPP.register_forward_pre_hook()
            • SPP.register_full_backward_hook()
            • SPP.register_full_backward_pre_hook()
            • SPP.register_load_state_dict_post_hook()
            • SPP.register_module()
            • SPP.register_parameter()
            • SPP.register_state_dict_pre_hook()
            • SPP.requires_grad_()
            • SPP.set_extra_state()
            • SPP.share_memory()
            • SPP.state_dict()
            • SPP.to()
            • SPP.to_empty()
            • SPP.train()
            • SPP.type()
            • SPP.xpu()
            • SPP.zero_grad()
      • towhee.models.layers.swin_transformer_block3d
        • towhee.models.layers.swin_transformer_block3d.SwinTransformerBlock3D
          • SwinTransformerBlock3D
            • SwinTransformerBlock3D.__call__()
            • SwinTransformerBlock3D.__init__()
            • SwinTransformerBlock3D.__repr__()
            • SwinTransformerBlock3D.add_module()
            • SwinTransformerBlock3D.apply()
            • SwinTransformerBlock3D.bfloat16()
            • SwinTransformerBlock3D.buffers()
            • SwinTransformerBlock3D.children()
            • SwinTransformerBlock3D.cpu()
            • SwinTransformerBlock3D.cuda()
            • SwinTransformerBlock3D.double()
            • SwinTransformerBlock3D.eval()
            • SwinTransformerBlock3D.extra_repr()
            • SwinTransformerBlock3D.float()
            • SwinTransformerBlock3D.forward()
            • SwinTransformerBlock3D.get_buffer()
            • SwinTransformerBlock3D.get_extra_state()
            • SwinTransformerBlock3D.get_parameter()
            • SwinTransformerBlock3D.get_submodule()
            • SwinTransformerBlock3D.half()
            • SwinTransformerBlock3D.ipu()
            • SwinTransformerBlock3D.load_state_dict()
            • SwinTransformerBlock3D.modules()
            • SwinTransformerBlock3D.named_buffers()
            • SwinTransformerBlock3D.named_children()
            • SwinTransformerBlock3D.named_modules()
            • SwinTransformerBlock3D.named_parameters()
            • SwinTransformerBlock3D.parameters()
            • SwinTransformerBlock3D.register_backward_hook()
            • SwinTransformerBlock3D.register_buffer()
            • SwinTransformerBlock3D.register_forward_hook()
            • SwinTransformerBlock3D.register_forward_pre_hook()
            • SwinTransformerBlock3D.register_full_backward_hook()
            • SwinTransformerBlock3D.register_full_backward_pre_hook()
            • SwinTransformerBlock3D.register_load_state_dict_post_hook()
            • SwinTransformerBlock3D.register_module()
            • SwinTransformerBlock3D.register_parameter()
            • SwinTransformerBlock3D.register_state_dict_pre_hook()
            • SwinTransformerBlock3D.requires_grad_()
            • SwinTransformerBlock3D.set_extra_state()
            • SwinTransformerBlock3D.share_memory()
            • SwinTransformerBlock3D.state_dict()
            • SwinTransformerBlock3D.to()
            • SwinTransformerBlock3D.to_empty()
            • SwinTransformerBlock3D.train()
            • SwinTransformerBlock3D.type()
            • SwinTransformerBlock3D.xpu()
            • SwinTransformerBlock3D.zero_grad()
      • towhee.models.layers.temporal_cg_avgpool3d
        • towhee.models.layers.temporal_cg_avgpool3d.TemporalCGAvgPool3D
          • TemporalCGAvgPool3D
            • TemporalCGAvgPool3D.__call__()
            • TemporalCGAvgPool3D.__init__()
            • TemporalCGAvgPool3D.__repr__()
            • TemporalCGAvgPool3D.add_module()
            • TemporalCGAvgPool3D.apply()
            • TemporalCGAvgPool3D.bfloat16()
            • TemporalCGAvgPool3D.buffers()
            • TemporalCGAvgPool3D.children()
            • TemporalCGAvgPool3D.cpu()
            • TemporalCGAvgPool3D.cuda()
            • TemporalCGAvgPool3D.double()
            • TemporalCGAvgPool3D.eval()
            • TemporalCGAvgPool3D.extra_repr()
            • TemporalCGAvgPool3D.float()
            • TemporalCGAvgPool3D.forward()
            • TemporalCGAvgPool3D.get_buffer()
            • TemporalCGAvgPool3D.get_extra_state()
            • TemporalCGAvgPool3D.get_parameter()
            • TemporalCGAvgPool3D.get_submodule()
            • TemporalCGAvgPool3D.half()
            • TemporalCGAvgPool3D.ipu()
            • TemporalCGAvgPool3D.load_state_dict()
            • TemporalCGAvgPool3D.modules()
            • TemporalCGAvgPool3D.named_buffers()
            • TemporalCGAvgPool3D.named_children()
            • TemporalCGAvgPool3D.named_modules()
            • TemporalCGAvgPool3D.named_parameters()
            • TemporalCGAvgPool3D.parameters()
            • TemporalCGAvgPool3D.register_backward_hook()
            • TemporalCGAvgPool3D.register_buffer()
            • TemporalCGAvgPool3D.register_forward_hook()
            • TemporalCGAvgPool3D.register_forward_pre_hook()
            • TemporalCGAvgPool3D.register_full_backward_hook()
            • TemporalCGAvgPool3D.register_full_backward_pre_hook()
            • TemporalCGAvgPool3D.register_load_state_dict_post_hook()
            • TemporalCGAvgPool3D.register_module()
            • TemporalCGAvgPool3D.register_parameter()
            • TemporalCGAvgPool3D.register_state_dict_pre_hook()
            • TemporalCGAvgPool3D.requires_grad_()
            • TemporalCGAvgPool3D.set_extra_state()
            • TemporalCGAvgPool3D.share_memory()
            • TemporalCGAvgPool3D.state_dict()
            • TemporalCGAvgPool3D.to()
            • TemporalCGAvgPool3D.to_empty()
            • TemporalCGAvgPool3D.train()
            • TemporalCGAvgPool3D.type()
            • TemporalCGAvgPool3D.xpu()
            • TemporalCGAvgPool3D.zero_grad()
      • towhee.models.layers.tf_avgpool3d
        • towhee.models.layers.tf_avgpool3d.TfAvgPool3D
          • TfAvgPool3D
            • TfAvgPool3D.__call__()
            • TfAvgPool3D.__init__()
            • TfAvgPool3D.__repr__()
            • TfAvgPool3D.add_module()
            • TfAvgPool3D.apply()
            • TfAvgPool3D.bfloat16()
            • TfAvgPool3D.buffers()
            • TfAvgPool3D.children()
            • TfAvgPool3D.cpu()
            • TfAvgPool3D.cuda()
            • TfAvgPool3D.double()
            • TfAvgPool3D.eval()
            • TfAvgPool3D.extra_repr()
            • TfAvgPool3D.float()
            • TfAvgPool3D.forward()
            • TfAvgPool3D.get_buffer()
            • TfAvgPool3D.get_extra_state()
            • TfAvgPool3D.get_parameter()
            • TfAvgPool3D.get_submodule()
            • TfAvgPool3D.half()
            • TfAvgPool3D.ipu()
            • TfAvgPool3D.load_state_dict()
            • TfAvgPool3D.modules()
            • TfAvgPool3D.named_buffers()
            • TfAvgPool3D.named_children()
            • TfAvgPool3D.named_modules()
            • TfAvgPool3D.named_parameters()
            • TfAvgPool3D.parameters()
            • TfAvgPool3D.register_backward_hook()
            • TfAvgPool3D.register_buffer()
            • TfAvgPool3D.register_forward_hook()
            • TfAvgPool3D.register_forward_pre_hook()
            • TfAvgPool3D.register_full_backward_hook()
            • TfAvgPool3D.register_full_backward_pre_hook()
            • TfAvgPool3D.register_load_state_dict_post_hook()
            • TfAvgPool3D.register_module()
            • TfAvgPool3D.register_parameter()
            • TfAvgPool3D.register_state_dict_pre_hook()
            • TfAvgPool3D.requires_grad_()
            • TfAvgPool3D.set_extra_state()
            • TfAvgPool3D.share_memory()
            • TfAvgPool3D.state_dict()
            • TfAvgPool3D.to()
            • TfAvgPool3D.to_empty()
            • TfAvgPool3D.train()
            • TfAvgPool3D.type()
            • TfAvgPool3D.xpu()
            • TfAvgPool3D.zero_grad()
      • towhee.models.layers.time2vec
        • towhee.models.layers.time2vec.Time2Vec
          • Time2Vec
            • Time2Vec.__call__()
            • Time2Vec.__init__()
            • Time2Vec.__repr__()
            • Time2Vec.add_module()
            • Time2Vec.apply()
            • Time2Vec.bfloat16()
            • Time2Vec.buffers()
            • Time2Vec.children()
            • Time2Vec.cpu()
            • Time2Vec.cuda()
            • Time2Vec.double()
            • Time2Vec.eval()
            • Time2Vec.extra_repr()
            • Time2Vec.float()
            • Time2Vec.forward()
            • Time2Vec.get_buffer()
            • Time2Vec.get_extra_state()
            • Time2Vec.get_parameter()
            • Time2Vec.get_submodule()
            • Time2Vec.half()
            • Time2Vec.ipu()
            • Time2Vec.load_state_dict()
            • Time2Vec.modules()
            • Time2Vec.named_buffers()
            • Time2Vec.named_children()
            • Time2Vec.named_modules()
            • Time2Vec.named_parameters()
            • Time2Vec.parameters()
            • Time2Vec.register_backward_hook()
            • Time2Vec.register_buffer()
            • Time2Vec.register_forward_hook()
            • Time2Vec.register_forward_pre_hook()
            • Time2Vec.register_full_backward_hook()
            • Time2Vec.register_full_backward_pre_hook()
            • Time2Vec.register_load_state_dict_post_hook()
            • Time2Vec.register_module()
            • Time2Vec.register_parameter()
            • Time2Vec.register_state_dict_pre_hook()
            • Time2Vec.requires_grad_()
            • Time2Vec.set_extra_state()
            • Time2Vec.share_memory()
            • Time2Vec.state_dict()
            • Time2Vec.to()
            • Time2Vec.to_empty()
            • Time2Vec.train()
            • Time2Vec.type()
            • Time2Vec.xpu()
            • Time2Vec.zero_grad()
      • towhee.models.layers.transformer_encoder
        • towhee.models.layers.transformer_encoder.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.layers.vision_transformer_basic_head
        • towhee.models.layers.vision_transformer_basic_head.VisionTransformerBasicHead
          • VisionTransformerBasicHead
            • VisionTransformerBasicHead.__call__()
            • VisionTransformerBasicHead.__init__()
            • VisionTransformerBasicHead.__repr__()
            • VisionTransformerBasicHead.add_module()
            • VisionTransformerBasicHead.apply()
            • VisionTransformerBasicHead.bfloat16()
            • VisionTransformerBasicHead.buffers()
            • VisionTransformerBasicHead.children()
            • VisionTransformerBasicHead.cpu()
            • VisionTransformerBasicHead.cuda()
            • VisionTransformerBasicHead.double()
            • VisionTransformerBasicHead.eval()
            • VisionTransformerBasicHead.extra_repr()
            • VisionTransformerBasicHead.float()
            • VisionTransformerBasicHead.forward()
            • VisionTransformerBasicHead.get_buffer()
            • VisionTransformerBasicHead.get_extra_state()
            • VisionTransformerBasicHead.get_parameter()
            • VisionTransformerBasicHead.get_submodule()
            • VisionTransformerBasicHead.half()
            • VisionTransformerBasicHead.ipu()
            • VisionTransformerBasicHead.load_state_dict()
            • VisionTransformerBasicHead.modules()
            • VisionTransformerBasicHead.named_buffers()
            • VisionTransformerBasicHead.named_children()
            • VisionTransformerBasicHead.named_modules()
            • VisionTransformerBasicHead.named_parameters()
            • VisionTransformerBasicHead.parameters()
            • VisionTransformerBasicHead.register_backward_hook()
            • VisionTransformerBasicHead.register_buffer()
            • VisionTransformerBasicHead.register_forward_hook()
            • VisionTransformerBasicHead.register_forward_pre_hook()
            • VisionTransformerBasicHead.register_full_backward_hook()
            • VisionTransformerBasicHead.register_full_backward_pre_hook()
            • VisionTransformerBasicHead.register_load_state_dict_post_hook()
            • VisionTransformerBasicHead.register_module()
            • VisionTransformerBasicHead.register_parameter()
            • VisionTransformerBasicHead.register_state_dict_pre_hook()
            • VisionTransformerBasicHead.requires_grad_()
            • VisionTransformerBasicHead.set_extra_state()
            • VisionTransformerBasicHead.share_memory()
            • VisionTransformerBasicHead.state_dict()
            • VisionTransformerBasicHead.to()
            • VisionTransformerBasicHead.to_empty()
            • VisionTransformerBasicHead.train()
            • VisionTransformerBasicHead.type()
            • VisionTransformerBasicHead.xpu()
            • VisionTransformerBasicHead.zero_grad()
      • towhee.models.layers.window_attention
        • towhee.models.layers.window_attention.WindowAttention
          • WindowAttention
            • WindowAttention.__call__()
            • WindowAttention.__init__()
            • WindowAttention.__repr__()
            • WindowAttention.add_module()
            • WindowAttention.apply()
            • WindowAttention.bfloat16()
            • WindowAttention.buffers()
            • WindowAttention.children()
            • WindowAttention.cpu()
            • WindowAttention.cuda()
            • WindowAttention.double()
            • WindowAttention.eval()
            • WindowAttention.extra_repr()
            • WindowAttention.float()
            • WindowAttention.forward()
            • WindowAttention.get_buffer()
            • WindowAttention.get_extra_state()
            • WindowAttention.get_parameter()
            • WindowAttention.get_submodule()
            • WindowAttention.half()
            • WindowAttention.ipu()
            • WindowAttention.load_state_dict()
            • WindowAttention.modules()
            • WindowAttention.named_buffers()
            • WindowAttention.named_children()
            • WindowAttention.named_modules()
            • WindowAttention.named_parameters()
            • WindowAttention.parameters()
            • WindowAttention.register_backward_hook()
            • WindowAttention.register_buffer()
            • WindowAttention.register_forward_hook()
            • WindowAttention.register_forward_pre_hook()
            • WindowAttention.register_full_backward_hook()
            • WindowAttention.register_full_backward_pre_hook()
            • WindowAttention.register_load_state_dict_post_hook()
            • WindowAttention.register_module()
            • WindowAttention.register_parameter()
            • WindowAttention.register_state_dict_pre_hook()
            • WindowAttention.requires_grad_()
            • WindowAttention.set_extra_state()
            • WindowAttention.share_memory()
            • WindowAttention.state_dict()
            • WindowAttention.to()
            • WindowAttention.to_empty()
            • WindowAttention.train()
            • WindowAttention.type()
            • WindowAttention.xpu()
            • WindowAttention.zero_grad()
      • towhee.models.layers.window_attention3d
        • towhee.models.layers.window_attention3d.WindowAttention3D
          • WindowAttention3D
            • WindowAttention3D.__call__()
            • WindowAttention3D.__init__()
            • WindowAttention3D.__repr__()
            • WindowAttention3D.add_module()
            • WindowAttention3D.apply()
            • WindowAttention3D.bfloat16()
            • WindowAttention3D.buffers()
            • WindowAttention3D.children()
            • WindowAttention3D.cpu()
            • WindowAttention3D.cuda()
            • WindowAttention3D.double()
            • WindowAttention3D.eval()
            • WindowAttention3D.extra_repr()
            • WindowAttention3D.float()
            • WindowAttention3D.forward()
            • WindowAttention3D.get_buffer()
            • WindowAttention3D.get_extra_state()
            • WindowAttention3D.get_parameter()
            • WindowAttention3D.get_submodule()
            • WindowAttention3D.half()
            • WindowAttention3D.ipu()
            • WindowAttention3D.load_state_dict()
            • WindowAttention3D.modules()
            • WindowAttention3D.named_buffers()
            • WindowAttention3D.named_children()
            • WindowAttention3D.named_modules()
            • WindowAttention3D.named_parameters()
            • WindowAttention3D.parameters()
            • WindowAttention3D.register_backward_hook()
            • WindowAttention3D.register_buffer()
            • WindowAttention3D.register_forward_hook()
            • WindowAttention3D.register_forward_pre_hook()
            • WindowAttention3D.register_full_backward_hook()
            • WindowAttention3D.register_full_backward_pre_hook()
            • WindowAttention3D.register_load_state_dict_post_hook()
            • WindowAttention3D.register_module()
            • WindowAttention3D.register_parameter()
            • WindowAttention3D.register_state_dict_pre_hook()
            • WindowAttention3D.requires_grad_()
            • WindowAttention3D.set_extra_state()
            • WindowAttention3D.share_memory()
            • WindowAttention3D.state_dict()
            • WindowAttention3D.to()
            • WindowAttention3D.to_empty()
            • WindowAttention3D.train()
            • WindowAttention3D.type()
            • WindowAttention3D.xpu()
            • WindowAttention3D.zero_grad()
    • towhee.models.lightning_dot
      • towhee.models.lightning_dot.bi_encoder
        • towhee.models.lightning_dot.bi_encoder.BiEncoder
          • BiEncoder
            • BiEncoder.__call__()
            • BiEncoder.__init__()
            • BiEncoder.__repr__()
            • BiEncoder.add_module()
            • BiEncoder.apply()
            • BiEncoder.bfloat16()
            • BiEncoder.buffers()
            • BiEncoder.children()
            • BiEncoder.cpu()
            • BiEncoder.cuda()
            • BiEncoder.double()
            • BiEncoder.eval()
            • BiEncoder.extra_repr()
            • BiEncoder.float()
            • BiEncoder.forward()
            • BiEncoder.get_buffer()
            • BiEncoder.get_extra_state()
            • BiEncoder.get_parameter()
            • BiEncoder.get_submodule()
            • BiEncoder.half()
            • BiEncoder.ipu()
            • BiEncoder.load_state_dict()
            • BiEncoder.modules()
            • BiEncoder.named_buffers()
            • BiEncoder.named_children()
            • BiEncoder.named_modules()
            • BiEncoder.named_parameters()
            • BiEncoder.parameters()
            • BiEncoder.register_backward_hook()
            • BiEncoder.register_buffer()
            • BiEncoder.register_forward_hook()
            • BiEncoder.register_forward_pre_hook()
            • BiEncoder.register_full_backward_hook()
            • BiEncoder.register_full_backward_pre_hook()
            • BiEncoder.register_load_state_dict_post_hook()
            • BiEncoder.register_module()
            • BiEncoder.register_parameter()
            • BiEncoder.register_state_dict_pre_hook()
            • BiEncoder.requires_grad_()
            • BiEncoder.set_extra_state()
            • BiEncoder.share_memory()
            • BiEncoder.state_dict()
            • BiEncoder.to()
            • BiEncoder.to_empty()
            • BiEncoder.train()
            • BiEncoder.type()
            • BiEncoder.xpu()
            • BiEncoder.zero_grad()
    • towhee.models.loss
      • towhee.models.loss.focal_loss
        • towhee.models.loss.focal_loss.FocalLoss
          • FocalLoss
            • FocalLoss.__call__()
            • FocalLoss.__init__()
            • FocalLoss.__repr__()
            • FocalLoss.add_module()
            • FocalLoss.apply()
            • FocalLoss.bfloat16()
            • FocalLoss.buffers()
            • FocalLoss.children()
            • FocalLoss.cpu()
            • FocalLoss.cuda()
            • FocalLoss.double()
            • FocalLoss.eval()
            • FocalLoss.extra_repr()
            • FocalLoss.float()
            • FocalLoss.forward()
            • FocalLoss.get_buffer()
            • FocalLoss.get_extra_state()
            • FocalLoss.get_parameter()
            • FocalLoss.get_submodule()
            • FocalLoss.half()
            • FocalLoss.ipu()
            • FocalLoss.load_state_dict()
            • FocalLoss.modules()
            • FocalLoss.named_buffers()
            • FocalLoss.named_children()
            • FocalLoss.named_modules()
            • FocalLoss.named_parameters()
            • FocalLoss.parameters()
            • FocalLoss.register_backward_hook()
            • FocalLoss.register_buffer()
            • FocalLoss.register_forward_hook()
            • FocalLoss.register_forward_pre_hook()
            • FocalLoss.register_full_backward_hook()
            • FocalLoss.register_full_backward_pre_hook()
            • FocalLoss.register_load_state_dict_post_hook()
            • FocalLoss.register_module()
            • FocalLoss.register_parameter()
            • FocalLoss.register_state_dict_pre_hook()
            • FocalLoss.requires_grad_()
            • FocalLoss.set_extra_state()
            • FocalLoss.share_memory()
            • FocalLoss.state_dict()
            • FocalLoss.to()
            • FocalLoss.to_empty()
            • FocalLoss.train()
            • FocalLoss.type()
            • FocalLoss.xpu()
            • FocalLoss.zero_grad()
    • towhee.models.mdmmt
      • towhee.models.mdmmt.bert_mmt
        • towhee.models.mdmmt.bert_mmt.BertAttention
          • BertAttention
            • BertAttention.__call__()
            • BertAttention.__init__()
            • BertAttention.__repr__()
            • BertAttention.add_module()
            • BertAttention.apply()
            • BertAttention.bfloat16()
            • BertAttention.buffers()
            • BertAttention.children()
            • BertAttention.cpu()
            • BertAttention.cuda()
            • BertAttention.double()
            • BertAttention.eval()
            • BertAttention.extra_repr()
            • BertAttention.float()
            • BertAttention.forward()
            • BertAttention.get_buffer()
            • BertAttention.get_extra_state()
            • BertAttention.get_parameter()
            • BertAttention.get_submodule()
            • BertAttention.half()
            • BertAttention.ipu()
            • BertAttention.load_state_dict()
            • BertAttention.modules()
            • BertAttention.named_buffers()
            • BertAttention.named_children()
            • BertAttention.named_modules()
            • BertAttention.named_parameters()
            • BertAttention.parameters()
            • BertAttention.register_backward_hook()
            • BertAttention.register_buffer()
            • BertAttention.register_forward_hook()
            • BertAttention.register_forward_pre_hook()
            • BertAttention.register_full_backward_hook()
            • BertAttention.register_full_backward_pre_hook()
            • BertAttention.register_load_state_dict_post_hook()
            • BertAttention.register_module()
            • BertAttention.register_parameter()
            • BertAttention.register_state_dict_pre_hook()
            • BertAttention.requires_grad_()
            • BertAttention.set_extra_state()
            • BertAttention.share_memory()
            • BertAttention.state_dict()
            • BertAttention.to()
            • BertAttention.to_empty()
            • BertAttention.train()
            • BertAttention.type()
            • BertAttention.xpu()
            • BertAttention.zero_grad()
        • towhee.models.mdmmt.bert_mmt.BertEmbeddings
          • BertEmbeddings
            • BertEmbeddings.__call__()
            • BertEmbeddings.__init__()
            • BertEmbeddings.__repr__()
            • BertEmbeddings.add_module()
            • BertEmbeddings.apply()
            • BertEmbeddings.bfloat16()
            • BertEmbeddings.buffers()
            • BertEmbeddings.children()
            • BertEmbeddings.cpu()
            • BertEmbeddings.cuda()
            • BertEmbeddings.double()
            • BertEmbeddings.eval()
            • BertEmbeddings.extra_repr()
            • BertEmbeddings.float()
            • BertEmbeddings.forward()
            • BertEmbeddings.get_buffer()
            • BertEmbeddings.get_extra_state()
            • BertEmbeddings.get_parameter()
            • BertEmbeddings.get_submodule()
            • BertEmbeddings.half()
            • BertEmbeddings.ipu()
            • BertEmbeddings.load_state_dict()
            • BertEmbeddings.modules()
            • BertEmbeddings.named_buffers()
            • BertEmbeddings.named_children()
            • BertEmbeddings.named_modules()
            • BertEmbeddings.named_parameters()
            • BertEmbeddings.parameters()
            • BertEmbeddings.register_backward_hook()
            • BertEmbeddings.register_buffer()
            • BertEmbeddings.register_forward_hook()
            • BertEmbeddings.register_forward_pre_hook()
            • BertEmbeddings.register_full_backward_hook()
            • BertEmbeddings.register_full_backward_pre_hook()
            • BertEmbeddings.register_load_state_dict_post_hook()
            • BertEmbeddings.register_module()
            • BertEmbeddings.register_parameter()
            • BertEmbeddings.register_state_dict_pre_hook()
            • BertEmbeddings.requires_grad_()
            • BertEmbeddings.set_extra_state()
            • BertEmbeddings.share_memory()
            • BertEmbeddings.state_dict()
            • BertEmbeddings.to()
            • BertEmbeddings.to_empty()
            • BertEmbeddings.train()
            • BertEmbeddings.type()
            • BertEmbeddings.xpu()
            • BertEmbeddings.zero_grad()
        • towhee.models.mdmmt.bert_mmt.BertEncoder
          • BertEncoder
            • BertEncoder.__call__()
            • BertEncoder.__init__()
            • BertEncoder.__repr__()
            • BertEncoder.add_module()
            • BertEncoder.apply()
            • BertEncoder.bfloat16()
            • BertEncoder.buffers()
            • BertEncoder.children()
            • BertEncoder.cpu()
            • BertEncoder.cuda()
            • BertEncoder.double()
            • BertEncoder.eval()
            • BertEncoder.extra_repr()
            • BertEncoder.float()
            • BertEncoder.forward()
            • BertEncoder.get_buffer()
            • BertEncoder.get_extra_state()
            • BertEncoder.get_parameter()
            • BertEncoder.get_submodule()
            • BertEncoder.half()
            • BertEncoder.ipu()
            • BertEncoder.load_state_dict()
            • BertEncoder.modules()
            • BertEncoder.named_buffers()
            • BertEncoder.named_children()
            • BertEncoder.named_modules()
            • BertEncoder.named_parameters()
            • BertEncoder.parameters()
            • BertEncoder.register_backward_hook()
            • BertEncoder.register_buffer()
            • BertEncoder.register_forward_hook()
            • BertEncoder.register_forward_pre_hook()
            • BertEncoder.register_full_backward_hook()
            • BertEncoder.register_full_backward_pre_hook()
            • BertEncoder.register_load_state_dict_post_hook()
            • BertEncoder.register_module()
            • BertEncoder.register_parameter()
            • BertEncoder.register_state_dict_pre_hook()
            • BertEncoder.requires_grad_()
            • BertEncoder.set_extra_state()
            • BertEncoder.share_memory()
            • BertEncoder.state_dict()
            • BertEncoder.to()
            • BertEncoder.to_empty()
            • BertEncoder.train()
            • BertEncoder.type()
            • BertEncoder.xpu()
            • BertEncoder.zero_grad()
        • towhee.models.mdmmt.bert_mmt.BertIntermediate
          • BertIntermediate
            • BertIntermediate.__call__()
            • BertIntermediate.__init__()
            • BertIntermediate.__repr__()
            • BertIntermediate.add_module()
            • BertIntermediate.apply()
            • BertIntermediate.bfloat16()
            • BertIntermediate.buffers()
            • BertIntermediate.children()
            • BertIntermediate.cpu()
            • BertIntermediate.cuda()
            • BertIntermediate.double()
            • BertIntermediate.eval()
            • BertIntermediate.extra_repr()
            • BertIntermediate.float()
            • BertIntermediate.forward()
            • BertIntermediate.get_buffer()
            • BertIntermediate.get_extra_state()
            • BertIntermediate.get_parameter()
            • BertIntermediate.get_submodule()
            • BertIntermediate.half()
            • BertIntermediate.ipu()
            • BertIntermediate.load_state_dict()
            • BertIntermediate.modules()
            • BertIntermediate.named_buffers()
            • BertIntermediate.named_children()
            • BertIntermediate.named_modules()
            • BertIntermediate.named_parameters()
            • BertIntermediate.parameters()
            • BertIntermediate.register_backward_hook()
            • BertIntermediate.register_buffer()
            • BertIntermediate.register_forward_hook()
            • BertIntermediate.register_forward_pre_hook()
            • BertIntermediate.register_full_backward_hook()
            • BertIntermediate.register_full_backward_pre_hook()
            • BertIntermediate.register_load_state_dict_post_hook()
            • BertIntermediate.register_module()
            • BertIntermediate.register_parameter()
            • BertIntermediate.register_state_dict_pre_hook()
            • BertIntermediate.requires_grad_()
            • BertIntermediate.set_extra_state()
            • BertIntermediate.share_memory()
            • BertIntermediate.state_dict()
            • BertIntermediate.to()
            • BertIntermediate.to_empty()
            • BertIntermediate.train()
            • BertIntermediate.type()
            • BertIntermediate.xpu()
            • BertIntermediate.zero_grad()
        • towhee.models.mdmmt.bert_mmt.BertLayer
          • BertLayer
            • BertLayer.__call__()
            • BertLayer.__init__()
            • BertLayer.__repr__()
            • BertLayer.add_module()
            • BertLayer.apply()
            • BertLayer.bfloat16()
            • BertLayer.buffers()
            • BertLayer.children()
            • BertLayer.cpu()
            • BertLayer.cuda()
            • BertLayer.double()
            • BertLayer.eval()
            • BertLayer.extra_repr()
            • BertLayer.float()
            • BertLayer.forward()
            • BertLayer.get_buffer()
            • BertLayer.get_extra_state()
            • BertLayer.get_parameter()
            • BertLayer.get_submodule()
            • BertLayer.half()
            • BertLayer.ipu()
            • BertLayer.load_state_dict()
            • BertLayer.modules()
            • BertLayer.named_buffers()
            • BertLayer.named_children()
            • BertLayer.named_modules()
            • BertLayer.named_parameters()
            • BertLayer.parameters()
            • BertLayer.register_backward_hook()
            • BertLayer.register_buffer()
            • BertLayer.register_forward_hook()
            • BertLayer.register_forward_pre_hook()
            • BertLayer.register_full_backward_hook()
            • BertLayer.register_full_backward_pre_hook()
            • BertLayer.register_load_state_dict_post_hook()
            • BertLayer.register_module()
            • BertLayer.register_parameter()
            • BertLayer.register_state_dict_pre_hook()
            • BertLayer.requires_grad_()
            • BertLayer.set_extra_state()
            • BertLayer.share_memory()
            • BertLayer.state_dict()
            • BertLayer.to()
            • BertLayer.to_empty()
            • BertLayer.train()
            • BertLayer.type()
            • BertLayer.xpu()
            • BertLayer.zero_grad()
        • towhee.models.mdmmt.bert_mmt.BertMMT
          • BertMMT
            • BertMMT.__call__()
            • BertMMT.__init__()
            • BertMMT.__repr__()
            • BertMMT.add_module()
            • BertMMT.apply()
            • BertMMT.bfloat16()
            • BertMMT.buffers()
            • BertMMT.children()
            • BertMMT.cpu()
            • BertMMT.cuda()
            • BertMMT.double()
            • BertMMT.eval()
            • BertMMT.extra_repr()
            • BertMMT.float()
            • BertMMT.forward()
            • BertMMT.get_buffer()
            • BertMMT.get_extra_state()
            • BertMMT.get_parameter()
            • BertMMT.get_submodule()
            • BertMMT.half()
            • BertMMT.ipu()
            • BertMMT.load_state_dict()
            • BertMMT.modules()
            • BertMMT.named_buffers()
            • BertMMT.named_children()
            • BertMMT.named_modules()
            • BertMMT.named_parameters()
            • BertMMT.parameters()
            • BertMMT.register_backward_hook()
            • BertMMT.register_buffer()
            • BertMMT.register_forward_hook()
            • BertMMT.register_forward_pre_hook()
            • BertMMT.register_full_backward_hook()
            • BertMMT.register_full_backward_pre_hook()
            • BertMMT.register_load_state_dict_post_hook()
            • BertMMT.register_module()
            • BertMMT.register_parameter()
            • BertMMT.register_state_dict_pre_hook()
            • BertMMT.requires_grad_()
            • BertMMT.set_extra_state()
            • BertMMT.share_memory()
            • BertMMT.state_dict()
            • BertMMT.to()
            • BertMMT.to_empty()
            • BertMMT.train()
            • BertMMT.type()
            • BertMMT.xpu()
            • BertMMT.zero_grad()
        • towhee.models.mdmmt.bert_mmt.BertOutput
          • BertOutput
            • BertOutput.__call__()
            • BertOutput.__init__()
            • BertOutput.__repr__()
            • BertOutput.add_module()
            • BertOutput.apply()
            • BertOutput.bfloat16()
            • BertOutput.buffers()
            • BertOutput.children()
            • BertOutput.cpu()
            • BertOutput.cuda()
            • BertOutput.double()
            • BertOutput.eval()
            • BertOutput.extra_repr()
            • BertOutput.float()
            • BertOutput.forward()
            • BertOutput.get_buffer()
            • BertOutput.get_extra_state()
            • BertOutput.get_parameter()
            • BertOutput.get_submodule()
            • BertOutput.half()
            • BertOutput.ipu()
            • BertOutput.load_state_dict()
            • BertOutput.modules()
            • BertOutput.named_buffers()
            • BertOutput.named_children()
            • BertOutput.named_modules()
            • BertOutput.named_parameters()
            • BertOutput.parameters()
            • BertOutput.register_backward_hook()
            • BertOutput.register_buffer()
            • BertOutput.register_forward_hook()
            • BertOutput.register_forward_pre_hook()
            • BertOutput.register_full_backward_hook()
            • BertOutput.register_full_backward_pre_hook()
            • BertOutput.register_load_state_dict_post_hook()
            • BertOutput.register_module()
            • BertOutput.register_parameter()
            • BertOutput.register_state_dict_pre_hook()
            • BertOutput.requires_grad_()
            • BertOutput.set_extra_state()
            • BertOutput.share_memory()
            • BertOutput.state_dict()
            • BertOutput.to()
            • BertOutput.to_empty()
            • BertOutput.train()
            • BertOutput.type()
            • BertOutput.xpu()
            • BertOutput.zero_grad()
        • towhee.models.mdmmt.bert_mmt.BertPooler
          • BertPooler
            • BertPooler.__call__()
            • BertPooler.__init__()
            • BertPooler.__repr__()
            • BertPooler.add_module()
            • BertPooler.apply()
            • BertPooler.bfloat16()
            • BertPooler.buffers()
            • BertPooler.children()
            • BertPooler.cpu()
            • BertPooler.cuda()
            • BertPooler.double()
            • BertPooler.eval()
            • BertPooler.extra_repr()
            • BertPooler.float()
            • BertPooler.forward()
            • BertPooler.get_buffer()
            • BertPooler.get_extra_state()
            • BertPooler.get_parameter()
            • BertPooler.get_submodule()
            • BertPooler.half()
            • BertPooler.ipu()
            • BertPooler.load_state_dict()
            • BertPooler.modules()
            • BertPooler.named_buffers()
            • BertPooler.named_children()
            • BertPooler.named_modules()
            • BertPooler.named_parameters()
            • BertPooler.parameters()
            • BertPooler.register_backward_hook()
            • BertPooler.register_buffer()
            • BertPooler.register_forward_hook()
            • BertPooler.register_forward_pre_hook()
            • BertPooler.register_full_backward_hook()
            • BertPooler.register_full_backward_pre_hook()
            • BertPooler.register_load_state_dict_post_hook()
            • BertPooler.register_module()
            • BertPooler.register_parameter()
            • BertPooler.register_state_dict_pre_hook()
            • BertPooler.requires_grad_()
            • BertPooler.set_extra_state()
            • BertPooler.share_memory()
            • BertPooler.state_dict()
            • BertPooler.to()
            • BertPooler.to_empty()
            • BertPooler.train()
            • BertPooler.type()
            • BertPooler.xpu()
            • BertPooler.zero_grad()
        • towhee.models.mdmmt.bert_mmt.BertSelfAttention
          • BertSelfAttention
            • BertSelfAttention.__call__()
            • BertSelfAttention.__init__()
            • BertSelfAttention.__repr__()
            • BertSelfAttention.add_module()
            • BertSelfAttention.apply()
            • BertSelfAttention.bfloat16()
            • BertSelfAttention.buffers()
            • BertSelfAttention.children()
            • BertSelfAttention.cpu()
            • BertSelfAttention.cuda()
            • BertSelfAttention.double()
            • BertSelfAttention.eval()
            • BertSelfAttention.extra_repr()
            • BertSelfAttention.float()
            • BertSelfAttention.forward()
            • BertSelfAttention.get_buffer()
            • BertSelfAttention.get_extra_state()
            • BertSelfAttention.get_parameter()
            • BertSelfAttention.get_submodule()
            • BertSelfAttention.half()
            • BertSelfAttention.ipu()
            • BertSelfAttention.load_state_dict()
            • BertSelfAttention.modules()
            • BertSelfAttention.named_buffers()
            • BertSelfAttention.named_children()
            • BertSelfAttention.named_modules()
            • BertSelfAttention.named_parameters()
            • BertSelfAttention.parameters()
            • BertSelfAttention.register_backward_hook()
            • BertSelfAttention.register_buffer()
            • BertSelfAttention.register_forward_hook()
            • BertSelfAttention.register_forward_pre_hook()
            • BertSelfAttention.register_full_backward_hook()
            • BertSelfAttention.register_full_backward_pre_hook()
            • BertSelfAttention.register_load_state_dict_post_hook()
            • BertSelfAttention.register_module()
            • BertSelfAttention.register_parameter()
            • BertSelfAttention.register_state_dict_pre_hook()
            • BertSelfAttention.requires_grad_()
            • BertSelfAttention.set_extra_state()
            • BertSelfAttention.share_memory()
            • BertSelfAttention.state_dict()
            • BertSelfAttention.to()
            • BertSelfAttention.to_empty()
            • BertSelfAttention.train()
            • BertSelfAttention.type()
            • BertSelfAttention.xpu()
            • BertSelfAttention.zero_grad()
        • towhee.models.mdmmt.bert_mmt.BertSelfOutput
          • BertSelfOutput
            • BertSelfOutput.__call__()
            • BertSelfOutput.__init__()
            • BertSelfOutput.__repr__()
            • BertSelfOutput.add_module()
            • BertSelfOutput.apply()
            • BertSelfOutput.bfloat16()
            • BertSelfOutput.buffers()
            • BertSelfOutput.children()
            • BertSelfOutput.cpu()
            • BertSelfOutput.cuda()
            • BertSelfOutput.double()
            • BertSelfOutput.eval()
            • BertSelfOutput.extra_repr()
            • BertSelfOutput.float()
            • BertSelfOutput.forward()
            • BertSelfOutput.get_buffer()
            • BertSelfOutput.get_extra_state()
            • BertSelfOutput.get_parameter()
            • BertSelfOutput.get_submodule()
            • BertSelfOutput.half()
            • BertSelfOutput.ipu()
            • BertSelfOutput.load_state_dict()
            • BertSelfOutput.modules()
            • BertSelfOutput.named_buffers()
            • BertSelfOutput.named_children()
            • BertSelfOutput.named_modules()
            • BertSelfOutput.named_parameters()
            • BertSelfOutput.parameters()
            • BertSelfOutput.register_backward_hook()
            • BertSelfOutput.register_buffer()
            • BertSelfOutput.register_forward_hook()
            • BertSelfOutput.register_forward_pre_hook()
            • BertSelfOutput.register_full_backward_hook()
            • BertSelfOutput.register_full_backward_pre_hook()
            • BertSelfOutput.register_load_state_dict_post_hook()
            • BertSelfOutput.register_module()
            • BertSelfOutput.register_parameter()
            • BertSelfOutput.register_state_dict_pre_hook()
            • BertSelfOutput.requires_grad_()
            • BertSelfOutput.set_extra_state()
            • BertSelfOutput.share_memory()
            • BertSelfOutput.state_dict()
            • BertSelfOutput.to()
            • BertSelfOutput.to_empty()
            • BertSelfOutput.train()
            • BertSelfOutput.type()
            • BertSelfOutput.xpu()
            • BertSelfOutput.zero_grad()
      • towhee.models.mdmmt.mmt
        • towhee.models.mdmmt.mmt.get_maxp
          • get_maxp()
        • towhee.models.mdmmt.mmt.pad
          • pad()
        • towhee.models.mdmmt.mmt.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.mdmmt.mmt.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.mdmmt.mmt.MMTTXT
          • MMTTXT
            • MMTTXT.__call__()
            • MMTTXT.__init__()
            • MMTTXT.__repr__()
            • MMTTXT.add_module()
            • MMTTXT.apply()
            • MMTTXT.bfloat16()
            • MMTTXT.buffers()
            • MMTTXT.children()
            • MMTTXT.cpu()
            • MMTTXT.cuda()
            • MMTTXT.double()
            • MMTTXT.eval()
            • MMTTXT.extra_repr()
            • MMTTXT.float()
            • MMTTXT.forward()
            • MMTTXT.get_buffer()
            • MMTTXT.get_extra_state()
            • MMTTXT.get_parameter()
            • MMTTXT.get_submodule()
            • MMTTXT.half()
            • MMTTXT.ipu()
            • MMTTXT.load_state_dict()
            • MMTTXT.modules()
            • MMTTXT.named_buffers()
            • MMTTXT.named_children()
            • MMTTXT.named_modules()
            • MMTTXT.named_parameters()
            • MMTTXT.parameters()
            • MMTTXT.register_backward_hook()
            • MMTTXT.register_buffer()
            • MMTTXT.register_forward_hook()
            • MMTTXT.register_forward_pre_hook()
            • MMTTXT.register_full_backward_hook()
            • MMTTXT.register_full_backward_pre_hook()
            • MMTTXT.register_load_state_dict_post_hook()
            • MMTTXT.register_module()
            • MMTTXT.register_parameter()
            • MMTTXT.register_state_dict_pre_hook()
            • MMTTXT.requires_grad_()
            • MMTTXT.set_extra_state()
            • MMTTXT.share_memory()
            • MMTTXT.state_dict()
            • MMTTXT.to()
            • MMTTXT.to_empty()
            • MMTTXT.train()
            • MMTTXT.type()
            • MMTTXT.xpu()
            • MMTTXT.zero_grad()
        • towhee.models.mdmmt.mmt.MMTVID
          • MMTVID
            • MMTVID.__call__()
            • MMTVID.__init__()
            • MMTVID.__repr__()
            • MMTVID.add_module()
            • MMTVID.apply()
            • MMTVID.bfloat16()
            • MMTVID.buffers()
            • MMTVID.children()
            • MMTVID.cpu()
            • MMTVID.cuda()
            • MMTVID.double()
            • MMTVID.eval()
            • MMTVID.extra_repr()
            • MMTVID.float()
            • MMTVID.forward()
            • MMTVID.get_buffer()
            • MMTVID.get_extra_state()
            • MMTVID.get_parameter()
            • MMTVID.get_submodule()
            • MMTVID.half()
            • MMTVID.ipu()
            • MMTVID.load_state_dict()
            • MMTVID.modules()
            • MMTVID.named_buffers()
            • MMTVID.named_children()
            • MMTVID.named_modules()
            • MMTVID.named_parameters()
            • MMTVID.parameters()
            • MMTVID.register_backward_hook()
            • MMTVID.register_buffer()
            • MMTVID.register_forward_hook()
            • MMTVID.register_forward_pre_hook()
            • MMTVID.register_full_backward_hook()
            • MMTVID.register_full_backward_pre_hook()
            • MMTVID.register_load_state_dict_post_hook()
            • MMTVID.register_module()
            • MMTVID.register_parameter()
            • MMTVID.register_state_dict_pre_hook()
            • MMTVID.requires_grad_()
            • MMTVID.set_extra_state()
            • MMTVID.share_memory()
            • MMTVID.state_dict()
            • MMTVID.to()
            • MMTVID.to_empty()
            • MMTVID.train()
            • MMTVID.type()
            • MMTVID.xpu()
            • MMTVID.zero_grad()
        • towhee.models.mdmmt.mmt.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.movinet
      • towhee.models.movinet.config
        • towhee.models.movinet.config.fill_conv
          • fill_conv()
        • towhee.models.movinet.config.fill_se_config
          • fill_se_config()
      • towhee.models.movinet.movinet
        • towhee.models.movinet.movinet.create_model
          • create_model()
        • towhee.models.movinet.movinet.MoViNet
          • MoViNet
            • MoViNet.__call__()
            • MoViNet.__init__()
            • MoViNet.__repr__()
            • MoViNet.add_module()
            • MoViNet.apply()
            • MoViNet.bfloat16()
            • MoViNet.buffers()
            • MoViNet.children()
            • MoViNet.cpu()
            • MoViNet.cuda()
            • MoViNet.double()
            • MoViNet.eval()
            • MoViNet.extra_repr()
            • MoViNet.float()
            • MoViNet.forward()
            • MoViNet.get_buffer()
            • MoViNet.get_extra_state()
            • MoViNet.get_parameter()
            • MoViNet.get_submodule()
            • MoViNet.half()
            • MoViNet.ipu()
            • MoViNet.load_state_dict()
            • MoViNet.modules()
            • MoViNet.named_buffers()
            • MoViNet.named_children()
            • MoViNet.named_modules()
            • MoViNet.named_parameters()
            • MoViNet.parameters()
            • MoViNet.register_backward_hook()
            • MoViNet.register_buffer()
            • MoViNet.register_forward_hook()
            • MoViNet.register_forward_pre_hook()
            • MoViNet.register_full_backward_hook()
            • MoViNet.register_full_backward_pre_hook()
            • MoViNet.register_load_state_dict_post_hook()
            • MoViNet.register_module()
            • MoViNet.register_parameter()
            • MoViNet.register_state_dict_pre_hook()
            • MoViNet.requires_grad_()
            • MoViNet.set_extra_state()
            • MoViNet.share_memory()
            • MoViNet.state_dict()
            • MoViNet.to()
            • MoViNet.to_empty()
            • MoViNet.train()
            • MoViNet.type()
            • MoViNet.xpu()
            • MoViNet.zero_grad()
      • towhee.models.movinet.movinet_block
        • towhee.models.movinet.movinet_block.BasicBneck
          • BasicBneck
            • BasicBneck.__call__()
            • BasicBneck.__init__()
            • BasicBneck.__repr__()
            • BasicBneck.add_module()
            • BasicBneck.apply()
            • BasicBneck.bfloat16()
            • BasicBneck.buffers()
            • BasicBneck.children()
            • BasicBneck.cpu()
            • BasicBneck.cuda()
            • BasicBneck.double()
            • BasicBneck.eval()
            • BasicBneck.extra_repr()
            • BasicBneck.float()
            • BasicBneck.forward()
            • BasicBneck.get_buffer()
            • BasicBneck.get_extra_state()
            • BasicBneck.get_parameter()
            • BasicBneck.get_submodule()
            • BasicBneck.half()
            • BasicBneck.ipu()
            • BasicBneck.load_state_dict()
            • BasicBneck.modules()
            • BasicBneck.named_buffers()
            • BasicBneck.named_children()
            • BasicBneck.named_modules()
            • BasicBneck.named_parameters()
            • BasicBneck.parameters()
            • BasicBneck.register_backward_hook()
            • BasicBneck.register_buffer()
            • BasicBneck.register_forward_hook()
            • BasicBneck.register_forward_pre_hook()
            • BasicBneck.register_full_backward_hook()
            • BasicBneck.register_full_backward_pre_hook()
            • BasicBneck.register_load_state_dict_post_hook()
            • BasicBneck.register_module()
            • BasicBneck.register_parameter()
            • BasicBneck.register_state_dict_pre_hook()
            • BasicBneck.requires_grad_()
            • BasicBneck.set_extra_state()
            • BasicBneck.share_memory()
            • BasicBneck.state_dict()
            • BasicBneck.to()
            • BasicBneck.to_empty()
            • BasicBneck.train()
            • BasicBneck.type()
            • BasicBneck.xpu()
            • BasicBneck.zero_grad()
        • towhee.models.movinet.movinet_block.ConvBlock3D
          • ConvBlock3D
            • ConvBlock3D.__call__()
            • ConvBlock3D.__init__()
            • ConvBlock3D.__repr__()
            • ConvBlock3D.add_module()
            • ConvBlock3D.apply()
            • ConvBlock3D.bfloat16()
            • ConvBlock3D.buffers()
            • ConvBlock3D.children()
            • ConvBlock3D.cpu()
            • ConvBlock3D.cuda()
            • ConvBlock3D.double()
            • ConvBlock3D.eval()
            • ConvBlock3D.extra_repr()
            • ConvBlock3D.float()
            • ConvBlock3D.forward()
            • ConvBlock3D.get_buffer()
            • ConvBlock3D.get_extra_state()
            • ConvBlock3D.get_parameter()
            • ConvBlock3D.get_submodule()
            • ConvBlock3D.half()
            • ConvBlock3D.ipu()
            • ConvBlock3D.load_state_dict()
            • ConvBlock3D.modules()
            • ConvBlock3D.named_buffers()
            • ConvBlock3D.named_children()
            • ConvBlock3D.named_modules()
            • ConvBlock3D.named_parameters()
            • ConvBlock3D.parameters()
            • ConvBlock3D.register_backward_hook()
            • ConvBlock3D.register_buffer()
            • ConvBlock3D.register_forward_hook()
            • ConvBlock3D.register_forward_pre_hook()
            • ConvBlock3D.register_full_backward_hook()
            • ConvBlock3D.register_full_backward_pre_hook()
            • ConvBlock3D.register_load_state_dict_post_hook()
            • ConvBlock3D.register_module()
            • ConvBlock3D.register_parameter()
            • ConvBlock3D.register_state_dict_pre_hook()
            • ConvBlock3D.requires_grad_()
            • ConvBlock3D.set_extra_state()
            • ConvBlock3D.share_memory()
            • ConvBlock3D.state_dict()
            • ConvBlock3D.to()
            • ConvBlock3D.to_empty()
            • ConvBlock3D.train()
            • ConvBlock3D.type()
            • ConvBlock3D.xpu()
            • ConvBlock3D.zero_grad()
        • towhee.models.movinet.movinet_block.SqueezeExcitation
          • SqueezeExcitation
            • SqueezeExcitation.__call__()
            • SqueezeExcitation.__init__()
            • SqueezeExcitation.__repr__()
            • SqueezeExcitation.add_module()
            • SqueezeExcitation.apply()
            • SqueezeExcitation.bfloat16()
            • SqueezeExcitation.buffers()
            • SqueezeExcitation.children()
            • SqueezeExcitation.cpu()
            • SqueezeExcitation.cuda()
            • SqueezeExcitation.double()
            • SqueezeExcitation.eval()
            • SqueezeExcitation.extra_repr()
            • SqueezeExcitation.float()
            • SqueezeExcitation.forward()
            • SqueezeExcitation.get_buffer()
            • SqueezeExcitation.get_extra_state()
            • SqueezeExcitation.get_parameter()
            • SqueezeExcitation.get_submodule()
            • SqueezeExcitation.half()
            • SqueezeExcitation.ipu()
            • SqueezeExcitation.load_state_dict()
            • SqueezeExcitation.modules()
            • SqueezeExcitation.named_buffers()
            • SqueezeExcitation.named_children()
            • SqueezeExcitation.named_modules()
            • SqueezeExcitation.named_parameters()
            • SqueezeExcitation.parameters()
            • SqueezeExcitation.register_backward_hook()
            • SqueezeExcitation.register_buffer()
            • SqueezeExcitation.register_forward_hook()
            • SqueezeExcitation.register_forward_pre_hook()
            • SqueezeExcitation.register_full_backward_hook()
            • SqueezeExcitation.register_full_backward_pre_hook()
            • SqueezeExcitation.register_load_state_dict_post_hook()
            • SqueezeExcitation.register_module()
            • SqueezeExcitation.register_parameter()
            • SqueezeExcitation.register_state_dict_pre_hook()
            • SqueezeExcitation.requires_grad_()
            • SqueezeExcitation.set_extra_state()
            • SqueezeExcitation.share_memory()
            • SqueezeExcitation.state_dict()
            • SqueezeExcitation.to()
            • SqueezeExcitation.to_empty()
            • SqueezeExcitation.train()
            • SqueezeExcitation.type()
            • SqueezeExcitation.xpu()
            • SqueezeExcitation.zero_grad()
    • towhee.models.mpvit
      • towhee.models.mpvit.mpvit
        • towhee.models.mpvit.mpvit.create_model
          • create_model()
        • towhee.models.mpvit.mpvit.dpr_generator
          • dpr_generator()
        • towhee.models.mpvit.mpvit.mpvit_base
          • mpvit_base()
        • towhee.models.mpvit.mpvit.mpvit_small
          • mpvit_small()
        • towhee.models.mpvit.mpvit.mpvit_tiny
          • mpvit_tiny()
        • towhee.models.mpvit.mpvit.mpvit_xsmall
          • mpvit_xsmall()
        • towhee.models.mpvit.mpvit.ClsHead
          • ClsHead
            • ClsHead.__call__()
            • ClsHead.__init__()
            • ClsHead.__repr__()
            • ClsHead.add_module()
            • ClsHead.apply()
            • ClsHead.bfloat16()
            • ClsHead.buffers()
            • ClsHead.children()
            • ClsHead.cpu()
            • ClsHead.cuda()
            • ClsHead.double()
            • ClsHead.eval()
            • ClsHead.extra_repr()
            • ClsHead.float()
            • ClsHead.forward()
            • ClsHead.get_buffer()
            • ClsHead.get_extra_state()
            • ClsHead.get_parameter()
            • ClsHead.get_submodule()
            • ClsHead.half()
            • ClsHead.ipu()
            • ClsHead.load_state_dict()
            • ClsHead.modules()
            • ClsHead.named_buffers()
            • ClsHead.named_children()
            • ClsHead.named_modules()
            • ClsHead.named_parameters()
            • ClsHead.parameters()
            • ClsHead.register_backward_hook()
            • ClsHead.register_buffer()
            • ClsHead.register_forward_hook()
            • ClsHead.register_forward_pre_hook()
            • ClsHead.register_full_backward_hook()
            • ClsHead.register_full_backward_pre_hook()
            • ClsHead.register_load_state_dict_post_hook()
            • ClsHead.register_module()
            • ClsHead.register_parameter()
            • ClsHead.register_state_dict_pre_hook()
            • ClsHead.requires_grad_()
            • ClsHead.set_extra_state()
            • ClsHead.share_memory()
            • ClsHead.state_dict()
            • ClsHead.to()
            • ClsHead.to_empty()
            • ClsHead.train()
            • ClsHead.type()
            • ClsHead.xpu()
            • ClsHead.zero_grad()
        • towhee.models.mpvit.mpvit.Conv2dBN
          • Conv2dBN
            • Conv2dBN.__call__()
            • Conv2dBN.__init__()
            • Conv2dBN.__repr__()
            • Conv2dBN.add_module()
            • Conv2dBN.apply()
            • Conv2dBN.bfloat16()
            • Conv2dBN.buffers()
            • Conv2dBN.children()
            • Conv2dBN.cpu()
            • Conv2dBN.cuda()
            • Conv2dBN.double()
            • Conv2dBN.eval()
            • Conv2dBN.extra_repr()
            • Conv2dBN.float()
            • Conv2dBN.forward()
            • Conv2dBN.get_buffer()
            • Conv2dBN.get_extra_state()
            • Conv2dBN.get_parameter()
            • Conv2dBN.get_submodule()
            • Conv2dBN.half()
            • Conv2dBN.ipu()
            • Conv2dBN.load_state_dict()
            • Conv2dBN.modules()
            • Conv2dBN.named_buffers()
            • Conv2dBN.named_children()
            • Conv2dBN.named_modules()
            • Conv2dBN.named_parameters()
            • Conv2dBN.parameters()
            • Conv2dBN.register_backward_hook()
            • Conv2dBN.register_buffer()
            • Conv2dBN.register_forward_hook()
            • Conv2dBN.register_forward_pre_hook()
            • Conv2dBN.register_full_backward_hook()
            • Conv2dBN.register_full_backward_pre_hook()
            • Conv2dBN.register_load_state_dict_post_hook()
            • Conv2dBN.register_module()
            • Conv2dBN.register_parameter()
            • Conv2dBN.register_state_dict_pre_hook()
            • Conv2dBN.requires_grad_()
            • Conv2dBN.set_extra_state()
            • Conv2dBN.share_memory()
            • Conv2dBN.state_dict()
            • Conv2dBN.to()
            • Conv2dBN.to_empty()
            • Conv2dBN.train()
            • Conv2dBN.type()
            • Conv2dBN.xpu()
            • Conv2dBN.zero_grad()
        • towhee.models.mpvit.mpvit.ConvPosEnc
          • ConvPosEnc
            • ConvPosEnc.__call__()
            • ConvPosEnc.__init__()
            • ConvPosEnc.__repr__()
            • ConvPosEnc.add_module()
            • ConvPosEnc.apply()
            • ConvPosEnc.bfloat16()
            • ConvPosEnc.buffers()
            • ConvPosEnc.children()
            • ConvPosEnc.cpu()
            • ConvPosEnc.cuda()
            • ConvPosEnc.double()
            • ConvPosEnc.eval()
            • ConvPosEnc.extra_repr()
            • ConvPosEnc.float()
            • ConvPosEnc.forward()
            • ConvPosEnc.get_buffer()
            • ConvPosEnc.get_extra_state()
            • ConvPosEnc.get_parameter()
            • ConvPosEnc.get_submodule()
            • ConvPosEnc.half()
            • ConvPosEnc.ipu()
            • ConvPosEnc.load_state_dict()
            • ConvPosEnc.modules()
            • ConvPosEnc.named_buffers()
            • ConvPosEnc.named_children()
            • ConvPosEnc.named_modules()
            • ConvPosEnc.named_parameters()
            • ConvPosEnc.parameters()
            • ConvPosEnc.register_backward_hook()
            • ConvPosEnc.register_buffer()
            • ConvPosEnc.register_forward_hook()
            • ConvPosEnc.register_forward_pre_hook()
            • ConvPosEnc.register_full_backward_hook()
            • ConvPosEnc.register_full_backward_pre_hook()
            • ConvPosEnc.register_load_state_dict_post_hook()
            • ConvPosEnc.register_module()
            • ConvPosEnc.register_parameter()
            • ConvPosEnc.register_state_dict_pre_hook()
            • ConvPosEnc.requires_grad_()
            • ConvPosEnc.set_extra_state()
            • ConvPosEnc.share_memory()
            • ConvPosEnc.state_dict()
            • ConvPosEnc.to()
            • ConvPosEnc.to_empty()
            • ConvPosEnc.train()
            • ConvPosEnc.type()
            • ConvPosEnc.xpu()
            • ConvPosEnc.zero_grad()
        • towhee.models.mpvit.mpvit.ConvRelPosEnc
          • ConvRelPosEnc
            • ConvRelPosEnc.__call__()
            • ConvRelPosEnc.__init__()
            • ConvRelPosEnc.__repr__()
            • ConvRelPosEnc.add_module()
            • ConvRelPosEnc.apply()
            • ConvRelPosEnc.bfloat16()
            • ConvRelPosEnc.buffers()
            • ConvRelPosEnc.children()
            • ConvRelPosEnc.cpu()
            • ConvRelPosEnc.cuda()
            • ConvRelPosEnc.double()
            • ConvRelPosEnc.eval()
            • ConvRelPosEnc.extra_repr()
            • ConvRelPosEnc.float()
            • ConvRelPosEnc.forward()
            • ConvRelPosEnc.get_buffer()
            • ConvRelPosEnc.get_extra_state()
            • ConvRelPosEnc.get_parameter()
            • ConvRelPosEnc.get_submodule()
            • ConvRelPosEnc.half()
            • ConvRelPosEnc.ipu()
            • ConvRelPosEnc.load_state_dict()
            • ConvRelPosEnc.modules()
            • ConvRelPosEnc.named_buffers()
            • ConvRelPosEnc.named_children()
            • ConvRelPosEnc.named_modules()
            • ConvRelPosEnc.named_parameters()
            • ConvRelPosEnc.parameters()
            • ConvRelPosEnc.register_backward_hook()
            • ConvRelPosEnc.register_buffer()
            • ConvRelPosEnc.register_forward_hook()
            • ConvRelPosEnc.register_forward_pre_hook()
            • ConvRelPosEnc.register_full_backward_hook()
            • ConvRelPosEnc.register_full_backward_pre_hook()
            • ConvRelPosEnc.register_load_state_dict_post_hook()
            • ConvRelPosEnc.register_module()
            • ConvRelPosEnc.register_parameter()
            • ConvRelPosEnc.register_state_dict_pre_hook()
            • ConvRelPosEnc.requires_grad_()
            • ConvRelPosEnc.set_extra_state()
            • ConvRelPosEnc.share_memory()
            • ConvRelPosEnc.state_dict()
            • ConvRelPosEnc.to()
            • ConvRelPosEnc.to_empty()
            • ConvRelPosEnc.train()
            • ConvRelPosEnc.type()
            • ConvRelPosEnc.xpu()
            • ConvRelPosEnc.zero_grad()
        • towhee.models.mpvit.mpvit.DWCPatchEmbed
          • DWCPatchEmbed
            • DWCPatchEmbed.__call__()
            • DWCPatchEmbed.__init__()
            • DWCPatchEmbed.__repr__()
            • DWCPatchEmbed.add_module()
            • DWCPatchEmbed.apply()
            • DWCPatchEmbed.bfloat16()
            • DWCPatchEmbed.buffers()
            • DWCPatchEmbed.children()
            • DWCPatchEmbed.cpu()
            • DWCPatchEmbed.cuda()
            • DWCPatchEmbed.double()
            • DWCPatchEmbed.eval()
            • DWCPatchEmbed.extra_repr()
            • DWCPatchEmbed.float()
            • DWCPatchEmbed.forward()
            • DWCPatchEmbed.get_buffer()
            • DWCPatchEmbed.get_extra_state()
            • DWCPatchEmbed.get_parameter()
            • DWCPatchEmbed.get_submodule()
            • DWCPatchEmbed.half()
            • DWCPatchEmbed.ipu()
            • DWCPatchEmbed.load_state_dict()
            • DWCPatchEmbed.modules()
            • DWCPatchEmbed.named_buffers()
            • DWCPatchEmbed.named_children()
            • DWCPatchEmbed.named_modules()
            • DWCPatchEmbed.named_parameters()
            • DWCPatchEmbed.parameters()
            • DWCPatchEmbed.register_backward_hook()
            • DWCPatchEmbed.register_buffer()
            • DWCPatchEmbed.register_forward_hook()
            • DWCPatchEmbed.register_forward_pre_hook()
            • DWCPatchEmbed.register_full_backward_hook()
            • DWCPatchEmbed.register_full_backward_pre_hook()
            • DWCPatchEmbed.register_load_state_dict_post_hook()
            • DWCPatchEmbed.register_module()
            • DWCPatchEmbed.register_parameter()
            • DWCPatchEmbed.register_state_dict_pre_hook()
            • DWCPatchEmbed.requires_grad_()
            • DWCPatchEmbed.set_extra_state()
            • DWCPatchEmbed.share_memory()
            • DWCPatchEmbed.state_dict()
            • DWCPatchEmbed.to()
            • DWCPatchEmbed.to_empty()
            • DWCPatchEmbed.train()
            • DWCPatchEmbed.type()
            • DWCPatchEmbed.xpu()
            • DWCPatchEmbed.zero_grad()
        • towhee.models.mpvit.mpvit.DWConv2dBN
          • DWConv2dBN
            • DWConv2dBN.__call__()
            • DWConv2dBN.__init__()
            • DWConv2dBN.__repr__()
            • DWConv2dBN.add_module()
            • DWConv2dBN.apply()
            • DWConv2dBN.bfloat16()
            • DWConv2dBN.buffers()
            • DWConv2dBN.children()
            • DWConv2dBN.cpu()
            • DWConv2dBN.cuda()
            • DWConv2dBN.double()
            • DWConv2dBN.eval()
            • DWConv2dBN.extra_repr()
            • DWConv2dBN.float()
            • DWConv2dBN.forward()
            • DWConv2dBN.get_buffer()
            • DWConv2dBN.get_extra_state()
            • DWConv2dBN.get_parameter()
            • DWConv2dBN.get_submodule()
            • DWConv2dBN.half()
            • DWConv2dBN.ipu()
            • DWConv2dBN.load_state_dict()
            • DWConv2dBN.modules()
            • DWConv2dBN.named_buffers()
            • DWConv2dBN.named_children()
            • DWConv2dBN.named_modules()
            • DWConv2dBN.named_parameters()
            • DWConv2dBN.parameters()
            • DWConv2dBN.register_backward_hook()
            • DWConv2dBN.register_buffer()
            • DWConv2dBN.register_forward_hook()
            • DWConv2dBN.register_forward_pre_hook()
            • DWConv2dBN.register_full_backward_hook()
            • DWConv2dBN.register_full_backward_pre_hook()
            • DWConv2dBN.register_load_state_dict_post_hook()
            • DWConv2dBN.register_module()
            • DWConv2dBN.register_parameter()
            • DWConv2dBN.register_state_dict_pre_hook()
            • DWConv2dBN.requires_grad_()
            • DWConv2dBN.set_extra_state()
            • DWConv2dBN.share_memory()
            • DWConv2dBN.state_dict()
            • DWConv2dBN.to()
            • DWConv2dBN.to_empty()
            • DWConv2dBN.train()
            • DWConv2dBN.type()
            • DWConv2dBN.xpu()
            • DWConv2dBN.zero_grad()
        • towhee.models.mpvit.mpvit.FactorAttConvRelPosEnc
          • FactorAttConvRelPosEnc
            • FactorAttConvRelPosEnc.__call__()
            • FactorAttConvRelPosEnc.__init__()
            • FactorAttConvRelPosEnc.__repr__()
            • FactorAttConvRelPosEnc.add_module()
            • FactorAttConvRelPosEnc.apply()
            • FactorAttConvRelPosEnc.bfloat16()
            • FactorAttConvRelPosEnc.buffers()
            • FactorAttConvRelPosEnc.children()
            • FactorAttConvRelPosEnc.cpu()
            • FactorAttConvRelPosEnc.cuda()
            • FactorAttConvRelPosEnc.double()
            • FactorAttConvRelPosEnc.eval()
            • FactorAttConvRelPosEnc.extra_repr()
            • FactorAttConvRelPosEnc.float()
            • FactorAttConvRelPosEnc.forward()
            • FactorAttConvRelPosEnc.get_buffer()
            • FactorAttConvRelPosEnc.get_extra_state()
            • FactorAttConvRelPosEnc.get_parameter()
            • FactorAttConvRelPosEnc.get_submodule()
            • FactorAttConvRelPosEnc.half()
            • FactorAttConvRelPosEnc.ipu()
            • FactorAttConvRelPosEnc.load_state_dict()
            • FactorAttConvRelPosEnc.modules()
            • FactorAttConvRelPosEnc.named_buffers()
            • FactorAttConvRelPosEnc.named_children()
            • FactorAttConvRelPosEnc.named_modules()
            • FactorAttConvRelPosEnc.named_parameters()
            • FactorAttConvRelPosEnc.parameters()
            • FactorAttConvRelPosEnc.register_backward_hook()
            • FactorAttConvRelPosEnc.register_buffer()
            • FactorAttConvRelPosEnc.register_forward_hook()
            • FactorAttConvRelPosEnc.register_forward_pre_hook()
            • FactorAttConvRelPosEnc.register_full_backward_hook()
            • FactorAttConvRelPosEnc.register_full_backward_pre_hook()
            • FactorAttConvRelPosEnc.register_load_state_dict_post_hook()
            • FactorAttConvRelPosEnc.register_module()
            • FactorAttConvRelPosEnc.register_parameter()
            • FactorAttConvRelPosEnc.register_state_dict_pre_hook()
            • FactorAttConvRelPosEnc.requires_grad_()
            • FactorAttConvRelPosEnc.set_extra_state()
            • FactorAttConvRelPosEnc.share_memory()
            • FactorAttConvRelPosEnc.state_dict()
            • FactorAttConvRelPosEnc.to()
            • FactorAttConvRelPosEnc.to_empty()
            • FactorAttConvRelPosEnc.train()
            • FactorAttConvRelPosEnc.type()
            • FactorAttConvRelPosEnc.xpu()
            • FactorAttConvRelPosEnc.zero_grad()
        • towhee.models.mpvit.mpvit.MHCABlock
          • MHCABlock
            • MHCABlock.__call__()
            • MHCABlock.__init__()
            • MHCABlock.__repr__()
            • MHCABlock.add_module()
            • MHCABlock.apply()
            • MHCABlock.bfloat16()
            • MHCABlock.buffers()
            • MHCABlock.children()
            • MHCABlock.cpu()
            • MHCABlock.cuda()
            • MHCABlock.double()
            • MHCABlock.eval()
            • MHCABlock.extra_repr()
            • MHCABlock.float()
            • MHCABlock.forward()
            • MHCABlock.get_buffer()
            • MHCABlock.get_extra_state()
            • MHCABlock.get_parameter()
            • MHCABlock.get_submodule()
            • MHCABlock.half()
            • MHCABlock.ipu()
            • MHCABlock.load_state_dict()
            • MHCABlock.modules()
            • MHCABlock.named_buffers()
            • MHCABlock.named_children()
            • MHCABlock.named_modules()
            • MHCABlock.named_parameters()
            • MHCABlock.parameters()
            • MHCABlock.register_backward_hook()
            • MHCABlock.register_buffer()
            • MHCABlock.register_forward_hook()
            • MHCABlock.register_forward_pre_hook()
            • MHCABlock.register_full_backward_hook()
            • MHCABlock.register_full_backward_pre_hook()
            • MHCABlock.register_load_state_dict_post_hook()
            • MHCABlock.register_module()
            • MHCABlock.register_parameter()
            • MHCABlock.register_state_dict_pre_hook()
            • MHCABlock.requires_grad_()
            • MHCABlock.set_extra_state()
            • MHCABlock.share_memory()
            • MHCABlock.state_dict()
            • MHCABlock.to()
            • MHCABlock.to_empty()
            • MHCABlock.train()
            • MHCABlock.type()
            • MHCABlock.xpu()
            • MHCABlock.zero_grad()
        • towhee.models.mpvit.mpvit.MHCAEncoder
          • MHCAEncoder
            • MHCAEncoder.__call__()
            • MHCAEncoder.__init__()
            • MHCAEncoder.__repr__()
            • MHCAEncoder.add_module()
            • MHCAEncoder.apply()
            • MHCAEncoder.bfloat16()
            • MHCAEncoder.buffers()
            • MHCAEncoder.children()
            • MHCAEncoder.cpu()
            • MHCAEncoder.cuda()
            • MHCAEncoder.double()
            • MHCAEncoder.eval()
            • MHCAEncoder.extra_repr()
            • MHCAEncoder.float()
            • MHCAEncoder.forward()
            • MHCAEncoder.get_buffer()
            • MHCAEncoder.get_extra_state()
            • MHCAEncoder.get_parameter()
            • MHCAEncoder.get_submodule()
            • MHCAEncoder.half()
            • MHCAEncoder.ipu()
            • MHCAEncoder.load_state_dict()
            • MHCAEncoder.modules()
            • MHCAEncoder.named_buffers()
            • MHCAEncoder.named_children()
            • MHCAEncoder.named_modules()
            • MHCAEncoder.named_parameters()
            • MHCAEncoder.parameters()
            • MHCAEncoder.register_backward_hook()
            • MHCAEncoder.register_buffer()
            • MHCAEncoder.register_forward_hook()
            • MHCAEncoder.register_forward_pre_hook()
            • MHCAEncoder.register_full_backward_hook()
            • MHCAEncoder.register_full_backward_pre_hook()
            • MHCAEncoder.register_load_state_dict_post_hook()
            • MHCAEncoder.register_module()
            • MHCAEncoder.register_parameter()
            • MHCAEncoder.register_state_dict_pre_hook()
            • MHCAEncoder.requires_grad_()
            • MHCAEncoder.set_extra_state()
            • MHCAEncoder.share_memory()
            • MHCAEncoder.state_dict()
            • MHCAEncoder.to()
            • MHCAEncoder.to_empty()
            • MHCAEncoder.train()
            • MHCAEncoder.type()
            • MHCAEncoder.xpu()
            • MHCAEncoder.zero_grad()
        • towhee.models.mpvit.mpvit.MHCAStage
          • MHCAStage
            • MHCAStage.__call__()
            • MHCAStage.__init__()
            • MHCAStage.__repr__()
            • MHCAStage.add_module()
            • MHCAStage.apply()
            • MHCAStage.bfloat16()
            • MHCAStage.buffers()
            • MHCAStage.children()
            • MHCAStage.cpu()
            • MHCAStage.cuda()
            • MHCAStage.double()
            • MHCAStage.eval()
            • MHCAStage.extra_repr()
            • MHCAStage.float()
            • MHCAStage.forward()
            • MHCAStage.get_buffer()
            • MHCAStage.get_extra_state()
            • MHCAStage.get_parameter()
            • MHCAStage.get_submodule()
            • MHCAStage.half()
            • MHCAStage.ipu()
            • MHCAStage.load_state_dict()
            • MHCAStage.modules()
            • MHCAStage.named_buffers()
            • MHCAStage.named_children()
            • MHCAStage.named_modules()
            • MHCAStage.named_parameters()
            • MHCAStage.parameters()
            • MHCAStage.register_backward_hook()
            • MHCAStage.register_buffer()
            • MHCAStage.register_forward_hook()
            • MHCAStage.register_forward_pre_hook()
            • MHCAStage.register_full_backward_hook()
            • MHCAStage.register_full_backward_pre_hook()
            • MHCAStage.register_load_state_dict_post_hook()
            • MHCAStage.register_module()
            • MHCAStage.register_parameter()
            • MHCAStage.register_state_dict_pre_hook()
            • MHCAStage.requires_grad_()
            • MHCAStage.set_extra_state()
            • MHCAStage.share_memory()
            • MHCAStage.state_dict()
            • MHCAStage.to()
            • MHCAStage.to_empty()
            • MHCAStage.train()
            • MHCAStage.type()
            • MHCAStage.xpu()
            • MHCAStage.zero_grad()
        • towhee.models.mpvit.mpvit.MPViT
          • MPViT
            • MPViT.__call__()
            • MPViT.__init__()
            • MPViT.__repr__()
            • MPViT.add_module()
            • MPViT.apply()
            • MPViT.bfloat16()
            • MPViT.buffers()
            • MPViT.children()
            • MPViT.cpu()
            • MPViT.cuda()
            • MPViT.double()
            • MPViT.eval()
            • MPViT.extra_repr()
            • MPViT.float()
            • MPViT.forward()
            • MPViT.forward_features()
            • MPViT.get_buffer()
            • MPViT.get_classifier()
            • MPViT.get_extra_state()
            • MPViT.get_parameter()
            • MPViT.get_submodule()
            • MPViT.half()
            • MPViT.ipu()
            • MPViT.load_state_dict()
            • MPViT.modules()
            • MPViT.named_buffers()
            • MPViT.named_children()
            • MPViT.named_modules()
            • MPViT.named_parameters()
            • MPViT.parameters()
            • MPViT.register_backward_hook()
            • MPViT.register_buffer()
            • MPViT.register_forward_hook()
            • MPViT.register_forward_pre_hook()
            • MPViT.register_full_backward_hook()
            • MPViT.register_full_backward_pre_hook()
            • MPViT.register_load_state_dict_post_hook()
            • MPViT.register_module()
            • MPViT.register_parameter()
            • MPViT.register_state_dict_pre_hook()
            • MPViT.requires_grad_()
            • MPViT.set_extra_state()
            • MPViT.share_memory()
            • MPViT.state_dict()
            • MPViT.to()
            • MPViT.to_empty()
            • MPViT.train()
            • MPViT.type()
            • MPViT.xpu()
            • MPViT.zero_grad()
        • towhee.models.mpvit.mpvit.Mlp
          • Mlp
            • Mlp.__call__()
            • Mlp.__init__()
            • Mlp.__repr__()
            • Mlp.add_module()
            • Mlp.apply()
            • Mlp.bfloat16()
            • Mlp.buffers()
            • Mlp.children()
            • Mlp.cpu()
            • Mlp.cuda()
            • Mlp.double()
            • Mlp.eval()
            • Mlp.extra_repr()
            • Mlp.float()
            • Mlp.forward()
            • Mlp.get_buffer()
            • Mlp.get_extra_state()
            • Mlp.get_parameter()
            • Mlp.get_submodule()
            • Mlp.half()
            • Mlp.ipu()
            • Mlp.load_state_dict()
            • Mlp.modules()
            • Mlp.named_buffers()
            • Mlp.named_children()
            • Mlp.named_modules()
            • Mlp.named_parameters()
            • Mlp.parameters()
            • Mlp.register_backward_hook()
            • Mlp.register_buffer()
            • Mlp.register_forward_hook()
            • Mlp.register_forward_pre_hook()
            • Mlp.register_full_backward_hook()
            • Mlp.register_full_backward_pre_hook()
            • Mlp.register_load_state_dict_post_hook()
            • Mlp.register_module()
            • Mlp.register_parameter()
            • Mlp.register_state_dict_pre_hook()
            • Mlp.requires_grad_()
            • Mlp.set_extra_state()
            • Mlp.share_memory()
            • Mlp.state_dict()
            • Mlp.to()
            • Mlp.to_empty()
            • Mlp.train()
            • Mlp.type()
            • Mlp.xpu()
            • Mlp.zero_grad()
        • towhee.models.mpvit.mpvit.PatchEmbedStage
          • PatchEmbedStage
            • PatchEmbedStage.__call__()
            • PatchEmbedStage.__init__()
            • PatchEmbedStage.__repr__()
            • PatchEmbedStage.add_module()
            • PatchEmbedStage.apply()
            • PatchEmbedStage.bfloat16()
            • PatchEmbedStage.buffers()
            • PatchEmbedStage.children()
            • PatchEmbedStage.cpu()
            • PatchEmbedStage.cuda()
            • PatchEmbedStage.double()
            • PatchEmbedStage.eval()
            • PatchEmbedStage.extra_repr()
            • PatchEmbedStage.float()
            • PatchEmbedStage.forward()
            • PatchEmbedStage.get_buffer()
            • PatchEmbedStage.get_extra_state()
            • PatchEmbedStage.get_parameter()
            • PatchEmbedStage.get_submodule()
            • PatchEmbedStage.half()
            • PatchEmbedStage.ipu()
            • PatchEmbedStage.load_state_dict()
            • PatchEmbedStage.modules()
            • PatchEmbedStage.named_buffers()
            • PatchEmbedStage.named_children()
            • PatchEmbedStage.named_modules()
            • PatchEmbedStage.named_parameters()
            • PatchEmbedStage.parameters()
            • PatchEmbedStage.register_backward_hook()
            • PatchEmbedStage.register_buffer()
            • PatchEmbedStage.register_forward_hook()
            • PatchEmbedStage.register_forward_pre_hook()
            • PatchEmbedStage.register_full_backward_hook()
            • PatchEmbedStage.register_full_backward_pre_hook()
            • PatchEmbedStage.register_load_state_dict_post_hook()
            • PatchEmbedStage.register_module()
            • PatchEmbedStage.register_parameter()
            • PatchEmbedStage.register_state_dict_pre_hook()
            • PatchEmbedStage.requires_grad_()
            • PatchEmbedStage.set_extra_state()
            • PatchEmbedStage.share_memory()
            • PatchEmbedStage.state_dict()
            • PatchEmbedStage.to()
            • PatchEmbedStage.to_empty()
            • PatchEmbedStage.train()
            • PatchEmbedStage.type()
            • PatchEmbedStage.xpu()
            • PatchEmbedStage.zero_grad()
        • towhee.models.mpvit.mpvit.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.multiscale_vision_transformers
      • towhee.models.multiscale_vision_transformers.create_mvit
        • towhee.models.multiscale_vision_transformers.create_mvit.create_mvit_model
          • create_mvit_model()
      • towhee.models.multiscale_vision_transformers.mvit
        • towhee.models.multiscale_vision_transformers.mvit.align_scale
          • align_scale()
        • towhee.models.multiscale_vision_transformers.mvit.compute_rollout_attention
          • compute_rollout_attention()
        • towhee.models.multiscale_vision_transformers.mvit.drop_path_func
          • drop_path_func()
        • towhee.models.multiscale_vision_transformers.mvit.find_most_h_w
          • find_most_h_w()
        • towhee.models.multiscale_vision_transformers.mvit.resize_last_dim_to_most
          • resize_last_dim_to_most()
        • towhee.models.multiscale_vision_transformers.mvit.round_width
          • round_width()
        • towhee.models.multiscale_vision_transformers.mvit.AttentionPool
          • AttentionPool
            • AttentionPool.__call__()
            • AttentionPool.__init__()
            • AttentionPool.__repr__()
            • AttentionPool.add_module()
            • AttentionPool.apply()
            • AttentionPool.bfloat16()
            • AttentionPool.buffers()
            • AttentionPool.children()
            • AttentionPool.cpu()
            • AttentionPool.cuda()
            • AttentionPool.double()
            • AttentionPool.eval()
            • AttentionPool.extra_repr()
            • AttentionPool.float()
            • AttentionPool.forward()
            • AttentionPool.get_buffer()
            • AttentionPool.get_extra_state()
            • AttentionPool.get_parameter()
            • AttentionPool.get_submodule()
            • AttentionPool.half()
            • AttentionPool.ipu()
            • AttentionPool.load_state_dict()
            • AttentionPool.modules()
            • AttentionPool.named_buffers()
            • AttentionPool.named_children()
            • AttentionPool.named_modules()
            • AttentionPool.named_parameters()
            • AttentionPool.parameters()
            • AttentionPool.register_backward_hook()
            • AttentionPool.register_buffer()
            • AttentionPool.register_forward_hook()
            • AttentionPool.register_forward_pre_hook()
            • AttentionPool.register_full_backward_hook()
            • AttentionPool.register_full_backward_pre_hook()
            • AttentionPool.register_load_state_dict_post_hook()
            • AttentionPool.register_module()
            • AttentionPool.register_parameter()
            • AttentionPool.register_state_dict_pre_hook()
            • AttentionPool.requires_grad_()
            • AttentionPool.set_extra_state()
            • AttentionPool.share_memory()
            • AttentionPool.state_dict()
            • AttentionPool.to()
            • AttentionPool.to_empty()
            • AttentionPool.train()
            • AttentionPool.type()
            • AttentionPool.xpu()
            • AttentionPool.zero_grad()
        • towhee.models.multiscale_vision_transformers.mvit.DropPath
          • DropPath
            • DropPath.__call__()
            • DropPath.__init__()
            • DropPath.__repr__()
            • DropPath.add_module()
            • DropPath.apply()
            • DropPath.bfloat16()
            • DropPath.buffers()
            • DropPath.children()
            • DropPath.cpu()
            • DropPath.cuda()
            • DropPath.double()
            • DropPath.eval()
            • DropPath.extra_repr()
            • DropPath.float()
            • DropPath.forward()
            • DropPath.get_buffer()
            • DropPath.get_extra_state()
            • DropPath.get_parameter()
            • DropPath.get_submodule()
            • DropPath.half()
            • DropPath.ipu()
            • DropPath.load_state_dict()
            • DropPath.modules()
            • DropPath.named_buffers()
            • DropPath.named_children()
            • DropPath.named_modules()
            • DropPath.named_parameters()
            • DropPath.parameters()
            • DropPath.register_backward_hook()
            • DropPath.register_buffer()
            • DropPath.register_forward_hook()
            • DropPath.register_forward_pre_hook()
            • DropPath.register_full_backward_hook()
            • DropPath.register_full_backward_pre_hook()
            • DropPath.register_load_state_dict_post_hook()
            • DropPath.register_module()
            • DropPath.register_parameter()
            • DropPath.register_state_dict_pre_hook()
            • DropPath.requires_grad_()
            • DropPath.set_extra_state()
            • DropPath.share_memory()
            • DropPath.state_dict()
            • DropPath.to()
            • DropPath.to_empty()
            • DropPath.train()
            • DropPath.type()
            • DropPath.xpu()
            • DropPath.zero_grad()
        • towhee.models.multiscale_vision_transformers.mvit.MViT
          • MViT
            • MViT.__call__()
            • MViT.__init__()
            • MViT.__repr__()
            • MViT.add_module()
            • MViT.apply()
            • MViT.bfloat16()
            • MViT.buffers()
            • MViT.children()
            • MViT.cpu()
            • MViT.cuda()
            • MViT.double()
            • MViT.eval()
            • MViT.extra_repr()
            • MViT.float()
            • MViT.forward()
            • MViT.get_buffer()
            • MViT.get_extra_state()
            • MViT.get_parameter()
            • MViT.get_submodule()
            • MViT.half()
            • MViT.ipu()
            • MViT.load_state_dict()
            • MViT.modules()
            • MViT.named_buffers()
            • MViT.named_children()
            • MViT.named_modules()
            • MViT.named_parameters()
            • MViT.parameters()
            • MViT.register_backward_hook()
            • MViT.register_buffer()
            • MViT.register_forward_hook()
            • MViT.register_forward_pre_hook()
            • MViT.register_full_backward_hook()
            • MViT.register_full_backward_pre_hook()
            • MViT.register_load_state_dict_post_hook()
            • MViT.register_module()
            • MViT.register_parameter()
            • MViT.register_state_dict_pre_hook()
            • MViT.requires_grad_()
            • MViT.set_extra_state()
            • MViT.share_memory()
            • MViT.state_dict()
            • MViT.to()
            • MViT.to_empty()
            • MViT.train()
            • MViT.type()
            • MViT.xpu()
            • MViT.zero_grad()
        • towhee.models.multiscale_vision_transformers.mvit.Mlp
          • Mlp
            • Mlp.__call__()
            • Mlp.__init__()
            • Mlp.__repr__()
            • Mlp.add_module()
            • Mlp.apply()
            • Mlp.bfloat16()
            • Mlp.buffers()
            • Mlp.children()
            • Mlp.cpu()
            • Mlp.cuda()
            • Mlp.double()
            • Mlp.eval()
            • Mlp.extra_repr()
            • Mlp.float()
            • Mlp.forward()
            • Mlp.get_buffer()
            • Mlp.get_extra_state()
            • Mlp.get_parameter()
            • Mlp.get_submodule()
            • Mlp.half()
            • Mlp.ipu()
            • Mlp.load_state_dict()
            • Mlp.modules()
            • Mlp.named_buffers()
            • Mlp.named_children()
            • Mlp.named_modules()
            • Mlp.named_parameters()
            • Mlp.parameters()
            • Mlp.register_backward_hook()
            • Mlp.register_buffer()
            • Mlp.register_forward_hook()
            • Mlp.register_forward_pre_hook()
            • Mlp.register_full_backward_hook()
            • Mlp.register_full_backward_pre_hook()
            • Mlp.register_load_state_dict_post_hook()
            • Mlp.register_module()
            • Mlp.register_parameter()
            • Mlp.register_state_dict_pre_hook()
            • Mlp.requires_grad_()
            • Mlp.set_extra_state()
            • Mlp.share_memory()
            • Mlp.state_dict()
            • Mlp.to()
            • Mlp.to_empty()
            • Mlp.train()
            • Mlp.type()
            • Mlp.xpu()
            • Mlp.zero_grad()
        • towhee.models.multiscale_vision_transformers.mvit.MultiScaleAttention
          • MultiScaleAttention
            • MultiScaleAttention.__call__()
            • MultiScaleAttention.__init__()
            • MultiScaleAttention.__repr__()
            • MultiScaleAttention.add_module()
            • MultiScaleAttention.apply()
            • MultiScaleAttention.bfloat16()
            • MultiScaleAttention.buffers()
            • MultiScaleAttention.children()
            • MultiScaleAttention.cpu()
            • MultiScaleAttention.cuda()
            • MultiScaleAttention.double()
            • MultiScaleAttention.eval()
            • MultiScaleAttention.extra_repr()
            • MultiScaleAttention.float()
            • MultiScaleAttention.forward()
            • MultiScaleAttention.get_buffer()
            • MultiScaleAttention.get_extra_state()
            • MultiScaleAttention.get_parameter()
            • MultiScaleAttention.get_submodule()
            • MultiScaleAttention.half()
            • MultiScaleAttention.ipu()
            • MultiScaleAttention.load_state_dict()
            • MultiScaleAttention.modules()
            • MultiScaleAttention.named_buffers()
            • MultiScaleAttention.named_children()
            • MultiScaleAttention.named_modules()
            • MultiScaleAttention.named_parameters()
            • MultiScaleAttention.parameters()
            • MultiScaleAttention.register_backward_hook()
            • MultiScaleAttention.register_buffer()
            • MultiScaleAttention.register_forward_hook()
            • MultiScaleAttention.register_forward_pre_hook()
            • MultiScaleAttention.register_full_backward_hook()
            • MultiScaleAttention.register_full_backward_pre_hook()
            • MultiScaleAttention.register_load_state_dict_post_hook()
            • MultiScaleAttention.register_module()
            • MultiScaleAttention.register_parameter()
            • MultiScaleAttention.register_state_dict_pre_hook()
            • MultiScaleAttention.requires_grad_()
            • MultiScaleAttention.set_extra_state()
            • MultiScaleAttention.share_memory()
            • MultiScaleAttention.state_dict()
            • MultiScaleAttention.to()
            • MultiScaleAttention.to_empty()
            • MultiScaleAttention.train()
            • MultiScaleAttention.type()
            • MultiScaleAttention.xpu()
            • MultiScaleAttention.zero_grad()
        • towhee.models.multiscale_vision_transformers.mvit.MultiScaleBlock
          • MultiScaleBlock
            • MultiScaleBlock.__call__()
            • MultiScaleBlock.__init__()
            • MultiScaleBlock.__repr__()
            • MultiScaleBlock.add_module()
            • MultiScaleBlock.apply()
            • MultiScaleBlock.bfloat16()
            • MultiScaleBlock.buffers()
            • MultiScaleBlock.children()
            • MultiScaleBlock.cpu()
            • MultiScaleBlock.cuda()
            • MultiScaleBlock.double()
            • MultiScaleBlock.eval()
            • MultiScaleBlock.extra_repr()
            • MultiScaleBlock.float()
            • MultiScaleBlock.forward()
            • MultiScaleBlock.get_buffer()
            • MultiScaleBlock.get_extra_state()
            • MultiScaleBlock.get_parameter()
            • MultiScaleBlock.get_submodule()
            • MultiScaleBlock.half()
            • MultiScaleBlock.ipu()
            • MultiScaleBlock.load_state_dict()
            • MultiScaleBlock.modules()
            • MultiScaleBlock.named_buffers()
            • MultiScaleBlock.named_children()
            • MultiScaleBlock.named_modules()
            • MultiScaleBlock.named_parameters()
            • MultiScaleBlock.parameters()
            • MultiScaleBlock.register_backward_hook()
            • MultiScaleBlock.register_buffer()
            • MultiScaleBlock.register_forward_hook()
            • MultiScaleBlock.register_forward_pre_hook()
            • MultiScaleBlock.register_full_backward_hook()
            • MultiScaleBlock.register_full_backward_pre_hook()
            • MultiScaleBlock.register_load_state_dict_post_hook()
            • MultiScaleBlock.register_module()
            • MultiScaleBlock.register_parameter()
            • MultiScaleBlock.register_state_dict_pre_hook()
            • MultiScaleBlock.requires_grad_()
            • MultiScaleBlock.set_extra_state()
            • MultiScaleBlock.share_memory()
            • MultiScaleBlock.state_dict()
            • MultiScaleBlock.to()
            • MultiScaleBlock.to_empty()
            • MultiScaleBlock.train()
            • MultiScaleBlock.type()
            • MultiScaleBlock.xpu()
            • MultiScaleBlock.zero_grad()
        • towhee.models.multiscale_vision_transformers.mvit.PatchEmbed
          • PatchEmbed
            • PatchEmbed.__call__()
            • PatchEmbed.__init__()
            • PatchEmbed.__repr__()
            • PatchEmbed.add_module()
            • PatchEmbed.apply()
            • PatchEmbed.bfloat16()
            • PatchEmbed.buffers()
            • PatchEmbed.children()
            • PatchEmbed.cpu()
            • PatchEmbed.cuda()
            • PatchEmbed.double()
            • PatchEmbed.eval()
            • PatchEmbed.extra_repr()
            • PatchEmbed.float()
            • PatchEmbed.forward()
            • PatchEmbed.get_buffer()
            • PatchEmbed.get_extra_state()
            • PatchEmbed.get_parameter()
            • PatchEmbed.get_submodule()
            • PatchEmbed.half()
            • PatchEmbed.ipu()
            • PatchEmbed.load_state_dict()
            • PatchEmbed.modules()
            • PatchEmbed.named_buffers()
            • PatchEmbed.named_children()
            • PatchEmbed.named_modules()
            • PatchEmbed.named_parameters()
            • PatchEmbed.parameters()
            • PatchEmbed.register_backward_hook()
            • PatchEmbed.register_buffer()
            • PatchEmbed.register_forward_hook()
            • PatchEmbed.register_forward_pre_hook()
            • PatchEmbed.register_full_backward_hook()
            • PatchEmbed.register_full_backward_pre_hook()
            • PatchEmbed.register_load_state_dict_post_hook()
            • PatchEmbed.register_module()
            • PatchEmbed.register_parameter()
            • PatchEmbed.register_state_dict_pre_hook()
            • PatchEmbed.requires_grad_()
            • PatchEmbed.set_extra_state()
            • PatchEmbed.share_memory()
            • PatchEmbed.state_dict()
            • PatchEmbed.to()
            • PatchEmbed.to_empty()
            • PatchEmbed.train()
            • PatchEmbed.type()
            • PatchEmbed.xpu()
            • PatchEmbed.zero_grad()
        • towhee.models.multiscale_vision_transformers.mvit.Permute
          • Permute
            • Permute.__call__()
            • Permute.__init__()
            • Permute.__repr__()
            • Permute.add_module()
            • Permute.apply()
            • Permute.bfloat16()
            • Permute.buffers()
            • Permute.children()
            • Permute.cpu()
            • Permute.cuda()
            • Permute.double()
            • Permute.eval()
            • Permute.extra_repr()
            • Permute.float()
            • Permute.forward()
            • Permute.get_buffer()
            • Permute.get_extra_state()
            • Permute.get_parameter()
            • Permute.get_submodule()
            • Permute.half()
            • Permute.ipu()
            • Permute.load_state_dict()
            • Permute.modules()
            • Permute.named_buffers()
            • Permute.named_children()
            • Permute.named_modules()
            • Permute.named_parameters()
            • Permute.parameters()
            • Permute.register_backward_hook()
            • Permute.register_buffer()
            • Permute.register_forward_hook()
            • Permute.register_forward_pre_hook()
            • Permute.register_full_backward_hook()
            • Permute.register_full_backward_pre_hook()
            • Permute.register_load_state_dict_post_hook()
            • Permute.register_module()
            • Permute.register_parameter()
            • Permute.register_state_dict_pre_hook()
            • Permute.requires_grad_()
            • Permute.set_extra_state()
            • Permute.share_memory()
            • Permute.state_dict()
            • Permute.to()
            • Permute.to_empty()
            • Permute.train()
            • Permute.type()
            • Permute.xpu()
            • Permute.zero_grad()
        • towhee.models.multiscale_vision_transformers.mvit.TransformerBasicHead
          • TransformerBasicHead
            • TransformerBasicHead.__call__()
            • TransformerBasicHead.__init__()
            • TransformerBasicHead.__repr__()
            • TransformerBasicHead.add_module()
            • TransformerBasicHead.apply()
            • TransformerBasicHead.bfloat16()
            • TransformerBasicHead.buffers()
            • TransformerBasicHead.children()
            • TransformerBasicHead.cpu()
            • TransformerBasicHead.cuda()
            • TransformerBasicHead.double()
            • TransformerBasicHead.eval()
            • TransformerBasicHead.extra_repr()
            • TransformerBasicHead.float()
            • TransformerBasicHead.forward()
            • TransformerBasicHead.get_buffer()
            • TransformerBasicHead.get_extra_state()
            • TransformerBasicHead.get_parameter()
            • TransformerBasicHead.get_submodule()
            • TransformerBasicHead.half()
            • TransformerBasicHead.ipu()
            • TransformerBasicHead.load_state_dict()
            • TransformerBasicHead.modules()
            • TransformerBasicHead.named_buffers()
            • TransformerBasicHead.named_children()
            • TransformerBasicHead.named_modules()
            • TransformerBasicHead.named_parameters()
            • TransformerBasicHead.parameters()
            • TransformerBasicHead.register_backward_hook()
            • TransformerBasicHead.register_buffer()
            • TransformerBasicHead.register_forward_hook()
            • TransformerBasicHead.register_forward_pre_hook()
            • TransformerBasicHead.register_full_backward_hook()
            • TransformerBasicHead.register_full_backward_pre_hook()
            • TransformerBasicHead.register_load_state_dict_post_hook()
            • TransformerBasicHead.register_module()
            • TransformerBasicHead.register_parameter()
            • TransformerBasicHead.register_state_dict_pre_hook()
            • TransformerBasicHead.requires_grad_()
            • TransformerBasicHead.set_extra_state()
            • TransformerBasicHead.share_memory()
            • TransformerBasicHead.state_dict()
            • TransformerBasicHead.to()
            • TransformerBasicHead.to_empty()
            • TransformerBasicHead.train()
            • TransformerBasicHead.type()
            • TransformerBasicHead.xpu()
            • TransformerBasicHead.zero_grad()
    • towhee.models.nnfp
      • towhee.models.nnfp.nnfp
        • towhee.models.nnfp.nnfp.DivEncoder
          • DivEncoder
            • DivEncoder.__call__()
            • DivEncoder.__init__()
            • DivEncoder.__repr__()
            • DivEncoder.add_module()
            • DivEncoder.apply()
            • DivEncoder.bfloat16()
            • DivEncoder.buffers()
            • DivEncoder.children()
            • DivEncoder.cpu()
            • DivEncoder.cuda()
            • DivEncoder.double()
            • DivEncoder.eval()
            • DivEncoder.extra_repr()
            • DivEncoder.float()
            • DivEncoder.forward()
            • DivEncoder.get_buffer()
            • DivEncoder.get_extra_state()
            • DivEncoder.get_parameter()
            • DivEncoder.get_submodule()
            • DivEncoder.half()
            • DivEncoder.ipu()
            • DivEncoder.load_state_dict()
            • DivEncoder.modules()
            • DivEncoder.named_buffers()
            • DivEncoder.named_children()
            • DivEncoder.named_modules()
            • DivEncoder.named_parameters()
            • DivEncoder.parameters()
            • DivEncoder.register_backward_hook()
            • DivEncoder.register_buffer()
            • DivEncoder.register_forward_hook()
            • DivEncoder.register_forward_pre_hook()
            • DivEncoder.register_full_backward_hook()
            • DivEncoder.register_full_backward_pre_hook()
            • DivEncoder.register_load_state_dict_post_hook()
            • DivEncoder.register_module()
            • DivEncoder.register_parameter()
            • DivEncoder.register_state_dict_pre_hook()
            • DivEncoder.requires_grad_()
            • DivEncoder.set_extra_state()
            • DivEncoder.share_memory()
            • DivEncoder.state_dict()
            • DivEncoder.to()
            • DivEncoder.to_empty()
            • DivEncoder.train()
            • DivEncoder.type()
            • DivEncoder.xpu()
            • DivEncoder.zero_grad()
        • towhee.models.nnfp.nnfp.FrontConv
          • FrontConv
            • FrontConv.__call__()
            • FrontConv.__init__()
            • FrontConv.__repr__()
            • FrontConv.add_module()
            • FrontConv.apply()
            • FrontConv.bfloat16()
            • FrontConv.buffers()
            • FrontConv.children()
            • FrontConv.cpu()
            • FrontConv.cuda()
            • FrontConv.double()
            • FrontConv.eval()
            • FrontConv.extra_repr()
            • FrontConv.float()
            • FrontConv.forward()
            • FrontConv.get_buffer()
            • FrontConv.get_extra_state()
            • FrontConv.get_parameter()
            • FrontConv.get_submodule()
            • FrontConv.half()
            • FrontConv.ipu()
            • FrontConv.load_state_dict()
            • FrontConv.modules()
            • FrontConv.named_buffers()
            • FrontConv.named_children()
            • FrontConv.named_modules()
            • FrontConv.named_parameters()
            • FrontConv.parameters()
            • FrontConv.register_backward_hook()
            • FrontConv.register_buffer()
            • FrontConv.register_forward_hook()
            • FrontConv.register_forward_pre_hook()
            • FrontConv.register_full_backward_hook()
            • FrontConv.register_full_backward_pre_hook()
            • FrontConv.register_load_state_dict_post_hook()
            • FrontConv.register_module()
            • FrontConv.register_parameter()
            • FrontConv.register_state_dict_pre_hook()
            • FrontConv.requires_grad_()
            • FrontConv.set_extra_state()
            • FrontConv.share_memory()
            • FrontConv.state_dict()
            • FrontConv.to()
            • FrontConv.to_empty()
            • FrontConv.train()
            • FrontConv.type()
            • FrontConv.xpu()
            • FrontConv.zero_grad()
        • towhee.models.nnfp.nnfp.NNFp
          • NNFp
            • NNFp.__call__()
            • NNFp.__init__()
            • NNFp.__repr__()
            • NNFp.add_module()
            • NNFp.apply()
            • NNFp.bfloat16()
            • NNFp.buffers()
            • NNFp.children()
            • NNFp.cpu()
            • NNFp.cuda()
            • NNFp.double()
            • NNFp.eval()
            • NNFp.extra_repr()
            • NNFp.float()
            • NNFp.forward()
            • NNFp.get_buffer()
            • NNFp.get_extra_state()
            • NNFp.get_parameter()
            • NNFp.get_submodule()
            • NNFp.half()
            • NNFp.ipu()
            • NNFp.load_state_dict()
            • NNFp.modules()
            • NNFp.named_buffers()
            • NNFp.named_children()
            • NNFp.named_modules()
            • NNFp.named_parameters()
            • NNFp.parameters()
            • NNFp.register_backward_hook()
            • NNFp.register_buffer()
            • NNFp.register_forward_hook()
            • NNFp.register_forward_pre_hook()
            • NNFp.register_full_backward_hook()
            • NNFp.register_full_backward_pre_hook()
            • NNFp.register_load_state_dict_post_hook()
            • NNFp.register_module()
            • NNFp.register_parameter()
            • NNFp.register_state_dict_pre_hook()
            • NNFp.requires_grad_()
            • NNFp.set_extra_state()
            • NNFp.share_memory()
            • NNFp.state_dict()
            • NNFp.to()
            • NNFp.to_empty()
            • NNFp.train()
            • NNFp.type()
            • NNFp.xpu()
            • NNFp.zero_grad()
    • towhee.models.omnivore
      • towhee.models.omnivore.omnivore
        • towhee.models.omnivore.omnivore.create_model
          • create_model()
        • towhee.models.omnivore.omnivore.get_all_heads
          • get_all_heads()
        • towhee.models.omnivore.omnivore.get_imagenet_head
          • get_imagenet_head()
        • towhee.models.omnivore.omnivore.get_kinetics_head
          • get_kinetics_head()
        • towhee.models.omnivore.omnivore.get_sunrgbd_head
          • get_sunrgbd_head()
        • towhee.models.omnivore.omnivore.omnivore_swinb
          • omnivore_swinb()
        • towhee.models.omnivore.omnivore.omnivore_swinb_epic
          • omnivore_swinb_epic()
        • towhee.models.omnivore.omnivore.omnivore_swinb_imagenet21k
          • omnivore_swinb_imagenet21k()
        • towhee.models.omnivore.omnivore.omnivore_swinl_imagenet21k
          • omnivore_swinl_imagenet21k()
        • towhee.models.omnivore.omnivore.omnivore_swinl_kinetics600
          • omnivore_swinl_kinetics600()
        • towhee.models.omnivore.omnivore.omnivore_swins
          • omnivore_swins()
        • towhee.models.omnivore.omnivore.omnivore_swint
          • omnivore_swint()
        • towhee.models.omnivore.omnivore.OmnivoreModel
          • OmnivoreModel
            • OmnivoreModel.__call__()
            • OmnivoreModel.__init__()
            • OmnivoreModel.__repr__()
            • OmnivoreModel.add_module()
            • OmnivoreModel.apply()
            • OmnivoreModel.bfloat16()
            • OmnivoreModel.buffers()
            • OmnivoreModel.children()
            • OmnivoreModel.cpu()
            • OmnivoreModel.cuda()
            • OmnivoreModel.double()
            • OmnivoreModel.eval()
            • OmnivoreModel.extra_repr()
            • OmnivoreModel.float()
            • OmnivoreModel.forward()
            • OmnivoreModel.get_buffer()
            • OmnivoreModel.get_extra_state()
            • OmnivoreModel.get_parameter()
            • OmnivoreModel.get_submodule()
            • OmnivoreModel.half()
            • OmnivoreModel.ipu()
            • OmnivoreModel.load_state_dict()
            • OmnivoreModel.modules()
            • OmnivoreModel.named_buffers()
            • OmnivoreModel.named_children()
            • OmnivoreModel.named_modules()
            • OmnivoreModel.named_parameters()
            • OmnivoreModel.parameters()
            • OmnivoreModel.register_backward_hook()
            • OmnivoreModel.register_buffer()
            • OmnivoreModel.register_forward_hook()
            • OmnivoreModel.register_forward_pre_hook()
            • OmnivoreModel.register_full_backward_hook()
            • OmnivoreModel.register_full_backward_pre_hook()
            • OmnivoreModel.register_load_state_dict_post_hook()
            • OmnivoreModel.register_module()
            • OmnivoreModel.register_parameter()
            • OmnivoreModel.register_state_dict_pre_hook()
            • OmnivoreModel.requires_grad_()
            • OmnivoreModel.set_extra_state()
            • OmnivoreModel.share_memory()
            • OmnivoreModel.state_dict()
            • OmnivoreModel.to()
            • OmnivoreModel.to_empty()
            • OmnivoreModel.train()
            • OmnivoreModel.type()
            • OmnivoreModel.xpu()
            • OmnivoreModel.zero_grad()
    • towhee.models.perceiver
      • towhee.models.perceiver.create_cross_attention
        • towhee.models.perceiver.create_cross_attention.cross_attention_layer
          • cross_attention_layer()
      • towhee.models.perceiver.create_self_attention
        • towhee.models.perceiver.create_self_attention.create_self_attention
          • create_self_attention()
      • towhee.models.perceiver.create_self_attention_block
        • towhee.models.perceiver.create_self_attention_block.create_self_attention_block
          • create_self_attention_block()
      • towhee.models.perceiver.cross_attention
        • towhee.models.perceiver.cross_attention.CrossAttention
          • CrossAttention
            • CrossAttention.__call__()
            • CrossAttention.__init__()
            • CrossAttention.__repr__()
            • CrossAttention.add_module()
            • CrossAttention.apply()
            • CrossAttention.bfloat16()
            • CrossAttention.buffers()
            • CrossAttention.children()
            • CrossAttention.cpu()
            • CrossAttention.cuda()
            • CrossAttention.double()
            • CrossAttention.eval()
            • CrossAttention.extra_repr()
            • CrossAttention.float()
            • CrossAttention.forward()
            • CrossAttention.get_buffer()
            • CrossAttention.get_extra_state()
            • CrossAttention.get_parameter()
            • CrossAttention.get_submodule()
            • CrossAttention.half()
            • CrossAttention.ipu()
            • CrossAttention.load_state_dict()
            • CrossAttention.modules()
            • CrossAttention.named_buffers()
            • CrossAttention.named_children()
            • CrossAttention.named_modules()
            • CrossAttention.named_parameters()
            • CrossAttention.parameters()
            • CrossAttention.register_backward_hook()
            • CrossAttention.register_buffer()
            • CrossAttention.register_forward_hook()
            • CrossAttention.register_forward_pre_hook()
            • CrossAttention.register_full_backward_hook()
            • CrossAttention.register_full_backward_pre_hook()
            • CrossAttention.register_load_state_dict_post_hook()
            • CrossAttention.register_module()
            • CrossAttention.register_parameter()
            • CrossAttention.register_state_dict_pre_hook()
            • CrossAttention.requires_grad_()
            • CrossAttention.set_extra_state()
            • CrossAttention.share_memory()
            • CrossAttention.state_dict()
            • CrossAttention.to()
            • CrossAttention.to_empty()
            • CrossAttention.train()
            • CrossAttention.type()
            • CrossAttention.xpu()
            • CrossAttention.zero_grad()
      • towhee.models.perceiver.mlp
        • towhee.models.perceiver.mlp.mlp
          • mlp()
      • towhee.models.perceiver.multi_head_attention
        • towhee.models.perceiver.multi_head_attention.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.perceiver.residual
        • towhee.models.perceiver.residual.Residual
          • Residual
            • Residual.__call__()
            • Residual.__init__()
            • Residual.__repr__()
            • Residual.add_module()
            • Residual.apply()
            • Residual.bfloat16()
            • Residual.buffers()
            • Residual.children()
            • Residual.cpu()
            • Residual.cuda()
            • Residual.double()
            • Residual.eval()
            • Residual.extra_repr()
            • Residual.float()
            • Residual.forward()
            • Residual.get_buffer()
            • Residual.get_extra_state()
            • Residual.get_parameter()
            • Residual.get_submodule()
            • Residual.half()
            • Residual.ipu()
            • Residual.load_state_dict()
            • Residual.modules()
            • Residual.named_buffers()
            • Residual.named_children()
            • Residual.named_modules()
            • Residual.named_parameters()
            • Residual.parameters()
            • Residual.register_backward_hook()
            • Residual.register_buffer()
            • Residual.register_forward_hook()
            • Residual.register_forward_pre_hook()
            • Residual.register_full_backward_hook()
            • Residual.register_full_backward_pre_hook()
            • Residual.register_load_state_dict_post_hook()
            • Residual.register_module()
            • Residual.register_parameter()
            • Residual.register_state_dict_pre_hook()
            • Residual.requires_grad_()
            • Residual.set_extra_state()
            • Residual.share_memory()
            • Residual.state_dict()
            • Residual.to()
            • Residual.to_empty()
            • Residual.train()
            • Residual.type()
            • Residual.xpu()
            • Residual.zero_grad()
      • towhee.models.perceiver.self_attention
        • towhee.models.perceiver.self_attention.SelfAttention
          • SelfAttention
            • SelfAttention.__call__()
            • SelfAttention.__init__()
            • SelfAttention.__repr__()
            • SelfAttention.add_module()
            • SelfAttention.apply()
            • SelfAttention.bfloat16()
            • SelfAttention.buffers()
            • SelfAttention.children()
            • SelfAttention.cpu()
            • SelfAttention.cuda()
            • SelfAttention.double()
            • SelfAttention.eval()
            • SelfAttention.extra_repr()
            • SelfAttention.float()
            • SelfAttention.forward()
            • SelfAttention.get_buffer()
            • SelfAttention.get_extra_state()
            • SelfAttention.get_parameter()
            • SelfAttention.get_submodule()
            • SelfAttention.half()
            • SelfAttention.ipu()
            • SelfAttention.load_state_dict()
            • SelfAttention.modules()
            • SelfAttention.named_buffers()
            • SelfAttention.named_children()
            • SelfAttention.named_modules()
            • SelfAttention.named_parameters()
            • SelfAttention.parameters()
            • SelfAttention.register_backward_hook()
            • SelfAttention.register_buffer()
            • SelfAttention.register_forward_hook()
            • SelfAttention.register_forward_pre_hook()
            • SelfAttention.register_full_backward_hook()
            • SelfAttention.register_full_backward_pre_hook()
            • SelfAttention.register_load_state_dict_post_hook()
            • SelfAttention.register_module()
            • SelfAttention.register_parameter()
            • SelfAttention.register_state_dict_pre_hook()
            • SelfAttention.requires_grad_()
            • SelfAttention.set_extra_state()
            • SelfAttention.share_memory()
            • SelfAttention.state_dict()
            • SelfAttention.to()
            • SelfAttention.to_empty()
            • SelfAttention.train()
            • SelfAttention.type()
            • SelfAttention.xpu()
            • SelfAttention.zero_grad()
      • towhee.models.perceiver.sequential
        • towhee.models.perceiver.sequential.Sequential
          • Sequential
            • Sequential.__call__()
            • Sequential.__init__()
            • Sequential.__repr__()
            • Sequential.add_module()
            • Sequential.append()
            • Sequential.apply()
            • Sequential.bfloat16()
            • Sequential.buffers()
            • Sequential.children()
            • Sequential.cpu()
            • Sequential.cuda()
            • Sequential.double()
            • Sequential.eval()
            • Sequential.extra_repr()
            • Sequential.float()
            • Sequential.forward()
            • Sequential.get_buffer()
            • Sequential.get_extra_state()
            • Sequential.get_parameter()
            • Sequential.get_submodule()
            • Sequential.half()
            • Sequential.ipu()
            • Sequential.load_state_dict()
            • Sequential.modules()
            • Sequential.named_buffers()
            • Sequential.named_children()
            • Sequential.named_modules()
            • Sequential.named_parameters()
            • Sequential.parameters()
            • Sequential.register_backward_hook()
            • Sequential.register_buffer()
            • Sequential.register_forward_hook()
            • Sequential.register_forward_pre_hook()
            • Sequential.register_full_backward_hook()
            • Sequential.register_full_backward_pre_hook()
            • Sequential.register_load_state_dict_post_hook()
            • Sequential.register_module()
            • Sequential.register_parameter()
            • Sequential.register_state_dict_pre_hook()
            • Sequential.requires_grad_()
            • Sequential.set_extra_state()
            • Sequential.share_memory()
            • Sequential.state_dict()
            • Sequential.to()
            • Sequential.to_empty()
            • Sequential.train()
            • Sequential.type()
            • Sequential.xpu()
            • Sequential.zero_grad()
    • towhee.models.repmlp
      • towhee.models.repmlp.blocks
        • towhee.models.repmlp.blocks.GlobalPerceptron
          • GlobalPerceptron
            • GlobalPerceptron.__call__()
            • GlobalPerceptron.__init__()
            • GlobalPerceptron.__repr__()
            • GlobalPerceptron.add_module()
            • GlobalPerceptron.apply()
            • GlobalPerceptron.bfloat16()
            • GlobalPerceptron.buffers()
            • GlobalPerceptron.children()
            • GlobalPerceptron.cpu()
            • GlobalPerceptron.cuda()
            • GlobalPerceptron.double()
            • GlobalPerceptron.eval()
            • GlobalPerceptron.extra_repr()
            • GlobalPerceptron.float()
            • GlobalPerceptron.forward()
            • GlobalPerceptron.get_buffer()
            • GlobalPerceptron.get_extra_state()
            • GlobalPerceptron.get_parameter()
            • GlobalPerceptron.get_submodule()
            • GlobalPerceptron.half()
            • GlobalPerceptron.ipu()
            • GlobalPerceptron.load_state_dict()
            • GlobalPerceptron.modules()
            • GlobalPerceptron.named_buffers()
            • GlobalPerceptron.named_children()
            • GlobalPerceptron.named_modules()
            • GlobalPerceptron.named_parameters()
            • GlobalPerceptron.parameters()
            • GlobalPerceptron.register_backward_hook()
            • GlobalPerceptron.register_buffer()
            • GlobalPerceptron.register_forward_hook()
            • GlobalPerceptron.register_forward_pre_hook()
            • GlobalPerceptron.register_full_backward_hook()
            • GlobalPerceptron.register_full_backward_pre_hook()
            • GlobalPerceptron.register_load_state_dict_post_hook()
            • GlobalPerceptron.register_module()
            • GlobalPerceptron.register_parameter()
            • GlobalPerceptron.register_state_dict_pre_hook()
            • GlobalPerceptron.requires_grad_()
            • GlobalPerceptron.set_extra_state()
            • GlobalPerceptron.share_memory()
            • GlobalPerceptron.state_dict()
            • GlobalPerceptron.to()
            • GlobalPerceptron.to_empty()
            • GlobalPerceptron.train()
            • GlobalPerceptron.type()
            • GlobalPerceptron.xpu()
            • GlobalPerceptron.zero_grad()
        • towhee.models.repmlp.blocks.RepMLPBlock
          • RepMLPBlock
            • RepMLPBlock.__call__()
            • RepMLPBlock.__init__()
            • RepMLPBlock.__repr__()
            • RepMLPBlock.add_module()
            • RepMLPBlock.apply()
            • RepMLPBlock.bfloat16()
            • RepMLPBlock.buffers()
            • RepMLPBlock.children()
            • RepMLPBlock.cpu()
            • RepMLPBlock.cuda()
            • RepMLPBlock.double()
            • RepMLPBlock.eval()
            • RepMLPBlock.extra_repr()
            • RepMLPBlock.float()
            • RepMLPBlock.forward()
            • RepMLPBlock.get_buffer()
            • RepMLPBlock.get_extra_state()
            • RepMLPBlock.get_parameter()
            • RepMLPBlock.get_submodule()
            • RepMLPBlock.half()
            • RepMLPBlock.ipu()
            • RepMLPBlock.load_state_dict()
            • RepMLPBlock.modules()
            • RepMLPBlock.named_buffers()
            • RepMLPBlock.named_children()
            • RepMLPBlock.named_modules()
            • RepMLPBlock.named_parameters()
            • RepMLPBlock.parameters()
            • RepMLPBlock.register_backward_hook()
            • RepMLPBlock.register_buffer()
            • RepMLPBlock.register_forward_hook()
            • RepMLPBlock.register_forward_pre_hook()
            • RepMLPBlock.register_full_backward_hook()
            • RepMLPBlock.register_full_backward_pre_hook()
            • RepMLPBlock.register_load_state_dict_post_hook()
            • RepMLPBlock.register_module()
            • RepMLPBlock.register_parameter()
            • RepMLPBlock.register_state_dict_pre_hook()
            • RepMLPBlock.requires_grad_()
            • RepMLPBlock.set_extra_state()
            • RepMLPBlock.share_memory()
            • RepMLPBlock.state_dict()
            • RepMLPBlock.to()
            • RepMLPBlock.to_empty()
            • RepMLPBlock.train()
            • RepMLPBlock.type()
            • RepMLPBlock.xpu()
            • RepMLPBlock.zero_grad()
      • towhee.models.repmlp.configs
        • towhee.models.repmlp.configs.get_configs
          • get_configs()
      • towhee.models.repmlp.repmlp
        • towhee.models.repmlp.repmlp.create_model
          • create_model()
        • towhee.models.repmlp.repmlp.RepMLPNet
          • RepMLPNet
            • RepMLPNet.__call__()
            • RepMLPNet.__init__()
            • RepMLPNet.__repr__()
            • RepMLPNet.add_module()
            • RepMLPNet.apply()
            • RepMLPNet.bfloat16()
            • RepMLPNet.buffers()
            • RepMLPNet.children()
            • RepMLPNet.cpu()
            • RepMLPNet.cuda()
            • RepMLPNet.double()
            • RepMLPNet.eval()
            • RepMLPNet.extra_repr()
            • RepMLPNet.float()
            • RepMLPNet.forward()
            • RepMLPNet.get_buffer()
            • RepMLPNet.get_extra_state()
            • RepMLPNet.get_parameter()
            • RepMLPNet.get_submodule()
            • RepMLPNet.half()
            • RepMLPNet.ipu()
            • RepMLPNet.load_state_dict()
            • RepMLPNet.modules()
            • RepMLPNet.named_buffers()
            • RepMLPNet.named_children()
            • RepMLPNet.named_modules()
            • RepMLPNet.named_parameters()
            • RepMLPNet.parameters()
            • RepMLPNet.register_backward_hook()
            • RepMLPNet.register_buffer()
            • RepMLPNet.register_forward_hook()
            • RepMLPNet.register_forward_pre_hook()
            • RepMLPNet.register_full_backward_hook()
            • RepMLPNet.register_full_backward_pre_hook()
            • RepMLPNet.register_load_state_dict_post_hook()
            • RepMLPNet.register_module()
            • RepMLPNet.register_parameter()
            • RepMLPNet.register_state_dict_pre_hook()
            • RepMLPNet.requires_grad_()
            • RepMLPNet.set_extra_state()
            • RepMLPNet.share_memory()
            • RepMLPNet.state_dict()
            • RepMLPNet.to()
            • RepMLPNet.to_empty()
            • RepMLPNet.train()
            • RepMLPNet.type()
            • RepMLPNet.xpu()
            • RepMLPNet.zero_grad()
        • towhee.models.repmlp.repmlp.RepMLPNetUnit
          • RepMLPNetUnit
            • RepMLPNetUnit.__call__()
            • RepMLPNetUnit.__init__()
            • RepMLPNetUnit.__repr__()
            • RepMLPNetUnit.add_module()
            • RepMLPNetUnit.apply()
            • RepMLPNetUnit.bfloat16()
            • RepMLPNetUnit.buffers()
            • RepMLPNetUnit.children()
            • RepMLPNetUnit.cpu()
            • RepMLPNetUnit.cuda()
            • RepMLPNetUnit.double()
            • RepMLPNetUnit.eval()
            • RepMLPNetUnit.extra_repr()
            • RepMLPNetUnit.float()
            • RepMLPNetUnit.forward()
            • RepMLPNetUnit.get_buffer()
            • RepMLPNetUnit.get_extra_state()
            • RepMLPNetUnit.get_parameter()
            • RepMLPNetUnit.get_submodule()
            • RepMLPNetUnit.half()
            • RepMLPNetUnit.ipu()
            • RepMLPNetUnit.load_state_dict()
            • RepMLPNetUnit.modules()
            • RepMLPNetUnit.named_buffers()
            • RepMLPNetUnit.named_children()
            • RepMLPNetUnit.named_modules()
            • RepMLPNetUnit.named_parameters()
            • RepMLPNetUnit.parameters()
            • RepMLPNetUnit.register_backward_hook()
            • RepMLPNetUnit.register_buffer()
            • RepMLPNetUnit.register_forward_hook()
            • RepMLPNetUnit.register_forward_pre_hook()
            • RepMLPNetUnit.register_full_backward_hook()
            • RepMLPNetUnit.register_full_backward_pre_hook()
            • RepMLPNetUnit.register_load_state_dict_post_hook()
            • RepMLPNetUnit.register_module()
            • RepMLPNetUnit.register_parameter()
            • RepMLPNetUnit.register_state_dict_pre_hook()
            • RepMLPNetUnit.requires_grad_()
            • RepMLPNetUnit.set_extra_state()
            • RepMLPNetUnit.share_memory()
            • RepMLPNetUnit.state_dict()
            • RepMLPNetUnit.to()
            • RepMLPNetUnit.to_empty()
            • RepMLPNetUnit.train()
            • RepMLPNetUnit.type()
            • RepMLPNetUnit.xpu()
            • RepMLPNetUnit.zero_grad()
    • towhee.models.retina_face
      • towhee.models.retina_face.configs
        • towhee.models.retina_face.configs.build_configs
          • build_configs()
      • towhee.models.retina_face.heads
        • towhee.models.retina_face.heads.BboxHead
          • BboxHead
            • BboxHead.__call__()
            • BboxHead.__init__()
            • BboxHead.__repr__()
            • BboxHead.add_module()
            • BboxHead.apply()
            • BboxHead.bfloat16()
            • BboxHead.buffers()
            • BboxHead.children()
            • BboxHead.cpu()
            • BboxHead.cuda()
            • BboxHead.double()
            • BboxHead.eval()
            • BboxHead.extra_repr()
            • BboxHead.float()
            • BboxHead.forward()
            • BboxHead.get_buffer()
            • BboxHead.get_extra_state()
            • BboxHead.get_parameter()
            • BboxHead.get_submodule()
            • BboxHead.half()
            • BboxHead.ipu()
            • BboxHead.load_state_dict()
            • BboxHead.modules()
            • BboxHead.named_buffers()
            • BboxHead.named_children()
            • BboxHead.named_modules()
            • BboxHead.named_parameters()
            • BboxHead.parameters()
            • BboxHead.register_backward_hook()
            • BboxHead.register_buffer()
            • BboxHead.register_forward_hook()
            • BboxHead.register_forward_pre_hook()
            • BboxHead.register_full_backward_hook()
            • BboxHead.register_full_backward_pre_hook()
            • BboxHead.register_load_state_dict_post_hook()
            • BboxHead.register_module()
            • BboxHead.register_parameter()
            • BboxHead.register_state_dict_pre_hook()
            • BboxHead.requires_grad_()
            • BboxHead.set_extra_state()
            • BboxHead.share_memory()
            • BboxHead.state_dict()
            • BboxHead.to()
            • BboxHead.to_empty()
            • BboxHead.train()
            • BboxHead.type()
            • BboxHead.xpu()
            • BboxHead.zero_grad()
        • towhee.models.retina_face.heads.ClassHead
          • ClassHead
            • ClassHead.__call__()
            • ClassHead.__init__()
            • ClassHead.__repr__()
            • ClassHead.add_module()
            • ClassHead.apply()
            • ClassHead.bfloat16()
            • ClassHead.buffers()
            • ClassHead.children()
            • ClassHead.cpu()
            • ClassHead.cuda()
            • ClassHead.double()
            • ClassHead.eval()
            • ClassHead.extra_repr()
            • ClassHead.float()
            • ClassHead.forward()
            • ClassHead.get_buffer()
            • ClassHead.get_extra_state()
            • ClassHead.get_parameter()
            • ClassHead.get_submodule()
            • ClassHead.half()
            • ClassHead.ipu()
            • ClassHead.load_state_dict()
            • ClassHead.modules()
            • ClassHead.named_buffers()
            • ClassHead.named_children()
            • ClassHead.named_modules()
            • ClassHead.named_parameters()
            • ClassHead.parameters()
            • ClassHead.register_backward_hook()
            • ClassHead.register_buffer()
            • ClassHead.register_forward_hook()
            • ClassHead.register_forward_pre_hook()
            • ClassHead.register_full_backward_hook()
            • ClassHead.register_full_backward_pre_hook()
            • ClassHead.register_load_state_dict_post_hook()
            • ClassHead.register_module()
            • ClassHead.register_parameter()
            • ClassHead.register_state_dict_pre_hook()
            • ClassHead.requires_grad_()
            • ClassHead.set_extra_state()
            • ClassHead.share_memory()
            • ClassHead.state_dict()
            • ClassHead.to()
            • ClassHead.to_empty()
            • ClassHead.train()
            • ClassHead.type()
            • ClassHead.xpu()
            • ClassHead.zero_grad()
        • towhee.models.retina_face.heads.LandmarkHead
          • LandmarkHead
            • LandmarkHead.__call__()
            • LandmarkHead.__init__()
            • LandmarkHead.__repr__()
            • LandmarkHead.add_module()
            • LandmarkHead.apply()
            • LandmarkHead.bfloat16()
            • LandmarkHead.buffers()
            • LandmarkHead.children()
            • LandmarkHead.cpu()
            • LandmarkHead.cuda()
            • LandmarkHead.double()
            • LandmarkHead.eval()
            • LandmarkHead.extra_repr()
            • LandmarkHead.float()
            • LandmarkHead.forward()
            • LandmarkHead.get_buffer()
            • LandmarkHead.get_extra_state()
            • LandmarkHead.get_parameter()
            • LandmarkHead.get_submodule()
            • LandmarkHead.half()
            • LandmarkHead.ipu()
            • LandmarkHead.load_state_dict()
            • LandmarkHead.modules()
            • LandmarkHead.named_buffers()
            • LandmarkHead.named_children()
            • LandmarkHead.named_modules()
            • LandmarkHead.named_parameters()
            • LandmarkHead.parameters()
            • LandmarkHead.register_backward_hook()
            • LandmarkHead.register_buffer()
            • LandmarkHead.register_forward_hook()
            • LandmarkHead.register_forward_pre_hook()
            • LandmarkHead.register_full_backward_hook()
            • LandmarkHead.register_full_backward_pre_hook()
            • LandmarkHead.register_load_state_dict_post_hook()
            • LandmarkHead.register_module()
            • LandmarkHead.register_parameter()
            • LandmarkHead.register_state_dict_pre_hook()
            • LandmarkHead.requires_grad_()
            • LandmarkHead.set_extra_state()
            • LandmarkHead.share_memory()
            • LandmarkHead.state_dict()
            • LandmarkHead.to()
            • LandmarkHead.to_empty()
            • LandmarkHead.train()
            • LandmarkHead.type()
            • LandmarkHead.xpu()
            • LandmarkHead.zero_grad()
      • towhee.models.retina_face.mobilenet_v1
        • towhee.models.retina_face.mobilenet_v1.MobileNetV1
          • MobileNetV1
            • MobileNetV1.__call__()
            • MobileNetV1.__init__()
            • MobileNetV1.__repr__()
            • MobileNetV1.add_module()
            • MobileNetV1.apply()
            • MobileNetV1.bfloat16()
            • MobileNetV1.buffers()
            • MobileNetV1.children()
            • MobileNetV1.cpu()
            • MobileNetV1.cuda()
            • MobileNetV1.double()
            • MobileNetV1.eval()
            • MobileNetV1.extra_repr()
            • MobileNetV1.float()
            • MobileNetV1.forward()
            • MobileNetV1.get_buffer()
            • MobileNetV1.get_extra_state()
            • MobileNetV1.get_parameter()
            • MobileNetV1.get_submodule()
            • MobileNetV1.half()
            • MobileNetV1.ipu()
            • MobileNetV1.load_state_dict()
            • MobileNetV1.modules()
            • MobileNetV1.named_buffers()
            • MobileNetV1.named_children()
            • MobileNetV1.named_modules()
            • MobileNetV1.named_parameters()
            • MobileNetV1.parameters()
            • MobileNetV1.register_backward_hook()
            • MobileNetV1.register_buffer()
            • MobileNetV1.register_forward_hook()
            • MobileNetV1.register_forward_pre_hook()
            • MobileNetV1.register_full_backward_hook()
            • MobileNetV1.register_full_backward_pre_hook()
            • MobileNetV1.register_load_state_dict_post_hook()
            • MobileNetV1.register_module()
            • MobileNetV1.register_parameter()
            • MobileNetV1.register_state_dict_pre_hook()
            • MobileNetV1.requires_grad_()
            • MobileNetV1.set_extra_state()
            • MobileNetV1.share_memory()
            • MobileNetV1.state_dict()
            • MobileNetV1.to()
            • MobileNetV1.to_empty()
            • MobileNetV1.train()
            • MobileNetV1.type()
            • MobileNetV1.xpu()
            • MobileNetV1.zero_grad()
      • towhee.models.retina_face.prior_box
        • towhee.models.retina_face.prior_box.PriorBox
          • PriorBox
            • PriorBox.__init__()
      • towhee.models.retina_face.retinaface
        • towhee.models.retina_face.retinaface.RetinaFace
          • RetinaFace
            • RetinaFace.__call__()
            • RetinaFace.__init__()
            • RetinaFace.__repr__()
            • RetinaFace.add_module()
            • RetinaFace.apply()
            • RetinaFace.bfloat16()
            • RetinaFace.buffers()
            • RetinaFace.children()
            • RetinaFace.cpu()
            • RetinaFace.cuda()
            • RetinaFace.double()
            • RetinaFace.eval()
            • RetinaFace.extra_repr()
            • RetinaFace.float()
            • RetinaFace.forward()
            • RetinaFace.get_buffer()
            • RetinaFace.get_extra_state()
            • RetinaFace.get_parameter()
            • RetinaFace.get_submodule()
            • RetinaFace.half()
            • RetinaFace.ipu()
            • RetinaFace.load_state_dict()
            • RetinaFace.modules()
            • RetinaFace.named_buffers()
            • RetinaFace.named_children()
            • RetinaFace.named_modules()
            • RetinaFace.named_parameters()
            • RetinaFace.parameters()
            • RetinaFace.register_backward_hook()
            • RetinaFace.register_buffer()
            • RetinaFace.register_forward_hook()
            • RetinaFace.register_forward_pre_hook()
            • RetinaFace.register_full_backward_hook()
            • RetinaFace.register_full_backward_pre_hook()
            • RetinaFace.register_load_state_dict_post_hook()
            • RetinaFace.register_module()
            • RetinaFace.register_parameter()
            • RetinaFace.register_state_dict_pre_hook()
            • RetinaFace.requires_grad_()
            • RetinaFace.set_extra_state()
            • RetinaFace.share_memory()
            • RetinaFace.state_dict()
            • RetinaFace.to()
            • RetinaFace.to_empty()
            • RetinaFace.train()
            • RetinaFace.type()
            • RetinaFace.xpu()
            • RetinaFace.zero_grad()
      • towhee.models.retina_face.retinaface_fpn
        • towhee.models.retina_face.retinaface_fpn.RetinaFaceFPN
          • RetinaFaceFPN
            • RetinaFaceFPN.__call__()
            • RetinaFaceFPN.__init__()
            • RetinaFaceFPN.__repr__()
            • RetinaFaceFPN.add_module()
            • RetinaFaceFPN.apply()
            • RetinaFaceFPN.bfloat16()
            • RetinaFaceFPN.buffers()
            • RetinaFaceFPN.children()
            • RetinaFaceFPN.cpu()
            • RetinaFaceFPN.cuda()
            • RetinaFaceFPN.double()
            • RetinaFaceFPN.eval()
            • RetinaFaceFPN.extra_repr()
            • RetinaFaceFPN.float()
            • RetinaFaceFPN.forward()
            • RetinaFaceFPN.get_buffer()
            • RetinaFaceFPN.get_extra_state()
            • RetinaFaceFPN.get_parameter()
            • RetinaFaceFPN.get_submodule()
            • RetinaFaceFPN.half()
            • RetinaFaceFPN.ipu()
            • RetinaFaceFPN.load_state_dict()
            • RetinaFaceFPN.modules()
            • RetinaFaceFPN.named_buffers()
            • RetinaFaceFPN.named_children()
            • RetinaFaceFPN.named_modules()
            • RetinaFaceFPN.named_parameters()
            • RetinaFaceFPN.parameters()
            • RetinaFaceFPN.register_backward_hook()
            • RetinaFaceFPN.register_buffer()
            • RetinaFaceFPN.register_forward_hook()
            • RetinaFaceFPN.register_forward_pre_hook()
            • RetinaFaceFPN.register_full_backward_hook()
            • RetinaFaceFPN.register_full_backward_pre_hook()
            • RetinaFaceFPN.register_load_state_dict_post_hook()
            • RetinaFaceFPN.register_module()
            • RetinaFaceFPN.register_parameter()
            • RetinaFaceFPN.register_state_dict_pre_hook()
            • RetinaFaceFPN.requires_grad_()
            • RetinaFaceFPN.set_extra_state()
            • RetinaFaceFPN.share_memory()
            • RetinaFaceFPN.state_dict()
            • RetinaFaceFPN.to()
            • RetinaFaceFPN.to_empty()
            • RetinaFaceFPN.train()
            • RetinaFaceFPN.type()
            • RetinaFaceFPN.xpu()
            • RetinaFaceFPN.zero_grad()
      • towhee.models.retina_face.ssh
        • towhee.models.retina_face.ssh.SSH
          • SSH
            • SSH.__call__()
            • SSH.__init__()
            • SSH.__repr__()
            • SSH.add_module()
            • SSH.apply()
            • SSH.bfloat16()
            • SSH.buffers()
            • SSH.children()
            • SSH.cpu()
            • SSH.cuda()
            • SSH.double()
            • SSH.eval()
            • SSH.extra_repr()
            • SSH.float()
            • SSH.forward()
            • SSH.get_buffer()
            • SSH.get_extra_state()
            • SSH.get_parameter()
            • SSH.get_submodule()
            • SSH.half()
            • SSH.ipu()
            • SSH.load_state_dict()
            • SSH.modules()
            • SSH.named_buffers()
            • SSH.named_children()
            • SSH.named_modules()
            • SSH.named_parameters()
            • SSH.parameters()
            • SSH.register_backward_hook()
            • SSH.register_buffer()
            • SSH.register_forward_hook()
            • SSH.register_forward_pre_hook()
            • SSH.register_full_backward_hook()
            • SSH.register_full_backward_pre_hook()
            • SSH.register_load_state_dict_post_hook()
            • SSH.register_module()
            • SSH.register_parameter()
            • SSH.register_state_dict_pre_hook()
            • SSH.requires_grad_()
            • SSH.set_extra_state()
            • SSH.share_memory()
            • SSH.state_dict()
            • SSH.to()
            • SSH.to_empty()
            • SSH.train()
            • SSH.type()
            • SSH.xpu()
            • SSH.zero_grad()
      • towhee.models.retina_face.utils
        • towhee.models.retina_face.utils.conv_bn
          • conv_bn()
        • towhee.models.retina_face.utils.conv_bn1x1
          • conv_bn1x1()
        • towhee.models.retina_face.utils.conv_bn_no_relu
          • conv_bn_no_relu()
        • towhee.models.retina_face.utils.conv_dw
          • conv_dw()
        • towhee.models.retina_face.utils.decode
          • decode()
        • towhee.models.retina_face.utils.decode_landm
          • decode_landm()
        • towhee.models.retina_face.utils.IntermediateLayerGetter
          • IntermediateLayerGetter
            • IntermediateLayerGetter.__call__()
            • IntermediateLayerGetter.__init__()
            • IntermediateLayerGetter.__repr__()
            • IntermediateLayerGetter.add_module()
            • IntermediateLayerGetter.apply()
            • IntermediateLayerGetter.bfloat16()
            • IntermediateLayerGetter.buffers()
            • IntermediateLayerGetter.children()
            • IntermediateLayerGetter.clear()
            • IntermediateLayerGetter.cpu()
            • IntermediateLayerGetter.cuda()
            • IntermediateLayerGetter.double()
            • IntermediateLayerGetter.eval()
            • IntermediateLayerGetter.extra_repr()
            • IntermediateLayerGetter.float()
            • IntermediateLayerGetter.forward()
            • IntermediateLayerGetter.get_buffer()
            • IntermediateLayerGetter.get_extra_state()
            • IntermediateLayerGetter.get_parameter()
            • IntermediateLayerGetter.get_submodule()
            • IntermediateLayerGetter.half()
            • IntermediateLayerGetter.ipu()
            • IntermediateLayerGetter.items()
            • IntermediateLayerGetter.keys()
            • IntermediateLayerGetter.load_state_dict()
            • IntermediateLayerGetter.modules()
            • IntermediateLayerGetter.named_buffers()
            • IntermediateLayerGetter.named_children()
            • IntermediateLayerGetter.named_modules()
            • IntermediateLayerGetter.named_parameters()
            • IntermediateLayerGetter.parameters()
            • IntermediateLayerGetter.pop()
            • IntermediateLayerGetter.register_backward_hook()
            • IntermediateLayerGetter.register_buffer()
            • IntermediateLayerGetter.register_forward_hook()
            • IntermediateLayerGetter.register_forward_pre_hook()
            • IntermediateLayerGetter.register_full_backward_hook()
            • IntermediateLayerGetter.register_full_backward_pre_hook()
            • IntermediateLayerGetter.register_load_state_dict_post_hook()
            • IntermediateLayerGetter.register_module()
            • IntermediateLayerGetter.register_parameter()
            • IntermediateLayerGetter.register_state_dict_pre_hook()
            • IntermediateLayerGetter.requires_grad_()
            • IntermediateLayerGetter.set_extra_state()
            • IntermediateLayerGetter.share_memory()
            • IntermediateLayerGetter.state_dict()
            • IntermediateLayerGetter.to()
            • IntermediateLayerGetter.to_empty()
            • IntermediateLayerGetter.train()
            • IntermediateLayerGetter.type()
            • IntermediateLayerGetter.update()
            • IntermediateLayerGetter.values()
            • IntermediateLayerGetter.xpu()
            • IntermediateLayerGetter.zero_grad()
    • towhee.models.svt
      • towhee.models.svt.svt
        • towhee.models.svt.svt.create_model
          • create_model()
      • towhee.models.svt.svt_utils
        • towhee.models.svt.svt_utils.get_configs
          • get_configs()
    • towhee.models.swin_transformer
      • towhee.models.swin_transformer.basic_layer
        • towhee.models.swin_transformer.basic_layer.BasicLayer
          • BasicLayer
            • BasicLayer.__call__()
            • BasicLayer.__init__()
            • BasicLayer.__repr__()
            • BasicLayer.add_module()
            • BasicLayer.apply()
            • BasicLayer.bfloat16()
            • BasicLayer.buffers()
            • BasicLayer.children()
            • BasicLayer.cpu()
            • BasicLayer.cuda()
            • BasicLayer.double()
            • BasicLayer.eval()
            • BasicLayer.extra_repr()
            • BasicLayer.float()
            • BasicLayer.forward()
            • BasicLayer.get_buffer()
            • BasicLayer.get_extra_state()
            • BasicLayer.get_parameter()
            • BasicLayer.get_submodule()
            • BasicLayer.half()
            • BasicLayer.ipu()
            • BasicLayer.load_state_dict()
            • BasicLayer.modules()
            • BasicLayer.named_buffers()
            • BasicLayer.named_children()
            • BasicLayer.named_modules()
            • BasicLayer.named_parameters()
            • BasicLayer.parameters()
            • BasicLayer.register_backward_hook()
            • BasicLayer.register_buffer()
            • BasicLayer.register_forward_hook()
            • BasicLayer.register_forward_pre_hook()
            • BasicLayer.register_full_backward_hook()
            • BasicLayer.register_full_backward_pre_hook()
            • BasicLayer.register_load_state_dict_post_hook()
            • BasicLayer.register_module()
            • BasicLayer.register_parameter()
            • BasicLayer.register_state_dict_pre_hook()
            • BasicLayer.requires_grad_()
            • BasicLayer.set_extra_state()
            • BasicLayer.share_memory()
            • BasicLayer.state_dict()
            • BasicLayer.to()
            • BasicLayer.to_empty()
            • BasicLayer.train()
            • BasicLayer.type()
            • BasicLayer.xpu()
            • BasicLayer.zero_grad()
      • towhee.models.swin_transformer.configs
        • towhee.models.swin_transformer.configs.build_configs
          • build_configs()
      • towhee.models.swin_transformer.model
        • towhee.models.swin_transformer.model.SwinTransformer
          • SwinTransformer
            • SwinTransformer.__call__()
            • SwinTransformer.__init__()
            • SwinTransformer.__repr__()
            • SwinTransformer.add_module()
            • SwinTransformer.apply()
            • SwinTransformer.bfloat16()
            • SwinTransformer.buffers()
            • SwinTransformer.children()
            • SwinTransformer.cpu()
            • SwinTransformer.cuda()
            • SwinTransformer.double()
            • SwinTransformer.eval()
            • SwinTransformer.extra_repr()
            • SwinTransformer.float()
            • SwinTransformer.forward()
            • SwinTransformer.get_buffer()
            • SwinTransformer.get_extra_state()
            • SwinTransformer.get_parameter()
            • SwinTransformer.get_submodule()
            • SwinTransformer.half()
            • SwinTransformer.ipu()
            • SwinTransformer.load_state_dict()
            • SwinTransformer.modules()
            • SwinTransformer.named_buffers()
            • SwinTransformer.named_children()
            • SwinTransformer.named_modules()
            • SwinTransformer.named_parameters()
            • SwinTransformer.parameters()
            • SwinTransformer.register_backward_hook()
            • SwinTransformer.register_buffer()
            • SwinTransformer.register_forward_hook()
            • SwinTransformer.register_forward_pre_hook()
            • SwinTransformer.register_full_backward_hook()
            • SwinTransformer.register_full_backward_pre_hook()
            • SwinTransformer.register_load_state_dict_post_hook()
            • SwinTransformer.register_module()
            • SwinTransformer.register_parameter()
            • SwinTransformer.register_state_dict_pre_hook()
            • SwinTransformer.requires_grad_()
            • SwinTransformer.set_extra_state()
            • SwinTransformer.share_memory()
            • SwinTransformer.state_dict()
            • SwinTransformer.to()
            • SwinTransformer.to_empty()
            • SwinTransformer.train()
            • SwinTransformer.type()
            • SwinTransformer.xpu()
            • SwinTransformer.zero_grad()
      • towhee.models.swin_transformer.swin_transformer_block
        • towhee.models.swin_transformer.swin_transformer_block.SwinTransformerBlock
          • SwinTransformerBlock
            • SwinTransformerBlock.__call__()
            • SwinTransformerBlock.__init__()
            • SwinTransformerBlock.__repr__()
            • SwinTransformerBlock.add_module()
            • SwinTransformerBlock.apply()
            • SwinTransformerBlock.bfloat16()
            • SwinTransformerBlock.buffers()
            • SwinTransformerBlock.children()
            • SwinTransformerBlock.cpu()
            • SwinTransformerBlock.cuda()
            • SwinTransformerBlock.double()
            • SwinTransformerBlock.eval()
            • SwinTransformerBlock.extra_repr()
            • SwinTransformerBlock.float()
            • SwinTransformerBlock.forward()
            • SwinTransformerBlock.get_buffer()
            • SwinTransformerBlock.get_extra_state()
            • SwinTransformerBlock.get_parameter()
            • SwinTransformerBlock.get_submodule()
            • SwinTransformerBlock.half()
            • SwinTransformerBlock.ipu()
            • SwinTransformerBlock.load_state_dict()
            • SwinTransformerBlock.modules()
            • SwinTransformerBlock.named_buffers()
            • SwinTransformerBlock.named_children()
            • SwinTransformerBlock.named_modules()
            • SwinTransformerBlock.named_parameters()
            • SwinTransformerBlock.parameters()
            • SwinTransformerBlock.register_backward_hook()
            • SwinTransformerBlock.register_buffer()
            • SwinTransformerBlock.register_forward_hook()
            • SwinTransformerBlock.register_forward_pre_hook()
            • SwinTransformerBlock.register_full_backward_hook()
            • SwinTransformerBlock.register_full_backward_pre_hook()
            • SwinTransformerBlock.register_load_state_dict_post_hook()
            • SwinTransformerBlock.register_module()
            • SwinTransformerBlock.register_parameter()
            • SwinTransformerBlock.register_state_dict_pre_hook()
            • SwinTransformerBlock.requires_grad_()
            • SwinTransformerBlock.set_extra_state()
            • SwinTransformerBlock.share_memory()
            • SwinTransformerBlock.state_dict()
            • SwinTransformerBlock.to()
            • SwinTransformerBlock.to_empty()
            • SwinTransformerBlock.train()
            • SwinTransformerBlock.type()
            • SwinTransformerBlock.xpu()
            • SwinTransformerBlock.zero_grad()
    • towhee.models.timesformer
      • towhee.models.timesformer.timesformer
        • towhee.models.timesformer.timesformer.create_model
          • create_model()
        • towhee.models.timesformer.timesformer.TimeSformer
          • TimeSformer
            • TimeSformer.__call__()
            • TimeSformer.__init__()
            • TimeSformer.__repr__()
            • TimeSformer.add_module()
            • TimeSformer.apply()
            • TimeSformer.bfloat16()
            • TimeSformer.buffers()
            • TimeSformer.children()
            • TimeSformer.cpu()
            • TimeSformer.cuda()
            • TimeSformer.double()
            • TimeSformer.eval()
            • TimeSformer.extra_repr()
            • TimeSformer.float()
            • TimeSformer.forward()
            • TimeSformer.get_buffer()
            • TimeSformer.get_extra_state()
            • TimeSformer.get_parameter()
            • TimeSformer.get_submodule()
            • TimeSformer.half()
            • TimeSformer.ipu()
            • TimeSformer.load_state_dict()
            • TimeSformer.modules()
            • TimeSformer.named_buffers()
            • TimeSformer.named_children()
            • TimeSformer.named_modules()
            • TimeSformer.named_parameters()
            • TimeSformer.parameters()
            • TimeSformer.register_backward_hook()
            • TimeSformer.register_buffer()
            • TimeSformer.register_forward_hook()
            • TimeSformer.register_forward_pre_hook()
            • TimeSformer.register_full_backward_hook()
            • TimeSformer.register_full_backward_pre_hook()
            • TimeSformer.register_load_state_dict_post_hook()
            • TimeSformer.register_module()
            • TimeSformer.register_parameter()
            • TimeSformer.register_state_dict_pre_hook()
            • TimeSformer.requires_grad_()
            • TimeSformer.set_extra_state()
            • TimeSformer.share_memory()
            • TimeSformer.state_dict()
            • TimeSformer.to()
            • TimeSformer.to_empty()
            • TimeSformer.train()
            • TimeSformer.type()
            • TimeSformer.xpu()
            • TimeSformer.zero_grad()
      • towhee.models.timesformer.timesformer_block
        • towhee.models.timesformer.timesformer_block.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.timesformer.timesformer_utils
        • towhee.models.timesformer.timesformer_utils.get_configs
          • get_configs()
        • towhee.models.timesformer.timesformer_utils.load_pretrained
          • load_pretrained()
        • towhee.models.timesformer.timesformer_utils.map_state_dict
          • map_state_dict()
    • towhee.models.transrac
      • towhee.models.transrac.transrac
        • towhee.models.transrac.transrac.TransRAC
          • TransRAC
            • TransRAC.__call__()
            • TransRAC.__init__()
            • TransRAC.__repr__()
            • TransRAC.add_module()
            • TransRAC.apply()
            • TransRAC.bfloat16()
            • TransRAC.buffers()
            • TransRAC.children()
            • TransRAC.cpu()
            • TransRAC.cuda()
            • TransRAC.double()
            • TransRAC.eval()
            • TransRAC.extra_repr()
            • TransRAC.float()
            • TransRAC.forward()
            • TransRAC.get_buffer()
            • TransRAC.get_extra_state()
            • TransRAC.get_parameter()
            • TransRAC.get_submodule()
            • TransRAC.half()
            • TransRAC.ipu()
            • TransRAC.load_state_dict()
            • TransRAC.modules()
            • TransRAC.named_buffers()
            • TransRAC.named_children()
            • TransRAC.named_modules()
            • TransRAC.named_parameters()
            • TransRAC.parameters()
            • TransRAC.register_backward_hook()
            • TransRAC.register_buffer()
            • TransRAC.register_forward_hook()
            • TransRAC.register_forward_pre_hook()
            • TransRAC.register_full_backward_hook()
            • TransRAC.register_full_backward_pre_hook()
            • TransRAC.register_load_state_dict_post_hook()
            • TransRAC.register_module()
            • TransRAC.register_parameter()
            • TransRAC.register_state_dict_pre_hook()
            • TransRAC.requires_grad_()
            • TransRAC.set_extra_state()
            • TransRAC.share_memory()
            • TransRAC.state_dict()
            • TransRAC.to()
            • TransRAC.to_empty()
            • TransRAC.train()
            • TransRAC.type()
            • TransRAC.xpu()
            • TransRAC.zero_grad()
      • towhee.models.transrac.utils
        • towhee.models.transrac.utils.DenseMap
          • DenseMap
            • DenseMap.__call__()
            • DenseMap.__init__()
            • DenseMap.__repr__()
            • DenseMap.add_module()
            • DenseMap.apply()
            • DenseMap.bfloat16()
            • DenseMap.buffers()
            • DenseMap.children()
            • DenseMap.cpu()
            • DenseMap.cuda()
            • DenseMap.double()
            • DenseMap.eval()
            • DenseMap.extra_repr()
            • DenseMap.float()
            • DenseMap.forward()
            • DenseMap.get_buffer()
            • DenseMap.get_extra_state()
            • DenseMap.get_parameter()
            • DenseMap.get_submodule()
            • DenseMap.half()
            • DenseMap.ipu()
            • DenseMap.load_state_dict()
            • DenseMap.modules()
            • DenseMap.named_buffers()
            • DenseMap.named_children()
            • DenseMap.named_modules()
            • DenseMap.named_parameters()
            • DenseMap.parameters()
            • DenseMap.register_backward_hook()
            • DenseMap.register_buffer()
            • DenseMap.register_forward_hook()
            • DenseMap.register_forward_pre_hook()
            • DenseMap.register_full_backward_hook()
            • DenseMap.register_full_backward_pre_hook()
            • DenseMap.register_load_state_dict_post_hook()
            • DenseMap.register_module()
            • DenseMap.register_parameter()
            • DenseMap.register_state_dict_pre_hook()
            • DenseMap.requires_grad_()
            • DenseMap.set_extra_state()
            • DenseMap.share_memory()
            • DenseMap.state_dict()
            • DenseMap.to()
            • DenseMap.to_empty()
            • DenseMap.train()
            • DenseMap.type()
            • DenseMap.xpu()
            • DenseMap.zero_grad()
        • towhee.models.transrac.utils.SimilarityMatrix
          • SimilarityMatrix
            • SimilarityMatrix.__call__()
            • SimilarityMatrix.__init__()
            • SimilarityMatrix.__repr__()
            • SimilarityMatrix.add_module()
            • SimilarityMatrix.apply()
            • SimilarityMatrix.bfloat16()
            • SimilarityMatrix.buffers()
            • SimilarityMatrix.children()
            • SimilarityMatrix.cpu()
            • SimilarityMatrix.cuda()
            • SimilarityMatrix.double()
            • SimilarityMatrix.eval()
            • SimilarityMatrix.extra_repr()
            • SimilarityMatrix.float()
            • SimilarityMatrix.forward()
            • SimilarityMatrix.get_buffer()
            • SimilarityMatrix.get_extra_state()
            • SimilarityMatrix.get_parameter()
            • SimilarityMatrix.get_submodule()
            • SimilarityMatrix.half()
            • SimilarityMatrix.ipu()
            • SimilarityMatrix.load_state_dict()
            • SimilarityMatrix.modules()
            • SimilarityMatrix.named_buffers()
            • SimilarityMatrix.named_children()
            • SimilarityMatrix.named_modules()
            • SimilarityMatrix.named_parameters()
            • SimilarityMatrix.parameters()
            • SimilarityMatrix.register_backward_hook()
            • SimilarityMatrix.register_buffer()
            • SimilarityMatrix.register_forward_hook()
            • SimilarityMatrix.register_forward_pre_hook()
            • SimilarityMatrix.register_full_backward_hook()
            • SimilarityMatrix.register_full_backward_pre_hook()
            • SimilarityMatrix.register_load_state_dict_post_hook()
            • SimilarityMatrix.register_module()
            • SimilarityMatrix.register_parameter()
            • SimilarityMatrix.register_state_dict_pre_hook()
            • SimilarityMatrix.requires_grad_()
            • SimilarityMatrix.set_extra_state()
            • SimilarityMatrix.share_memory()
            • SimilarityMatrix.state_dict()
            • SimilarityMatrix.to()
            • SimilarityMatrix.to_empty()
            • SimilarityMatrix.train()
            • SimilarityMatrix.type()
            • SimilarityMatrix.xpu()
            • SimilarityMatrix.zero_grad()
    • towhee.models.tsm
      • towhee.models.tsm.config
      • towhee.models.tsm.mobilenet_v2
        • towhee.models.tsm.mobilenet_v2.conv_1x1_bn
          • conv_1x1_bn()
        • towhee.models.tsm.mobilenet_v2.conv_bn
          • conv_bn()
        • towhee.models.tsm.mobilenet_v2.make_divisible
          • make_divisible()
        • towhee.models.tsm.mobilenet_v2.mobilenet_v2
          • mobilenet_v2()
        • towhee.models.tsm.mobilenet_v2.InvertedResidual
          • InvertedResidual
            • InvertedResidual.__call__()
            • InvertedResidual.__init__()
            • InvertedResidual.__repr__()
            • InvertedResidual.add_module()
            • InvertedResidual.apply()
            • InvertedResidual.bfloat16()
            • InvertedResidual.buffers()
            • InvertedResidual.children()
            • InvertedResidual.cpu()
            • InvertedResidual.cuda()
            • InvertedResidual.double()
            • InvertedResidual.eval()
            • InvertedResidual.extra_repr()
            • InvertedResidual.float()
            • InvertedResidual.forward()
            • InvertedResidual.get_buffer()
            • InvertedResidual.get_extra_state()
            • InvertedResidual.get_parameter()
            • InvertedResidual.get_submodule()
            • InvertedResidual.half()
            • InvertedResidual.ipu()
            • InvertedResidual.load_state_dict()
            • InvertedResidual.modules()
            • InvertedResidual.named_buffers()
            • InvertedResidual.named_children()
            • InvertedResidual.named_modules()
            • InvertedResidual.named_parameters()
            • InvertedResidual.parameters()
            • InvertedResidual.register_backward_hook()
            • InvertedResidual.register_buffer()
            • InvertedResidual.register_forward_hook()
            • InvertedResidual.register_forward_pre_hook()
            • InvertedResidual.register_full_backward_hook()
            • InvertedResidual.register_full_backward_pre_hook()
            • InvertedResidual.register_load_state_dict_post_hook()
            • InvertedResidual.register_module()
            • InvertedResidual.register_parameter()
            • InvertedResidual.register_state_dict_pre_hook()
            • InvertedResidual.requires_grad_()
            • InvertedResidual.set_extra_state()
            • InvertedResidual.share_memory()
            • InvertedResidual.state_dict()
            • InvertedResidual.to()
            • InvertedResidual.to_empty()
            • InvertedResidual.train()
            • InvertedResidual.type()
            • InvertedResidual.xpu()
            • InvertedResidual.zero_grad()
        • towhee.models.tsm.mobilenet_v2.MobileNetV2
          • MobileNetV2
            • MobileNetV2.__call__()
            • MobileNetV2.__init__()
            • MobileNetV2.__repr__()
            • MobileNetV2.add_module()
            • MobileNetV2.apply()
            • MobileNetV2.bfloat16()
            • MobileNetV2.buffers()
            • MobileNetV2.children()
            • MobileNetV2.cpu()
            • MobileNetV2.cuda()
            • MobileNetV2.double()
            • MobileNetV2.eval()
            • MobileNetV2.extra_repr()
            • MobileNetV2.float()
            • MobileNetV2.forward()
            • MobileNetV2.get_buffer()
            • MobileNetV2.get_extra_state()
            • MobileNetV2.get_parameter()
            • MobileNetV2.get_submodule()
            • MobileNetV2.half()
            • MobileNetV2.ipu()
            • MobileNetV2.load_state_dict()
            • MobileNetV2.modules()
            • MobileNetV2.named_buffers()
            • MobileNetV2.named_children()
            • MobileNetV2.named_modules()
            • MobileNetV2.named_parameters()
            • MobileNetV2.parameters()
            • MobileNetV2.register_backward_hook()
            • MobileNetV2.register_buffer()
            • MobileNetV2.register_forward_hook()
            • MobileNetV2.register_forward_pre_hook()
            • MobileNetV2.register_full_backward_hook()
            • MobileNetV2.register_full_backward_pre_hook()
            • MobileNetV2.register_load_state_dict_post_hook()
            • MobileNetV2.register_module()
            • MobileNetV2.register_parameter()
            • MobileNetV2.register_state_dict_pre_hook()
            • MobileNetV2.requires_grad_()
            • MobileNetV2.set_extra_state()
            • MobileNetV2.share_memory()
            • MobileNetV2.state_dict()
            • MobileNetV2.to()
            • MobileNetV2.to_empty()
            • MobileNetV2.train()
            • MobileNetV2.type()
            • MobileNetV2.xpu()
            • MobileNetV2.zero_grad()
      • towhee.models.tsm.temporal_shift
        • towhee.models.tsm.temporal_shift.make_temporal_pool
          • make_temporal_pool()
        • towhee.models.tsm.temporal_shift.make_temporal_shift
          • make_temporal_shift()
        • towhee.models.tsm.temporal_shift.InplaceShift
          • InplaceShift
            • InplaceShift.__call__()
            • InplaceShift.__init__()
            • InplaceShift.backward()
            • InplaceShift.forward()
            • InplaceShift.is_traceable
            • InplaceShift.jvp()
            • InplaceShift.mark_dirty()
            • InplaceShift.mark_non_differentiable()
            • InplaceShift.save_for_backward()
            • InplaceShift.save_for_forward()
            • InplaceShift.set_materialize_grads()
            • InplaceShift.setup_context()
            • InplaceShift.vjp()
            • InplaceShift.vmap()
        • towhee.models.tsm.temporal_shift.TemporalPool
          • TemporalPool
            • TemporalPool.__call__()
            • TemporalPool.__init__()
            • TemporalPool.__repr__()
            • TemporalPool.add_module()
            • TemporalPool.apply()
            • TemporalPool.bfloat16()
            • TemporalPool.buffers()
            • TemporalPool.children()
            • TemporalPool.cpu()
            • TemporalPool.cuda()
            • TemporalPool.double()
            • TemporalPool.eval()
            • TemporalPool.extra_repr()
            • TemporalPool.float()
            • TemporalPool.forward()
            • TemporalPool.get_buffer()
            • TemporalPool.get_extra_state()
            • TemporalPool.get_parameter()
            • TemporalPool.get_submodule()
            • TemporalPool.half()
            • TemporalPool.ipu()
            • TemporalPool.load_state_dict()
            • TemporalPool.modules()
            • TemporalPool.named_buffers()
            • TemporalPool.named_children()
            • TemporalPool.named_modules()
            • TemporalPool.named_parameters()
            • TemporalPool.parameters()
            • TemporalPool.register_backward_hook()
            • TemporalPool.register_buffer()
            • TemporalPool.register_forward_hook()
            • TemporalPool.register_forward_pre_hook()
            • TemporalPool.register_full_backward_hook()
            • TemporalPool.register_full_backward_pre_hook()
            • TemporalPool.register_load_state_dict_post_hook()
            • TemporalPool.register_module()
            • TemporalPool.register_parameter()
            • TemporalPool.register_state_dict_pre_hook()
            • TemporalPool.requires_grad_()
            • TemporalPool.set_extra_state()
            • TemporalPool.share_memory()
            • TemporalPool.state_dict()
            • TemporalPool.to()
            • TemporalPool.to_empty()
            • TemporalPool.train()
            • TemporalPool.type()
            • TemporalPool.xpu()
            • TemporalPool.zero_grad()
        • towhee.models.tsm.temporal_shift.TemporalShift
          • TemporalShift
            • TemporalShift.__call__()
            • TemporalShift.__init__()
            • TemporalShift.__repr__()
            • TemporalShift.add_module()
            • TemporalShift.apply()
            • TemporalShift.bfloat16()
            • TemporalShift.buffers()
            • TemporalShift.children()
            • TemporalShift.cpu()
            • TemporalShift.cuda()
            • TemporalShift.double()
            • TemporalShift.eval()
            • TemporalShift.extra_repr()
            • TemporalShift.float()
            • TemporalShift.forward()
            • TemporalShift.get_buffer()
            • TemporalShift.get_extra_state()
            • TemporalShift.get_parameter()
            • TemporalShift.get_submodule()
            • TemporalShift.half()
            • TemporalShift.ipu()
            • TemporalShift.load_state_dict()
            • TemporalShift.modules()
            • TemporalShift.named_buffers()
            • TemporalShift.named_children()
            • TemporalShift.named_modules()
            • TemporalShift.named_parameters()
            • TemporalShift.parameters()
            • TemporalShift.register_backward_hook()
            • TemporalShift.register_buffer()
            • TemporalShift.register_forward_hook()
            • TemporalShift.register_forward_pre_hook()
            • TemporalShift.register_full_backward_hook()
            • TemporalShift.register_full_backward_pre_hook()
            • TemporalShift.register_load_state_dict_post_hook()
            • TemporalShift.register_module()
            • TemporalShift.register_parameter()
            • TemporalShift.register_state_dict_pre_hook()
            • TemporalShift.requires_grad_()
            • TemporalShift.set_extra_state()
            • TemporalShift.share_memory()
            • TemporalShift.state_dict()
            • TemporalShift.to()
            • TemporalShift.to_empty()
            • TemporalShift.train()
            • TemporalShift.type()
            • TemporalShift.xpu()
            • TemporalShift.zero_grad()
      • towhee.models.tsm.tsm
        • towhee.models.tsm.tsm.create_model
          • create_model()
        • towhee.models.tsm.tsm.TSN
          • TSN
            • TSN.__call__()
            • TSN.__init__()
            • TSN.__repr__()
            • TSN.add_module()
            • TSN.apply()
            • TSN.bfloat16()
            • TSN.buffers()
            • TSN.children()
            • TSN.cpu()
            • TSN.cuda()
            • TSN.double()
            • TSN.eval()
            • TSN.extra_repr()
            • TSN.float()
            • TSN.forward()
            • TSN.get_buffer()
            • TSN.get_extra_state()
            • TSN.get_parameter()
            • TSN.get_submodule()
            • TSN.half()
            • TSN.ipu()
            • TSN.load_state_dict()
            • TSN.modules()
            • TSN.named_buffers()
            • TSN.named_children()
            • TSN.named_modules()
            • TSN.named_parameters()
            • TSN.parameters()
            • TSN.register_backward_hook()
            • TSN.register_buffer()
            • TSN.register_forward_hook()
            • TSN.register_forward_pre_hook()
            • TSN.register_full_backward_hook()
            • TSN.register_full_backward_pre_hook()
            • TSN.register_load_state_dict_post_hook()
            • TSN.register_module()
            • TSN.register_parameter()
            • TSN.register_state_dict_pre_hook()
            • TSN.requires_grad_()
            • TSN.set_extra_state()
            • TSN.share_memory()
            • TSN.state_dict()
            • TSN.to()
            • TSN.to_empty()
            • TSN.train()
            • TSN.type()
            • TSN.xpu()
            • TSN.zero_grad()
    • towhee.models.uniformer
      • towhee.models.uniformer.config
      • towhee.models.uniformer.uniformer
        • towhee.models.uniformer.uniformer.bn_3d
          • bn_3d()
        • towhee.models.uniformer.uniformer.conv_1x1x1
          • conv_1x1x1()
        • towhee.models.uniformer.uniformer.conv_1xnxn
          • conv_1xnxn()
        • towhee.models.uniformer.uniformer.conv_3x3x3
          • conv_3x3x3()
        • towhee.models.uniformer.uniformer.conv_3xnxn
          • conv_3xnxn()
        • towhee.models.uniformer.uniformer.conv_3xnxn_std
          • conv_3xnxn_std()
        • towhee.models.uniformer.uniformer.conv_5x5x5
          • conv_5x5x5()
        • towhee.models.uniformer.uniformer.create_model
          • create_model()
        • towhee.models.uniformer.uniformer.CBlock
          • CBlock
            • CBlock.__call__()
            • CBlock.__init__()
            • CBlock.__repr__()
            • CBlock.add_module()
            • CBlock.apply()
            • CBlock.bfloat16()
            • CBlock.buffers()
            • CBlock.children()
            • CBlock.cpu()
            • CBlock.cuda()
            • CBlock.double()
            • CBlock.eval()
            • CBlock.extra_repr()
            • CBlock.float()
            • CBlock.forward()
            • CBlock.get_buffer()
            • CBlock.get_extra_state()
            • CBlock.get_parameter()
            • CBlock.get_submodule()
            • CBlock.half()
            • CBlock.ipu()
            • CBlock.load_state_dict()
            • CBlock.modules()
            • CBlock.named_buffers()
            • CBlock.named_children()
            • CBlock.named_modules()
            • CBlock.named_parameters()
            • CBlock.parameters()
            • CBlock.register_backward_hook()
            • CBlock.register_buffer()
            • CBlock.register_forward_hook()
            • CBlock.register_forward_pre_hook()
            • CBlock.register_full_backward_hook()
            • CBlock.register_full_backward_pre_hook()
            • CBlock.register_load_state_dict_post_hook()
            • CBlock.register_module()
            • CBlock.register_parameter()
            • CBlock.register_state_dict_pre_hook()
            • CBlock.requires_grad_()
            • CBlock.set_extra_state()
            • CBlock.share_memory()
            • CBlock.state_dict()
            • CBlock.to()
            • CBlock.to_empty()
            • CBlock.train()
            • CBlock.type()
            • CBlock.xpu()
            • CBlock.zero_grad()
        • towhee.models.uniformer.uniformer.CMlp
          • CMlp
            • CMlp.__call__()
            • CMlp.__init__()
            • CMlp.__repr__()
            • CMlp.add_module()
            • CMlp.apply()
            • CMlp.bfloat16()
            • CMlp.buffers()
            • CMlp.children()
            • CMlp.cpu()
            • CMlp.cuda()
            • CMlp.double()
            • CMlp.eval()
            • CMlp.extra_repr()
            • CMlp.float()
            • CMlp.forward()
            • CMlp.get_buffer()
            • CMlp.get_extra_state()
            • CMlp.get_parameter()
            • CMlp.get_submodule()
            • CMlp.half()
            • CMlp.ipu()
            • CMlp.load_state_dict()
            • CMlp.modules()
            • CMlp.named_buffers()
            • CMlp.named_children()
            • CMlp.named_modules()
            • CMlp.named_parameters()
            • CMlp.parameters()
            • CMlp.register_backward_hook()
            • CMlp.register_buffer()
            • CMlp.register_forward_hook()
            • CMlp.register_forward_pre_hook()
            • CMlp.register_full_backward_hook()
            • CMlp.register_full_backward_pre_hook()
            • CMlp.register_load_state_dict_post_hook()
            • CMlp.register_module()
            • CMlp.register_parameter()
            • CMlp.register_state_dict_pre_hook()
            • CMlp.requires_grad_()
            • CMlp.set_extra_state()
            • CMlp.share_memory()
            • CMlp.state_dict()
            • CMlp.to()
            • CMlp.to_empty()
            • CMlp.train()
            • CMlp.type()
            • CMlp.xpu()
            • CMlp.zero_grad()
        • towhee.models.uniformer.uniformer.PatchEmbed
          • PatchEmbed
            • PatchEmbed.__call__()
            • PatchEmbed.__init__()
            • PatchEmbed.__repr__()
            • PatchEmbed.add_module()
            • PatchEmbed.apply()
            • PatchEmbed.bfloat16()
            • PatchEmbed.buffers()
            • PatchEmbed.children()
            • PatchEmbed.cpu()
            • PatchEmbed.cuda()
            • PatchEmbed.double()
            • PatchEmbed.eval()
            • PatchEmbed.extra_repr()
            • PatchEmbed.float()
            • PatchEmbed.forward()
            • PatchEmbed.get_buffer()
            • PatchEmbed.get_extra_state()
            • PatchEmbed.get_parameter()
            • PatchEmbed.get_submodule()
            • PatchEmbed.half()
            • PatchEmbed.ipu()
            • PatchEmbed.load_state_dict()
            • PatchEmbed.modules()
            • PatchEmbed.named_buffers()
            • PatchEmbed.named_children()
            • PatchEmbed.named_modules()
            • PatchEmbed.named_parameters()
            • PatchEmbed.parameters()
            • PatchEmbed.register_backward_hook()
            • PatchEmbed.register_buffer()
            • PatchEmbed.register_forward_hook()
            • PatchEmbed.register_forward_pre_hook()
            • PatchEmbed.register_full_backward_hook()
            • PatchEmbed.register_full_backward_pre_hook()
            • PatchEmbed.register_load_state_dict_post_hook()
            • PatchEmbed.register_module()
            • PatchEmbed.register_parameter()
            • PatchEmbed.register_state_dict_pre_hook()
            • PatchEmbed.requires_grad_()
            • PatchEmbed.set_extra_state()
            • PatchEmbed.share_memory()
            • PatchEmbed.state_dict()
            • PatchEmbed.to()
            • PatchEmbed.to_empty()
            • PatchEmbed.train()
            • PatchEmbed.type()
            • PatchEmbed.xpu()
            • PatchEmbed.zero_grad()
        • towhee.models.uniformer.uniformer.SABlock
          • SABlock
            • SABlock.__call__()
            • SABlock.__init__()
            • SABlock.__repr__()
            • SABlock.add_module()
            • SABlock.apply()
            • SABlock.bfloat16()
            • SABlock.buffers()
            • SABlock.children()
            • SABlock.cpu()
            • SABlock.cuda()
            • SABlock.double()
            • SABlock.eval()
            • SABlock.extra_repr()
            • SABlock.float()
            • SABlock.forward()
            • SABlock.get_buffer()
            • SABlock.get_extra_state()
            • SABlock.get_parameter()
            • SABlock.get_submodule()
            • SABlock.half()
            • SABlock.ipu()
            • SABlock.load_state_dict()
            • SABlock.modules()
            • SABlock.named_buffers()
            • SABlock.named_children()
            • SABlock.named_modules()
            • SABlock.named_parameters()
            • SABlock.parameters()
            • SABlock.register_backward_hook()
            • SABlock.register_buffer()
            • SABlock.register_forward_hook()
            • SABlock.register_forward_pre_hook()
            • SABlock.register_full_backward_hook()
            • SABlock.register_full_backward_pre_hook()
            • SABlock.register_load_state_dict_post_hook()
            • SABlock.register_module()
            • SABlock.register_parameter()
            • SABlock.register_state_dict_pre_hook()
            • SABlock.requires_grad_()
            • SABlock.set_extra_state()
            • SABlock.share_memory()
            • SABlock.state_dict()
            • SABlock.to()
            • SABlock.to_empty()
            • SABlock.train()
            • SABlock.type()
            • SABlock.xpu()
            • SABlock.zero_grad()
        • towhee.models.uniformer.uniformer.SpeicalPatchEmbed
          • SpeicalPatchEmbed
            • SpeicalPatchEmbed.__call__()
            • SpeicalPatchEmbed.__init__()
            • SpeicalPatchEmbed.__repr__()
            • SpeicalPatchEmbed.add_module()
            • SpeicalPatchEmbed.apply()
            • SpeicalPatchEmbed.bfloat16()
            • SpeicalPatchEmbed.buffers()
            • SpeicalPatchEmbed.children()
            • SpeicalPatchEmbed.cpu()
            • SpeicalPatchEmbed.cuda()
            • SpeicalPatchEmbed.double()
            • SpeicalPatchEmbed.eval()
            • SpeicalPatchEmbed.extra_repr()
            • SpeicalPatchEmbed.float()
            • SpeicalPatchEmbed.forward()
            • SpeicalPatchEmbed.get_buffer()
            • SpeicalPatchEmbed.get_extra_state()
            • SpeicalPatchEmbed.get_parameter()
            • SpeicalPatchEmbed.get_submodule()
            • SpeicalPatchEmbed.half()
            • SpeicalPatchEmbed.ipu()
            • SpeicalPatchEmbed.load_state_dict()
            • SpeicalPatchEmbed.modules()
            • SpeicalPatchEmbed.named_buffers()
            • SpeicalPatchEmbed.named_children()
            • SpeicalPatchEmbed.named_modules()
            • SpeicalPatchEmbed.named_parameters()
            • SpeicalPatchEmbed.parameters()
            • SpeicalPatchEmbed.register_backward_hook()
            • SpeicalPatchEmbed.register_buffer()
            • SpeicalPatchEmbed.register_forward_hook()
            • SpeicalPatchEmbed.register_forward_pre_hook()
            • SpeicalPatchEmbed.register_full_backward_hook()
            • SpeicalPatchEmbed.register_full_backward_pre_hook()
            • SpeicalPatchEmbed.register_load_state_dict_post_hook()
            • SpeicalPatchEmbed.register_module()
            • SpeicalPatchEmbed.register_parameter()
            • SpeicalPatchEmbed.register_state_dict_pre_hook()
            • SpeicalPatchEmbed.requires_grad_()
            • SpeicalPatchEmbed.set_extra_state()
            • SpeicalPatchEmbed.share_memory()
            • SpeicalPatchEmbed.state_dict()
            • SpeicalPatchEmbed.to()
            • SpeicalPatchEmbed.to_empty()
            • SpeicalPatchEmbed.train()
            • SpeicalPatchEmbed.type()
            • SpeicalPatchEmbed.xpu()
            • SpeicalPatchEmbed.zero_grad()
        • towhee.models.uniformer.uniformer.SplitSABlock
          • SplitSABlock
            • SplitSABlock.__call__()
            • SplitSABlock.__init__()
            • SplitSABlock.__repr__()
            • SplitSABlock.add_module()
            • SplitSABlock.apply()
            • SplitSABlock.bfloat16()
            • SplitSABlock.buffers()
            • SplitSABlock.children()
            • SplitSABlock.cpu()
            • SplitSABlock.cuda()
            • SplitSABlock.double()
            • SplitSABlock.eval()
            • SplitSABlock.extra_repr()
            • SplitSABlock.float()
            • SplitSABlock.forward()
            • SplitSABlock.get_buffer()
            • SplitSABlock.get_extra_state()
            • SplitSABlock.get_parameter()
            • SplitSABlock.get_submodule()
            • SplitSABlock.half()
            • SplitSABlock.ipu()
            • SplitSABlock.load_state_dict()
            • SplitSABlock.modules()
            • SplitSABlock.named_buffers()
            • SplitSABlock.named_children()
            • SplitSABlock.named_modules()
            • SplitSABlock.named_parameters()
            • SplitSABlock.parameters()
            • SplitSABlock.register_backward_hook()
            • SplitSABlock.register_buffer()
            • SplitSABlock.register_forward_hook()
            • SplitSABlock.register_forward_pre_hook()
            • SplitSABlock.register_full_backward_hook()
            • SplitSABlock.register_full_backward_pre_hook()
            • SplitSABlock.register_load_state_dict_post_hook()
            • SplitSABlock.register_module()
            • SplitSABlock.register_parameter()
            • SplitSABlock.register_state_dict_pre_hook()
            • SplitSABlock.requires_grad_()
            • SplitSABlock.set_extra_state()
            • SplitSABlock.share_memory()
            • SplitSABlock.state_dict()
            • SplitSABlock.to()
            • SplitSABlock.to_empty()
            • SplitSABlock.train()
            • SplitSABlock.type()
            • SplitSABlock.xpu()
            • SplitSABlock.zero_grad()
        • towhee.models.uniformer.uniformer.Uniformer
          • Uniformer
            • Uniformer.__call__()
            • Uniformer.__init__()
            • Uniformer.__repr__()
            • Uniformer.add_module()
            • Uniformer.apply()
            • Uniformer.bfloat16()
            • Uniformer.buffers()
            • Uniformer.children()
            • Uniformer.cpu()
            • Uniformer.cuda()
            • Uniformer.double()
            • Uniformer.eval()
            • Uniformer.extra_repr()
            • Uniformer.float()
            • Uniformer.forward()
            • Uniformer.get_buffer()
            • Uniformer.get_extra_state()
            • Uniformer.get_parameter()
            • Uniformer.get_submodule()
            • Uniformer.half()
            • Uniformer.ipu()
            • Uniformer.load_state_dict()
            • Uniformer.modules()
            • Uniformer.named_buffers()
            • Uniformer.named_children()
            • Uniformer.named_modules()
            • Uniformer.named_parameters()
            • Uniformer.parameters()
            • Uniformer.register_backward_hook()
            • Uniformer.register_buffer()
            • Uniformer.register_forward_hook()
            • Uniformer.register_forward_pre_hook()
            • Uniformer.register_full_backward_hook()
            • Uniformer.register_full_backward_pre_hook()
            • Uniformer.register_load_state_dict_post_hook()
            • Uniformer.register_module()
            • Uniformer.register_parameter()
            • Uniformer.register_state_dict_pre_hook()
            • Uniformer.requires_grad_()
            • Uniformer.set_extra_state()
            • Uniformer.share_memory()
            • Uniformer.state_dict()
            • Uniformer.to()
            • Uniformer.to_empty()
            • Uniformer.train()
            • Uniformer.type()
            • Uniformer.xpu()
            • Uniformer.zero_grad()
    • towhee.models.utils
      • towhee.models.utils.basic_ops
        • towhee.models.utils.basic_ops.ConsensusModule
          • ConsensusModule
            • ConsensusModule.__call__()
            • ConsensusModule.__init__()
            • ConsensusModule.__repr__()
            • ConsensusModule.add_module()
            • ConsensusModule.apply()
            • ConsensusModule.bfloat16()
            • ConsensusModule.buffers()
            • ConsensusModule.children()
            • ConsensusModule.cpu()
            • ConsensusModule.cuda()
            • ConsensusModule.double()
            • ConsensusModule.eval()
            • ConsensusModule.extra_repr()
            • ConsensusModule.float()
            • ConsensusModule.forward()
            • ConsensusModule.get_buffer()
            • ConsensusModule.get_extra_state()
            • ConsensusModule.get_parameter()
            • ConsensusModule.get_submodule()
            • ConsensusModule.half()
            • ConsensusModule.ipu()
            • ConsensusModule.load_state_dict()
            • ConsensusModule.modules()
            • ConsensusModule.named_buffers()
            • ConsensusModule.named_children()
            • ConsensusModule.named_modules()
            • ConsensusModule.named_parameters()
            • ConsensusModule.parameters()
            • ConsensusModule.register_backward_hook()
            • ConsensusModule.register_buffer()
            • ConsensusModule.register_forward_hook()
            • ConsensusModule.register_forward_pre_hook()
            • ConsensusModule.register_full_backward_hook()
            • ConsensusModule.register_full_backward_pre_hook()
            • ConsensusModule.register_load_state_dict_post_hook()
            • ConsensusModule.register_module()
            • ConsensusModule.register_parameter()
            • ConsensusModule.register_state_dict_pre_hook()
            • ConsensusModule.requires_grad_()
            • ConsensusModule.set_extra_state()
            • ConsensusModule.share_memory()
            • ConsensusModule.state_dict()
            • ConsensusModule.to()
            • ConsensusModule.to_empty()
            • ConsensusModule.train()
            • ConsensusModule.type()
            • ConsensusModule.xpu()
            • ConsensusModule.zero_grad()
        • towhee.models.utils.basic_ops.SegmentConsensus
          • SegmentConsensus
            • SegmentConsensus.__call__()
            • SegmentConsensus.__init__()
            • SegmentConsensus.__repr__()
            • SegmentConsensus.add_module()
            • SegmentConsensus.apply()
            • SegmentConsensus.bfloat16()
            • SegmentConsensus.buffers()
            • SegmentConsensus.children()
            • SegmentConsensus.cpu()
            • SegmentConsensus.cuda()
            • SegmentConsensus.double()
            • SegmentConsensus.eval()
            • SegmentConsensus.extra_repr()
            • SegmentConsensus.float()
            • SegmentConsensus.forward()
            • SegmentConsensus.get_buffer()
            • SegmentConsensus.get_extra_state()
            • SegmentConsensus.get_parameter()
            • SegmentConsensus.get_submodule()
            • SegmentConsensus.half()
            • SegmentConsensus.ipu()
            • SegmentConsensus.load_state_dict()
            • SegmentConsensus.modules()
            • SegmentConsensus.named_buffers()
            • SegmentConsensus.named_children()
            • SegmentConsensus.named_modules()
            • SegmentConsensus.named_parameters()
            • SegmentConsensus.parameters()
            • SegmentConsensus.register_backward_hook()
            • SegmentConsensus.register_buffer()
            • SegmentConsensus.register_forward_hook()
            • SegmentConsensus.register_forward_pre_hook()
            • SegmentConsensus.register_full_backward_hook()
            • SegmentConsensus.register_full_backward_pre_hook()
            • SegmentConsensus.register_load_state_dict_post_hook()
            • SegmentConsensus.register_module()
            • SegmentConsensus.register_parameter()
            • SegmentConsensus.register_state_dict_pre_hook()
            • SegmentConsensus.requires_grad_()
            • SegmentConsensus.set_extra_state()
            • SegmentConsensus.share_memory()
            • SegmentConsensus.state_dict()
            • SegmentConsensus.to()
            • SegmentConsensus.to_empty()
            • SegmentConsensus.train()
            • SegmentConsensus.type()
            • SegmentConsensus.xpu()
            • SegmentConsensus.zero_grad()
      • towhee.models.utils.causal_module
        • towhee.models.utils.causal_module.CausalModule
          • CausalModule
            • CausalModule.__call__()
            • CausalModule.__init__()
            • CausalModule.__repr__()
            • CausalModule.add_module()
            • CausalModule.apply()
            • CausalModule.bfloat16()
            • CausalModule.buffers()
            • CausalModule.children()
            • CausalModule.cpu()
            • CausalModule.cuda()
            • CausalModule.double()
            • CausalModule.eval()
            • CausalModule.extra_repr()
            • CausalModule.float()
            • CausalModule.forward()
            • CausalModule.get_buffer()
            • CausalModule.get_extra_state()
            • CausalModule.get_parameter()
            • CausalModule.get_submodule()
            • CausalModule.half()
            • CausalModule.ipu()
            • CausalModule.load_state_dict()
            • CausalModule.modules()
            • CausalModule.named_buffers()
            • CausalModule.named_children()
            • CausalModule.named_modules()
            • CausalModule.named_parameters()
            • CausalModule.parameters()
            • CausalModule.register_backward_hook()
            • CausalModule.register_buffer()
            • CausalModule.register_forward_hook()
            • CausalModule.register_forward_pre_hook()
            • CausalModule.register_full_backward_hook()
            • CausalModule.register_full_backward_pre_hook()
            • CausalModule.register_load_state_dict_post_hook()
            • CausalModule.register_module()
            • CausalModule.register_parameter()
            • CausalModule.register_state_dict_pre_hook()
            • CausalModule.requires_grad_()
            • CausalModule.set_extra_state()
            • CausalModule.share_memory()
            • CausalModule.state_dict()
            • CausalModule.to()
            • CausalModule.to_empty()
            • CausalModule.train()
            • CausalModule.type()
            • CausalModule.xpu()
            • CausalModule.zero_grad()
      • towhee.models.utils.create_act
        • towhee.models.utils.create_act.create_act_layer
          • create_act_layer()
        • towhee.models.utils.create_act.get_act_fn
          • get_act_fn()
        • towhee.models.utils.create_act.get_act_layer
          • get_act_layer()
      • towhee.models.utils.create_conv2d
        • towhee.models.utils.create_conv2d.create_conv2d
          • create_conv2d()
      • towhee.models.utils.create_conv2d_pad
        • towhee.models.utils.create_conv2d_pad.create_conv2d_pad
          • create_conv2d_pad()
      • towhee.models.utils.create_resnet_basic_3d_module
        • towhee.models.utils.create_resnet_basic_3d_module.create_resnet_basic_3d_module
          • create_resnet_basic_3d_module()
      • towhee.models.utils.fuse_bn
        • towhee.models.utils.fuse_bn.fuse_bn
          • fuse_bn()
      • towhee.models.utils.gelu_ignore_parameters
        • towhee.models.utils.gelu_ignore_parameters.gelu_ignore_parameters
          • gelu_ignore_parameters()
      • towhee.models.utils.general_utils
        • towhee.models.utils.general_utils.make_divisible
          • make_divisible()
        • towhee.models.utils.general_utils.to_1tuple
          • to_1tuple()
        • towhee.models.utils.general_utils.to_2tuple
          • to_2tuple()
        • towhee.models.utils.general_utils.to_3tuple
          • to_3tuple()
        • towhee.models.utils.general_utils.to_4tuple
          • to_4tuple()
        • towhee.models.utils.general_utils.to_ntuple
          • to_ntuple()
      • towhee.models.utils.get_relative_position_index
        • towhee.models.utils.get_relative_position_index.get_relative_position_index
          • get_relative_position_index()
      • towhee.models.utils.get_window_size
        • towhee.models.utils.get_window_size.get_window_size
          • get_window_size()
      • towhee.models.utils.init_vit_weights
        • towhee.models.utils.init_vit_weights.init_vit_weights
          • init_vit_weights()
      • towhee.models.utils.pretrained_utils
        • towhee.models.utils.pretrained_utils.load_pretrained_weights
          • load_pretrained_weights()
      • towhee.models.utils.round_width
        • towhee.models.utils.round_width.round_width
          • round_width()
      • towhee.models.utils.video_transforms
        • towhee.models.utils.video_transforms.get_configs
          • get_configs()
        • towhee.models.utils.video_transforms.transform_video
          • transform_video()
        • towhee.models.utils.video_transforms.CenterCropVideo
          • CenterCropVideo
            • CenterCropVideo.__call__()
            • CenterCropVideo.__init__()
            • CenterCropVideo.__repr__()
        • towhee.models.utils.video_transforms.NormalizeVideo
          • NormalizeVideo
            • NormalizeVideo.__call__()
            • NormalizeVideo.__init__()
            • NormalizeVideo.__repr__()
        • towhee.models.utils.video_transforms.PackPathway
          • PackPathway
            • PackPathway.__call__()
            • PackPathway.__init__()
            • PackPathway.__repr__()
            • PackPathway.add_module()
            • PackPathway.apply()
            • PackPathway.bfloat16()
            • PackPathway.buffers()
            • PackPathway.children()
            • PackPathway.cpu()
            • PackPathway.cuda()
            • PackPathway.double()
            • PackPathway.eval()
            • PackPathway.extra_repr()
            • PackPathway.float()
            • PackPathway.forward()
            • PackPathway.get_buffer()
            • PackPathway.get_extra_state()
            • PackPathway.get_parameter()
            • PackPathway.get_submodule()
            • PackPathway.half()
            • PackPathway.ipu()
            • PackPathway.load_state_dict()
            • PackPathway.modules()
            • PackPathway.named_buffers()
            • PackPathway.named_children()
            • PackPathway.named_modules()
            • PackPathway.named_parameters()
            • PackPathway.parameters()
            • PackPathway.register_backward_hook()
            • PackPathway.register_buffer()
            • PackPathway.register_forward_hook()
            • PackPathway.register_forward_pre_hook()
            • PackPathway.register_full_backward_hook()
            • PackPathway.register_full_backward_pre_hook()
            • PackPathway.register_load_state_dict_post_hook()
            • PackPathway.register_module()
            • PackPathway.register_parameter()
            • PackPathway.register_state_dict_pre_hook()
            • PackPathway.requires_grad_()
            • PackPathway.set_extra_state()
            • PackPathway.share_memory()
            • PackPathway.state_dict()
            • PackPathway.to()
            • PackPathway.to_empty()
            • PackPathway.train()
            • PackPathway.type()
            • PackPathway.xpu()
            • PackPathway.zero_grad()
        • towhee.models.utils.video_transforms.VideoTransforms
          • VideoTransforms
            • VideoTransforms.__call__()
            • VideoTransforms.__init__()
      • towhee.models.utils.weight_init
        • towhee.models.utils.weight_init.lecun_normal_
          • lecun_normal_()
        • towhee.models.utils.weight_init.trunc_normal_
          • trunc_normal_()
        • towhee.models.utils.weight_init.variance_scaling_
          • variance_scaling_()
      • towhee.models.utils.window_partition
        • towhee.models.utils.window_partition.window_partition
          • window_partition()
      • towhee.models.utils.window_partition3d
        • towhee.models.utils.window_partition3d.window_partition
          • window_partition()
      • towhee.models.utils.window_reverse
        • towhee.models.utils.window_reverse.window_reverse
          • window_reverse()
      • towhee.models.utils.window_reverse3d
        • towhee.models.utils.window_reverse3d.window_reverse
          • window_reverse()
    • towhee.models.vggish
      • towhee.models.vggish.torch_vggish
        • towhee.models.vggish.torch_vggish.VGG
          • VGG
            • VGG.__call__()
            • VGG.__init__()
            • VGG.__repr__()
            • VGG.add_module()
            • VGG.apply()
            • VGG.bfloat16()
            • VGG.buffers()
            • VGG.children()
            • VGG.cpu()
            • VGG.cuda()
            • VGG.double()
            • VGG.eval()
            • VGG.extra_repr()
            • VGG.float()
            • VGG.forward()
            • VGG.get_buffer()
            • VGG.get_extra_state()
            • VGG.get_parameter()
            • VGG.get_submodule()
            • VGG.half()
            • VGG.ipu()
            • VGG.load_state_dict()
            • VGG.modules()
            • VGG.named_buffers()
            • VGG.named_children()
            • VGG.named_modules()
            • VGG.named_parameters()
            • VGG.parameters()
            • VGG.register_backward_hook()
            • VGG.register_buffer()
            • VGG.register_forward_hook()
            • VGG.register_forward_pre_hook()
            • VGG.register_full_backward_hook()
            • VGG.register_full_backward_pre_hook()
            • VGG.register_load_state_dict_post_hook()
            • VGG.register_module()
            • VGG.register_parameter()
            • VGG.register_state_dict_pre_hook()
            • VGG.requires_grad_()
            • VGG.set_extra_state()
            • VGG.share_memory()
            • VGG.state_dict()
            • VGG.to()
            • VGG.to_empty()
            • VGG.train()
            • VGG.type()
            • VGG.xpu()
            • VGG.zero_grad()
    • towhee.models.video_swin_transformer
      • towhee.models.video_swin_transformer.compute_mask
      • towhee.models.video_swin_transformer.get_configs
        • towhee.models.video_swin_transformer.get_configs.configs
          • configs()
      • towhee.models.video_swin_transformer.video_swin_transformer
        • towhee.models.video_swin_transformer.video_swin_transformer.create_model
          • create_model()
        • towhee.models.video_swin_transformer.video_swin_transformer.VideoSwinTransformer
          • VideoSwinTransformer
            • VideoSwinTransformer.__call__()
            • VideoSwinTransformer.__init__()
            • VideoSwinTransformer.__repr__()
            • VideoSwinTransformer.add_module()
            • VideoSwinTransformer.apply()
            • VideoSwinTransformer.bfloat16()
            • VideoSwinTransformer.buffers()
            • VideoSwinTransformer.children()
            • VideoSwinTransformer.cpu()
            • VideoSwinTransformer.cuda()
            • VideoSwinTransformer.double()
            • VideoSwinTransformer.eval()
            • VideoSwinTransformer.extra_repr()
            • VideoSwinTransformer.float()
            • VideoSwinTransformer.forward()
            • VideoSwinTransformer.get_buffer()
            • VideoSwinTransformer.get_extra_state()
            • VideoSwinTransformer.get_parameter()
            • VideoSwinTransformer.get_submodule()
            • VideoSwinTransformer.half()
            • VideoSwinTransformer.head()
            • VideoSwinTransformer.inflate_weights()
            • VideoSwinTransformer.ipu()
            • VideoSwinTransformer.load_pretrained_weights()
            • VideoSwinTransformer.load_state_dict()
            • VideoSwinTransformer.modules()
            • VideoSwinTransformer.named_buffers()
            • VideoSwinTransformer.named_children()
            • VideoSwinTransformer.named_modules()
            • VideoSwinTransformer.named_parameters()
            • VideoSwinTransformer.parameters()
            • VideoSwinTransformer.register_backward_hook()
            • VideoSwinTransformer.register_buffer()
            • VideoSwinTransformer.register_forward_hook()
            • VideoSwinTransformer.register_forward_pre_hook()
            • VideoSwinTransformer.register_full_backward_hook()
            • VideoSwinTransformer.register_full_backward_pre_hook()
            • VideoSwinTransformer.register_load_state_dict_post_hook()
            • VideoSwinTransformer.register_module()
            • VideoSwinTransformer.register_parameter()
            • VideoSwinTransformer.register_state_dict_pre_hook()
            • VideoSwinTransformer.requires_grad_()
            • VideoSwinTransformer.set_extra_state()
            • VideoSwinTransformer.share_memory()
            • VideoSwinTransformer.state_dict()
            • VideoSwinTransformer.to()
            • VideoSwinTransformer.to_empty()
            • VideoSwinTransformer.train()
            • VideoSwinTransformer.type()
            • VideoSwinTransformer.xpu()
            • VideoSwinTransformer.zero_grad()
      • towhee.models.video_swin_transformer.video_swin_transformer_block
        • towhee.models.video_swin_transformer.video_swin_transformer_block.VideoSwinTransformerBlock
          • VideoSwinTransformerBlock
            • VideoSwinTransformerBlock.__call__()
            • VideoSwinTransformerBlock.__init__()
            • VideoSwinTransformerBlock.__repr__()
            • VideoSwinTransformerBlock.add_module()
            • VideoSwinTransformerBlock.apply()
            • VideoSwinTransformerBlock.bfloat16()
            • VideoSwinTransformerBlock.buffers()
            • VideoSwinTransformerBlock.children()
            • VideoSwinTransformerBlock.cpu()
            • VideoSwinTransformerBlock.cuda()
            • VideoSwinTransformerBlock.double()
            • VideoSwinTransformerBlock.eval()
            • VideoSwinTransformerBlock.extra_repr()
            • VideoSwinTransformerBlock.float()
            • VideoSwinTransformerBlock.forward()
            • VideoSwinTransformerBlock.get_buffer()
            • VideoSwinTransformerBlock.get_extra_state()
            • VideoSwinTransformerBlock.get_parameter()
            • VideoSwinTransformerBlock.get_submodule()
            • VideoSwinTransformerBlock.half()
            • VideoSwinTransformerBlock.ipu()
            • VideoSwinTransformerBlock.load_state_dict()
            • VideoSwinTransformerBlock.modules()
            • VideoSwinTransformerBlock.named_buffers()
            • VideoSwinTransformerBlock.named_children()
            • VideoSwinTransformerBlock.named_modules()
            • VideoSwinTransformerBlock.named_parameters()
            • VideoSwinTransformerBlock.parameters()
            • VideoSwinTransformerBlock.register_backward_hook()
            • VideoSwinTransformerBlock.register_buffer()
            • VideoSwinTransformerBlock.register_forward_hook()
            • VideoSwinTransformerBlock.register_forward_pre_hook()
            • VideoSwinTransformerBlock.register_full_backward_hook()
            • VideoSwinTransformerBlock.register_full_backward_pre_hook()
            • VideoSwinTransformerBlock.register_load_state_dict_post_hook()
            • VideoSwinTransformerBlock.register_module()
            • VideoSwinTransformerBlock.register_parameter()
            • VideoSwinTransformerBlock.register_state_dict_pre_hook()
            • VideoSwinTransformerBlock.requires_grad_()
            • VideoSwinTransformerBlock.set_extra_state()
            • VideoSwinTransformerBlock.share_memory()
            • VideoSwinTransformerBlock.state_dict()
            • VideoSwinTransformerBlock.to()
            • VideoSwinTransformerBlock.to_empty()
            • VideoSwinTransformerBlock.train()
            • VideoSwinTransformerBlock.type()
            • VideoSwinTransformerBlock.xpu()
            • VideoSwinTransformerBlock.zero_grad()
    • towhee.models.violet
      • towhee.models.violet.violet
        • towhee.models.violet.violet.EncImg
          • EncImg
            • EncImg.__call__()
            • EncImg.__init__()
            • EncImg.__repr__()
            • EncImg.add_module()
            • EncImg.apply()
            • EncImg.bfloat16()
            • EncImg.buffers()
            • EncImg.children()
            • EncImg.cpu()
            • EncImg.cuda()
            • EncImg.double()
            • EncImg.eval()
            • EncImg.extra_repr()
            • EncImg.float()
            • EncImg.forward()
            • EncImg.get_buffer()
            • EncImg.get_extra_state()
            • EncImg.get_parameter()
            • EncImg.get_submodule()
            • EncImg.half()
            • EncImg.ipu()
            • EncImg.load_state_dict()
            • EncImg.modules()
            • EncImg.named_buffers()
            • EncImg.named_children()
            • EncImg.named_modules()
            • EncImg.named_parameters()
            • EncImg.parameters()
            • EncImg.register_backward_hook()
            • EncImg.register_buffer()
            • EncImg.register_forward_hook()
            • EncImg.register_forward_pre_hook()
            • EncImg.register_full_backward_hook()
            • EncImg.register_full_backward_pre_hook()
            • EncImg.register_load_state_dict_post_hook()
            • EncImg.register_module()
            • EncImg.register_parameter()
            • EncImg.register_state_dict_pre_hook()
            • EncImg.requires_grad_()
            • EncImg.set_extra_state()
            • EncImg.share_memory()
            • EncImg.state_dict()
            • EncImg.to()
            • EncImg.to_empty()
            • EncImg.train()
            • EncImg.type()
            • EncImg.xpu()
            • EncImg.zero_grad()
        • towhee.models.violet.violet.EncTxt
          • EncTxt
            • EncTxt.__call__()
            • EncTxt.__init__()
            • EncTxt.__repr__()
            • EncTxt.add_module()
            • EncTxt.apply()
            • EncTxt.bfloat16()
            • EncTxt.buffers()
            • EncTxt.children()
            • EncTxt.cpu()
            • EncTxt.cuda()
            • EncTxt.double()
            • EncTxt.eval()
            • EncTxt.extra_repr()
            • EncTxt.float()
            • EncTxt.forward()
            • EncTxt.get_buffer()
            • EncTxt.get_extra_state()
            • EncTxt.get_parameter()
            • EncTxt.get_submodule()
            • EncTxt.half()
            • EncTxt.ipu()
            • EncTxt.load_state_dict()
            • EncTxt.modules()
            • EncTxt.named_buffers()
            • EncTxt.named_children()
            • EncTxt.named_modules()
            • EncTxt.named_parameters()
            • EncTxt.parameters()
            • EncTxt.register_backward_hook()
            • EncTxt.register_buffer()
            • EncTxt.register_forward_hook()
            • EncTxt.register_forward_pre_hook()
            • EncTxt.register_full_backward_hook()
            • EncTxt.register_full_backward_pre_hook()
            • EncTxt.register_load_state_dict_post_hook()
            • EncTxt.register_module()
            • EncTxt.register_parameter()
            • EncTxt.register_state_dict_pre_hook()
            • EncTxt.requires_grad_()
            • EncTxt.set_extra_state()
            • EncTxt.share_memory()
            • EncTxt.state_dict()
            • EncTxt.to()
            • EncTxt.to_empty()
            • EncTxt.train()
            • EncTxt.type()
            • EncTxt.xpu()
            • EncTxt.zero_grad()
        • towhee.models.violet.violet.VioletBase
          • VioletBase
            • VioletBase.__call__()
            • VioletBase.__init__()
            • VioletBase.__repr__()
            • VioletBase.add_module()
            • VioletBase.apply()
            • VioletBase.bfloat16()
            • VioletBase.buffers()
            • VioletBase.children()
            • VioletBase.cpu()
            • VioletBase.cuda()
            • VioletBase.double()
            • VioletBase.eval()
            • VioletBase.extra_repr()
            • VioletBase.float()
            • VioletBase.forward()
            • VioletBase.get_buffer()
            • VioletBase.get_extra_state()
            • VioletBase.get_parameter()
            • VioletBase.get_submodule()
            • VioletBase.half()
            • VioletBase.ipu()
            • VioletBase.load_state_dict()
            • VioletBase.modules()
            • VioletBase.named_buffers()
            • VioletBase.named_children()
            • VioletBase.named_modules()
            • VioletBase.named_parameters()
            • VioletBase.parameters()
            • VioletBase.register_backward_hook()
            • VioletBase.register_buffer()
            • VioletBase.register_forward_hook()
            • VioletBase.register_forward_pre_hook()
            • VioletBase.register_full_backward_hook()
            • VioletBase.register_full_backward_pre_hook()
            • VioletBase.register_load_state_dict_post_hook()
            • VioletBase.register_module()
            • VioletBase.register_parameter()
            • VioletBase.register_state_dict_pre_hook()
            • VioletBase.requires_grad_()
            • VioletBase.set_extra_state()
            • VioletBase.share_memory()
            • VioletBase.state_dict()
            • VioletBase.to()
            • VioletBase.to_empty()
            • VioletBase.train()
            • VioletBase.type()
            • VioletBase.xpu()
            • VioletBase.zero_grad()
    • towhee.models.visualization
      • towhee.models.visualization.clip_visualization
        • towhee.models.visualization.clip_visualization.get_clip_relevance
          • get_clip_relevance()
        • towhee.models.visualization.clip_visualization.show_attention_for_clip
          • show_attention_for_clip()
        • towhee.models.visualization.clip_visualization.show_heatmap_on_text
          • show_heatmap_on_text()
        • towhee.models.visualization.clip_visualization.show_image_relevance
          • show_image_relevance()
      • towhee.models.visualization.embedding_visualization
        • towhee.models.visualization.embedding_visualization.show_embeddings
          • show_embeddings()
      • towhee.models.visualization.transformer_visualization
        • towhee.models.visualization.transformer_visualization.generate_attention
          • generate_attention()
        • towhee.models.visualization.transformer_visualization.show_image_heatmap
          • show_image_heatmap()
        • towhee.models.visualization.transformer_visualization.LRP
          • LRP
            • LRP.__init__()
            • LRP.generate_lrp()
    • towhee.models.vit
      • towhee.models.vit.vit
        • towhee.models.vit.vit.compute_rollout_attention
          • compute_rollout_attention()
        • towhee.models.vit.vit.create_model
          • create_model()
        • towhee.models.vit.vit.VitModel
          • VitModel
            • VitModel.__call__()
            • VitModel.__init__()
            • VitModel.__repr__()
            • VitModel.add_module()
            • VitModel.apply()
            • VitModel.bfloat16()
            • VitModel.buffers()
            • VitModel.children()
            • VitModel.cpu()
            • VitModel.cuda()
            • VitModel.double()
            • VitModel.eval()
            • VitModel.extra_repr()
            • VitModel.float()
            • VitModel.forward()
            • VitModel.get_buffer()
            • VitModel.get_extra_state()
            • VitModel.get_parameter()
            • VitModel.get_submodule()
            • VitModel.half()
            • VitModel.ipu()
            • VitModel.load_state_dict()
            • VitModel.modules()
            • VitModel.named_buffers()
            • VitModel.named_children()
            • VitModel.named_modules()
            • VitModel.named_parameters()
            • VitModel.parameters()
            • VitModel.register_backward_hook()
            • VitModel.register_buffer()
            • VitModel.register_forward_hook()
            • VitModel.register_forward_pre_hook()
            • VitModel.register_full_backward_hook()
            • VitModel.register_full_backward_pre_hook()
            • VitModel.register_load_state_dict_post_hook()
            • VitModel.register_module()
            • VitModel.register_parameter()
            • VitModel.register_state_dict_pre_hook()
            • VitModel.requires_grad_()
            • VitModel.set_extra_state()
            • VitModel.share_memory()
            • VitModel.state_dict()
            • VitModel.to()
            • VitModel.to_empty()
            • VitModel.train()
            • VitModel.type()
            • VitModel.xpu()
            • VitModel.zero_grad()
      • towhee.models.vit.vit_block
        • towhee.models.vit.vit_block.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.vit.vit_utils
        • towhee.models.vit.vit_utils.base_configs
          • base_configs()
        • towhee.models.vit.vit_utils.get_configs
          • get_configs()
  • towhee.operator
    • towhee.operator.base
      • towhee.operator.base.NNOperator
        • NNOperator
          • NNOperator.__call__()
          • NNOperator.__init__()
          • NNOperator.load()
          • NNOperator.save()
          • NNOperator.save_model()
          • NNOperator.setup_trainer()
          • NNOperator.supported_model_names()
          • NNOperator.train()
      • towhee.operator.base.Operator
        • Operator
          • Operator.__call__()
          • Operator.__init__()
      • towhee.operator.base.OperatorFlag
        • OperatorFlag
      • towhee.operator.base.PyOperator
        • PyOperator
          • PyOperator.__call__()
          • PyOperator.__init__()
      • towhee.operator.base.SharedType
        • SharedType
    • towhee.operator.concat_operator
      • towhee.operator.concat_operator.ConcatOperator
        • ConcatOperator
          • ConcatOperator.__call__()
          • ConcatOperator.__init__()
    • towhee.operator.nop
      • towhee.operator.nop.NOPOperator
        • NOPOperator
          • NOPOperator.__call__()
          • NOPOperator.__init__()
    • towhee.operator.stateful_operator
      • towhee.operator.stateful_operator.StatefulOperator
        • StatefulOperator
          • StatefulOperator.__call__()
          • StatefulOperator.__init__()
  • towhee.pipeline_format
    • towhee.pipeline_format.ImageEmbeddingFormat
      • ImageEmbeddingFormat
        • ImageEmbeddingFormat.__call__()
    • towhee.pipeline_format.NormalFormat
      • NormalFormat
        • NormalFormat.__call__()
    • towhee.pipeline_format.OutputFormat
      • OutputFormat
        • OutputFormat.__call__()
  • towhee.serve
    • towhee.serve.triton
      • towhee.serve.triton.builder
        • towhee.serve.triton.builder.main
          • main()
        • towhee.serve.triton.builder.Builder
          • Builder
            • Builder.__init__()
      • towhee.serve.triton.constant
      • towhee.serve.triton.docker_image_builder
        • towhee.serve.triton.docker_image_builder.DockerImageBuilder
          • DockerImageBuilder
            • DockerImageBuilder.__init__()
      • towhee.serve.triton.dockerfiles
        • towhee.serve.triton.dockerfiles.get_dockerfile
          • get_dockerfile()
      • towhee.serve.triton.format_utils
        • towhee.serve.triton.format_utils.add_line_separator
          • add_line_separator()
        • towhee.serve.triton.format_utils.intend
          • intend()
      • towhee.serve.triton.python_model_builder
        • towhee.serve.triton.python_model_builder.gen_model_from_op
          • gen_model_from_op()
        • towhee.serve.triton.python_model_builder.gen_model_from_pickled_callable
          • gen_model_from_pickled_callable()
        • towhee.serve.triton.python_model_builder.OpPyModelBuilder
          • OpPyModelBuilder
            • OpPyModelBuilder.__init__()
        • towhee.serve.triton.python_model_builder.PickledCallablePyModelBuilder
          • PickledCallablePyModelBuilder
            • PickledCallablePyModelBuilder.__init__()
        • towhee.serve.triton.python_model_builder.PyModelBuilder
          • PyModelBuilder
      • towhee.serve.triton.to_triton_models
        • towhee.serve.triton.to_triton_models.EnsembleToTriton
          • EnsembleToTriton
            • EnsembleToTriton.__init__()
        • towhee.serve.triton.to_triton_models.ModelToTriton
          • ModelToTriton
            • ModelToTriton.__init__()
        • towhee.serve.triton.to_triton_models.PostprocessToTriton
          • PostprocessToTriton
            • PostprocessToTriton.__init__()
        • towhee.serve.triton.to_triton_models.PreprocessToTriton
          • PreprocessToTriton
            • PreprocessToTriton.__init__()
        • towhee.serve.triton.to_triton_models.PyOpToTriton
          • PyOpToTriton
            • PyOpToTriton.__init__()
        • towhee.serve.triton.to_triton_models.ToTriton
          • ToTriton
            • ToTriton.__init__()
        • towhee.serve.triton.to_triton_models.TritonFiles
          • TritonFiles
            • TritonFiles.__init__()
      • towhee.serve.triton.triton_config_builder
        • towhee.serve.triton.triton_config_builder.create_modelconfig
          • create_modelconfig()
        • towhee.serve.triton.triton_config_builder.EnsembleConfigBuilder
          • EnsembleConfigBuilder
            • EnsembleConfigBuilder.__init__()
        • towhee.serve.triton.triton_config_builder.TritonModelConfigBuilder
          • TritonModelConfigBuilder
            • TritonModelConfigBuilder.__init__()
      • towhee.serve.triton.type_gen
        • towhee.serve.triton.type_gen.get_init_code
          • get_init_code()
        • towhee.serve.triton.type_gen.get_type_info
          • get_type_info()
        • towhee.serve.triton.type_gen.handle_type_annotations
          • handle_type_annotations()
        • towhee.serve.triton.type_gen.is_scalar
          • is_scalar()
        • towhee.serve.triton.type_gen.tensor2bool
          • tensor2bool()
        • towhee.serve.triton.type_gen.tensor2float
          • tensor2float()
        • towhee.serve.triton.type_gen.tensor2int
          • tensor2int()
        • towhee.serve.triton.type_gen.tensor2ndarray
          • tensor2ndarray()
        • towhee.serve.triton.type_gen.tensor2str
          • tensor2str()
        • towhee.serve.triton.type_gen.AttrInfo
          • AttrInfo
            • AttrInfo.__add__()
            • AttrInfo.__getitem__()
            • AttrInfo.__mul__()
            • AttrInfo.__repr__()
            • AttrInfo.count()
            • AttrInfo.index()
            • AttrInfo.numpy_dtype
            • AttrInfo.obj_placeholder
            • AttrInfo.shape
            • AttrInfo.tensor_placeholder
            • AttrInfo.triton_dtype
        • towhee.serve.triton.type_gen.AudioFrameType
          • AudioFrameType
        • towhee.serve.triton.type_gen.BoolType
          • BoolType
        • towhee.serve.triton.type_gen.FloatType
          • FloatType
        • towhee.serve.triton.type_gen.ImageType
          • ImageType
        • towhee.serve.triton.type_gen.IntType
          • IntType
        • towhee.serve.triton.type_gen.NpFloat16Type
          • NpFloat16Type
        • towhee.serve.triton.type_gen.NpFloat32Type
          • NpFloat32Type
        • towhee.serve.triton.type_gen.NpFloat64Type
          • NpFloat64Type
        • towhee.serve.triton.type_gen.NpInt16Type
          • NpInt16Type
        • towhee.serve.triton.type_gen.NpInt32Type
          • NpInt32Type
        • towhee.serve.triton.type_gen.NpInt64Type
          • NpInt64Type
        • towhee.serve.triton.type_gen.NpInt8Type
          • NpInt8Type
        • towhee.serve.triton.type_gen.NpUint16Type
          • NpUint16Type
        • towhee.serve.triton.type_gen.NpUint32Type
          • NpUint32Type
        • towhee.serve.triton.type_gen.NpUint64Type
          • NpUint64Type
        • towhee.serve.triton.type_gen.NpUint8Type
          • NpUint8Type
        • towhee.serve.triton.type_gen.StringType
          • StringType
        • towhee.serve.triton.type_gen.TypeInfo
          • TypeInfo
            • TypeInfo.__init__()
        • towhee.serve.triton.type_gen.VideoFrameType
          • VideoFrameType
  • towhee.trainer
    • towhee.trainer.callback
      • towhee.trainer.callback.Callback
        • Callback
          • Callback.__init__()
          • Callback.on_batch_begin()
          • Callback.on_batch_end()
          • Callback.on_epoch_begin()
          • Callback.on_epoch_end()
          • Callback.on_eval_batch_begin()
          • Callback.on_eval_batch_end()
          • Callback.on_eval_begin()
          • Callback.on_eval_end()
          • Callback.on_train_batch_begin()
          • Callback.on_train_batch_end()
          • Callback.on_train_begin()
          • Callback.on_train_end()
          • Callback.set_model()
          • Callback.set_optimizer()
          • Callback.set_trainercontrol()
      • towhee.trainer.callback.CallbackList
        • CallbackList
          • CallbackList.__init__()
          • CallbackList.__repr__()
          • CallbackList.add_callback()
          • CallbackList.on_batch_begin()
          • CallbackList.on_batch_end()
          • CallbackList.on_epoch_begin()
          • CallbackList.on_epoch_end()
          • CallbackList.on_eval_batch_begin()
          • CallbackList.on_eval_batch_end()
          • CallbackList.on_eval_begin()
          • CallbackList.on_eval_end()
          • CallbackList.on_train_batch_begin()
          • CallbackList.on_train_batch_end()
          • CallbackList.on_train_begin()
          • CallbackList.on_train_end()
          • CallbackList.pop_callback()
          • CallbackList.set_model()
          • CallbackList.set_optimizer()
          • CallbackList.set_trainercontrol()
      • towhee.trainer.callback.EarlyStoppingCallback
        • EarlyStoppingCallback
          • EarlyStoppingCallback.__init__()
          • EarlyStoppingCallback.on_batch_begin()
          • EarlyStoppingCallback.on_batch_end()
          • EarlyStoppingCallback.on_epoch_begin()
          • EarlyStoppingCallback.on_epoch_end()
          • EarlyStoppingCallback.on_eval_batch_begin()
          • EarlyStoppingCallback.on_eval_batch_end()
          • EarlyStoppingCallback.on_eval_begin()
          • EarlyStoppingCallback.on_eval_end()
          • EarlyStoppingCallback.on_train_batch_begin()
          • EarlyStoppingCallback.on_train_batch_end()
          • EarlyStoppingCallback.on_train_begin()
          • EarlyStoppingCallback.on_train_end()
          • EarlyStoppingCallback.set_model()
          • EarlyStoppingCallback.set_optimizer()
          • EarlyStoppingCallback.set_trainercontrol()
      • towhee.trainer.callback.ModelCheckpointCallback
        • ModelCheckpointCallback
          • ModelCheckpointCallback.__init__()
          • ModelCheckpointCallback.on_batch_begin()
          • ModelCheckpointCallback.on_batch_end()
          • ModelCheckpointCallback.on_epoch_begin()
          • ModelCheckpointCallback.on_epoch_end()
          • ModelCheckpointCallback.on_eval_batch_begin()
          • ModelCheckpointCallback.on_eval_batch_end()
          • ModelCheckpointCallback.on_eval_begin()
          • ModelCheckpointCallback.on_eval_end()
          • ModelCheckpointCallback.on_train_batch_begin()
          • ModelCheckpointCallback.on_train_batch_end()
          • ModelCheckpointCallback.on_train_begin()
          • ModelCheckpointCallback.on_train_end()
          • ModelCheckpointCallback.set_model()
          • ModelCheckpointCallback.set_optimizer()
          • ModelCheckpointCallback.set_trainercontrol()
      • towhee.trainer.callback.PrintCallBack
        • PrintCallBack
          • PrintCallBack.__init__()
          • PrintCallBack.on_batch_begin()
          • PrintCallBack.on_batch_end()
          • PrintCallBack.on_epoch_begin()
          • PrintCallBack.on_epoch_end()
          • PrintCallBack.on_eval_batch_begin()
          • PrintCallBack.on_eval_batch_end()
          • PrintCallBack.on_eval_begin()
          • PrintCallBack.on_eval_end()
          • PrintCallBack.on_train_batch_begin()
          • PrintCallBack.on_train_batch_end()
          • PrintCallBack.on_train_begin()
          • PrintCallBack.on_train_end()
          • PrintCallBack.set_model()
          • PrintCallBack.set_optimizer()
          • PrintCallBack.set_trainercontrol()
      • towhee.trainer.callback.ProgressBarCallBack
        • ProgressBarCallBack
          • ProgressBarCallBack.__init__()
          • ProgressBarCallBack.on_batch_begin()
          • ProgressBarCallBack.on_batch_end()
          • ProgressBarCallBack.on_epoch_begin()
          • ProgressBarCallBack.on_epoch_end()
          • ProgressBarCallBack.on_eval_batch_begin()
          • ProgressBarCallBack.on_eval_batch_end()
          • ProgressBarCallBack.on_eval_begin()
          • ProgressBarCallBack.on_eval_end()
          • ProgressBarCallBack.on_train_batch_begin()
          • ProgressBarCallBack.on_train_batch_end()
          • ProgressBarCallBack.on_train_begin()
          • ProgressBarCallBack.on_train_end()
          • ProgressBarCallBack.set_model()
          • ProgressBarCallBack.set_optimizer()
          • ProgressBarCallBack.set_trainercontrol()
      • towhee.trainer.callback.TensorBoardCallBack
        • TensorBoardCallBack
          • TensorBoardCallBack.__init__()
          • TensorBoardCallBack.on_batch_begin()
          • TensorBoardCallBack.on_batch_end()
          • TensorBoardCallBack.on_epoch_begin()
          • TensorBoardCallBack.on_epoch_end()
          • TensorBoardCallBack.on_eval_batch_begin()
          • TensorBoardCallBack.on_eval_batch_end()
          • TensorBoardCallBack.on_eval_begin()
          • TensorBoardCallBack.on_eval_end()
          • TensorBoardCallBack.on_train_batch_begin()
          • TensorBoardCallBack.on_train_batch_end()
          • TensorBoardCallBack.on_train_begin()
          • TensorBoardCallBack.on_train_end()
          • TensorBoardCallBack.set_model()
          • TensorBoardCallBack.set_optimizer()
          • TensorBoardCallBack.set_trainercontrol()
      • towhee.trainer.callback.TrainerControl
        • TrainerControl
          • TrainerControl.__init__()
    • towhee.trainer.modelcard
      • towhee.trainer.modelcard.ModelCard
        • ModelCard
          • ModelCard.__init__()
          • ModelCard.__repr__()
          • ModelCard.save_model_card()
          • ModelCard.to_dict()
    • towhee.trainer.optimization
      • towhee.trainer.optimization.adafactor
        • towhee.trainer.optimization.adafactor.Adafactor
          • Adafactor
            • Adafactor.__init__()
            • Adafactor.__repr__()
            • Adafactor.add_param_group()
            • Adafactor.load_state_dict()
            • Adafactor.register_step_post_hook()
            • Adafactor.register_step_pre_hook()
            • Adafactor.state_dict()
            • Adafactor.step()
            • Adafactor.zero_grad()
      • towhee.trainer.optimization.adamw
        • towhee.trainer.optimization.adamw.AdamW
          • AdamW
            • AdamW.__init__()
            • AdamW.__repr__()
            • AdamW.add_param_group()
            • AdamW.load_state_dict()
            • AdamW.register_step_post_hook()
            • AdamW.register_step_pre_hook()
            • AdamW.state_dict()
            • AdamW.step()
            • AdamW.zero_grad()
      • towhee.trainer.optimization.optimization
        • towhee.trainer.optimization.optimization.get_constant_schedule
          • get_constant_schedule()
        • towhee.trainer.optimization.optimization.get_constant_schedule_with_warmup
          • get_constant_schedule_with_warmup()
        • towhee.trainer.optimization.optimization.get_cosine_schedule_with_warmup
          • get_cosine_schedule_with_warmup()
        • towhee.trainer.optimization.optimization.get_cosine_with_hard_restarts_schedule_with_warmup
          • get_cosine_with_hard_restarts_schedule_with_warmup()
        • towhee.trainer.optimization.optimization.get_linear_schedule_with_warmup
          • get_linear_schedule_with_warmup()
        • towhee.trainer.optimization.optimization.get_polynomial_decay_schedule_with_warmup
          • get_polynomial_decay_schedule_with_warmup()
        • towhee.trainer.optimization.optimization.get_scheduler
          • get_scheduler()
        • towhee.trainer.optimization.optimization.get_warmup_steps
          • get_warmup_steps()
    • towhee.trainer.scheduler
      • towhee.trainer.scheduler.check_scheduler
        • check_scheduler()
      • towhee.trainer.scheduler.configure_constant_scheduler
        • configure_constant_scheduler()
      • towhee.trainer.scheduler.configure_constant_scheduler_with_warmup
        • configure_constant_scheduler_with_warmup()
      • towhee.trainer.scheduler.configure_cosine_scheduler_with_warmup
        • configure_cosine_scheduler_with_warmup()
      • towhee.trainer.scheduler.configure_cosine_with_hard_restarts_scheduler_with_warmup
        • configure_cosine_with_hard_restarts_scheduler_with_warmup()
      • towhee.trainer.scheduler.configure_linear_scheduler_with_warmup
        • configure_linear_scheduler_with_warmup()
      • towhee.trainer.scheduler.configure_polynomial_decay_scheduler_with_warmup
        • configure_polynomial_decay_scheduler_with_warmup()
    • towhee.trainer.training_config
      • towhee.trainer.training_config.dump_default_yaml
        • dump_default_yaml()
      • towhee.trainer.training_config.get_config_help
        • get_config_help()
      • towhee.trainer.training_config.TrainingConfig
        • TrainingConfig
          • TrainingConfig.__init__()
          • TrainingConfig.__repr__()
          • TrainingConfig.load_from_yaml()
          • TrainingConfig.save_to_yaml()
    • towhee.trainer.utils
      • towhee.trainer.utils.file_utils
        • towhee.trainer.utils.file_utils.is_captum_available
          • is_captum_available()
        • towhee.trainer.utils.file_utils.is_matplotlib_available
          • is_matplotlib_available()
        • towhee.trainer.utils.file_utils.is_tensorboard_available
          • is_tensorboard_available()
      • towhee.trainer.utils.layer_freezer
        • towhee.trainer.utils.layer_freezer.LayerFreezer
          • LayerFreezer
            • LayerFreezer.__init__()
            • LayerFreezer.by_idx()
            • LayerFreezer.by_names()
            • LayerFreezer.set_all()
            • LayerFreezer.set_slice()
            • LayerFreezer.show_frozen_layers()
            • LayerFreezer.status()
      • towhee.trainer.utils.plot_utils
        • towhee.trainer.utils.plot_utils.image_folder_sample_show
          • image_folder_sample_show()
        • towhee.trainer.utils.plot_utils.image_folder_statistic
          • image_folder_statistic()
        • towhee.trainer.utils.plot_utils.interpret_image_classification
          • interpret_image_classification()
        • towhee.trainer.utils.plot_utils.plot_lrs_for_config
          • plot_lrs_for_config()
        • towhee.trainer.utils.plot_utils.plot_lrs_for_scheduler
          • plot_lrs_for_scheduler()
        • towhee.trainer.utils.plot_utils.predict_image_classification
          • predict_image_classification()
        • towhee.trainer.utils.plot_utils.show_transform
          • show_transform()
      • towhee.trainer.utils.trainer_utils
        • towhee.trainer.utils.trainer_utils.get_last_checkpoint
          • get_last_checkpoint()
        • towhee.trainer.utils.trainer_utils.get_rank
          • get_rank()
        • towhee.trainer.utils.trainer_utils.get_world_size
          • get_world_size()
        • towhee.trainer.utils.trainer_utils.honor_type
          • honor_type()
        • towhee.trainer.utils.trainer_utils.is_dist_avail_and_initialized
          • is_dist_avail_and_initialized()
        • towhee.trainer.utils.trainer_utils.is_main_process
          • is_main_process()
        • towhee.trainer.utils.trainer_utils.is_torch_tensor
          • is_torch_tensor()
        • towhee.trainer.utils.trainer_utils.recursively_apply
          • recursively_apply()
        • towhee.trainer.utils.trainer_utils.reduce_value
          • reduce_value()
        • towhee.trainer.utils.trainer_utils.send_to_device
          • send_to_device()
        • towhee.trainer.utils.trainer_utils.set_seed
          • set_seed()
        • towhee.trainer.utils.trainer_utils.unwrap_model
          • unwrap_model()
        • towhee.trainer.utils.trainer_utils.SchedulerType
          • SchedulerType
        • towhee.trainer.utils.trainer_utils.TrainOutput
          • TrainOutput
            • TrainOutput.__add__()
            • TrainOutput.__getitem__()
            • TrainOutput.__mul__()
            • TrainOutput.__repr__()
            • TrainOutput.count()
            • TrainOutput.global_step
            • TrainOutput.index()
            • TrainOutput.training_loss
  • towhee.types
    • towhee.types.arg
    • towhee.types.audio_frame
      • towhee.types.audio_frame.AudioFrame
        • AudioFrame
          • AudioFrame.T
          • AudioFrame.__add__()
          • AudioFrame.__getitem__()
          • AudioFrame.__mul__()
          • AudioFrame.__or__()
          • AudioFrame.__repr__()
          • AudioFrame.__rshift__()
          • AudioFrame.__setitem__()
          • AudioFrame.all()
          • AudioFrame.any()
          • AudioFrame.argmax()
          • AudioFrame.argmin()
          • AudioFrame.argpartition()
          • AudioFrame.argsort()
          • AudioFrame.astype()
          • AudioFrame.base
          • AudioFrame.byteswap()
          • AudioFrame.choose()
          • AudioFrame.clip()
          • AudioFrame.compress()
          • AudioFrame.conj()
          • AudioFrame.conjugate()
          • AudioFrame.copy()
          • AudioFrame.ctypes
          • AudioFrame.cumprod()
          • AudioFrame.cumsum()
          • AudioFrame.data
          • AudioFrame.diagonal()
          • AudioFrame.dtype
          • AudioFrame.dump()
          • AudioFrame.dumps()
          • AudioFrame.fill()
          • AudioFrame.flags
          • AudioFrame.C_CONTIGUOUS
          • AudioFrame.F_CONTIGUOUS
          • AudioFrame.OWNDATA
          • AudioFrame.WRITEABLE
          • AudioFrame.ALIGNED
          • AudioFrame.WRITEBACKIFCOPY
          • AudioFrame.FNC
          • AudioFrame.FORC
          • AudioFrame.BEHAVED
          • AudioFrame.CARRAY
          • AudioFrame.FARRAY
          • AudioFrame.flat
          • AudioFrame.flatten()
          • AudioFrame.getfield()
          • AudioFrame.imag
          • AudioFrame.item()
          • AudioFrame.itemset()
          • AudioFrame.itemsize
          • AudioFrame.max()
          • AudioFrame.mean()
          • AudioFrame.min()
          • AudioFrame.nbytes
          • AudioFrame.ndim
          • AudioFrame.newbyteorder()
          • AudioFrame.nonzero()
          • AudioFrame.partition()
          • AudioFrame.prod()
          • AudioFrame.ptp()
          • AudioFrame.put()
          • AudioFrame.ravel()
          • AudioFrame.real
          • AudioFrame.repeat()
          • AudioFrame.reshape()
          • AudioFrame.resize()
          • AudioFrame.round()
          • AudioFrame.searchsorted()
          • AudioFrame.setfield()
          • AudioFrame.setflags()
          • AudioFrame.shape
          • AudioFrame.size
          • AudioFrame.sort()
          • AudioFrame.squeeze()
          • AudioFrame.std()
          • AudioFrame.strides
          • AudioFrame.sum()
          • AudioFrame.swapaxes()
          • AudioFrame.take()
          • AudioFrame.tobytes()
          • AudioFrame.tofile()
          • AudioFrame.tolist()
          • AudioFrame.tostring()
          • AudioFrame.trace()
          • AudioFrame.transpose()
          • AudioFrame.var()
          • AudioFrame.view()
    • towhee.types.image
      • towhee.types.image.Image
        • Image
          • Image.T
          • Image.__add__()
          • Image.__getitem__()
          • Image.__mul__()
          • Image.__or__()
          • Image.__repr__()
          • Image.__rshift__()
          • Image.__setitem__()
          • Image.all()
          • Image.any()
          • Image.argmax()
          • Image.argmin()
          • Image.argpartition()
          • Image.argsort()
          • Image.astype()
          • Image.base
          • Image.byteswap()
          • Image.choose()
          • Image.clip()
          • Image.compress()
          • Image.conj()
          • Image.conjugate()
          • Image.copy()
          • Image.ctypes
          • Image.cumprod()
          • Image.cumsum()
          • Image.data
          • Image.diagonal()
          • Image.dtype
          • Image.dump()
          • Image.dumps()
          • Image.fill()
          • Image.flags
          • Image.C_CONTIGUOUS
          • Image.F_CONTIGUOUS
          • Image.OWNDATA
          • Image.WRITEABLE
          • Image.ALIGNED
          • Image.WRITEBACKIFCOPY
          • Image.FNC
          • Image.FORC
          • Image.BEHAVED
          • Image.CARRAY
          • Image.FARRAY
          • Image.flat
          • Image.flatten()
          • Image.getfield()
          • Image.imag
          • Image.item()
          • Image.itemset()
          • Image.itemsize
          • Image.max()
          • Image.mean()
          • Image.min()
          • Image.nbytes
          • Image.ndim
          • Image.newbyteorder()
          • Image.nonzero()
          • Image.partition()
          • Image.prod()
          • Image.ptp()
          • Image.put()
          • Image.ravel()
          • Image.real
          • Image.repeat()
          • Image.reshape()
          • Image.resize()
          • Image.round()
          • Image.searchsorted()
          • Image.setfield()
          • Image.setflags()
          • Image.shape
          • Image.size
          • Image.sort()
          • Image.squeeze()
          • Image.std()
          • Image.strides
          • Image.sum()
          • Image.swapaxes()
          • Image.take()
          • Image.tobytes()
          • Image.tofile()
          • Image.tolist()
          • Image.tostring()
          • Image.trace()
          • Image.transpose()
          • Image.var()
          • Image.view()
    • towhee.types.image_utils
      • towhee.types.image_utils.from_pil
        • from_pil()
      • towhee.types.image_utils.to_image_color
        • to_image_color()
      • towhee.types.image_utils.to_pil
        • to_pil()
    • towhee.types.tensor_array
      • towhee.types.tensor_array.TensorArray
        • TensorArray
          • TensorArray.__getitem__()
          • TensorArray.__init__()
          • TensorArray.__repr__()
          • TensorArray.buffers()
          • TensorArray.cast()
          • TensorArray.dictionary_encode()
          • TensorArray.diff()
          • TensorArray.drop_null()
          • TensorArray.equals()
          • TensorArray.fill_null()
          • TensorArray.filter()
          • TensorArray.format()
          • TensorArray.from_buffers()
          • TensorArray.from_pandas()
          • TensorArray.from_storage()
          • TensorArray.get_total_buffer_size()
          • TensorArray.index()
          • TensorArray.is_nan()
          • TensorArray.is_null()
          • TensorArray.is_valid()
          • TensorArray.nbytes
          • TensorArray.offset
          • TensorArray.slice()
          • TensorArray.sort()
          • TensorArray.sum()
          • TensorArray.take()
          • TensorArray.to_numpy()
          • TensorArray.to_pandas()
          • TensorArray.to_pylist()
          • TensorArray.to_string()
          • TensorArray.tolist()
          • TensorArray.unique()
          • TensorArray.validate()
          • TensorArray.value_counts()
          • TensorArray.view()
    • towhee.types.video_frame
      • towhee.types.video_frame.VideoFrame
        • VideoFrame
          • VideoFrame.T
          • VideoFrame.__add__()
          • VideoFrame.__getitem__()
          • VideoFrame.__mul__()
          • VideoFrame.__or__()
          • VideoFrame.__repr__()
          • VideoFrame.__rshift__()
          • VideoFrame.__setitem__()
          • VideoFrame.all()
          • VideoFrame.any()
          • VideoFrame.argmax()
          • VideoFrame.argmin()
          • VideoFrame.argpartition()
          • VideoFrame.argsort()
          • VideoFrame.astype()
          • VideoFrame.base
          • VideoFrame.byteswap()
          • VideoFrame.choose()
          • VideoFrame.clip()
          • VideoFrame.compress()
          • VideoFrame.conj()
          • VideoFrame.conjugate()
          • VideoFrame.copy()
          • VideoFrame.ctypes
          • VideoFrame.cumprod()
          • VideoFrame.cumsum()
          • VideoFrame.data
          • VideoFrame.diagonal()
          • VideoFrame.dtype
          • VideoFrame.dump()
          • VideoFrame.dumps()
          • VideoFrame.fill()
          • VideoFrame.flags
          • VideoFrame.C_CONTIGUOUS
          • VideoFrame.F_CONTIGUOUS
          • VideoFrame.OWNDATA
          • VideoFrame.WRITEABLE
          • VideoFrame.ALIGNED
          • VideoFrame.WRITEBACKIFCOPY
          • VideoFrame.FNC
          • VideoFrame.FORC
          • VideoFrame.BEHAVED
          • VideoFrame.CARRAY
          • VideoFrame.FARRAY
          • VideoFrame.flat
          • VideoFrame.flatten()
          • VideoFrame.getfield()
          • VideoFrame.imag
          • VideoFrame.item()
          • VideoFrame.itemset()
          • VideoFrame.itemsize
          • VideoFrame.max()
          • VideoFrame.mean()
          • VideoFrame.min()
          • VideoFrame.nbytes
          • VideoFrame.ndim
          • VideoFrame.newbyteorder()
          • VideoFrame.nonzero()
          • VideoFrame.partition()
          • VideoFrame.prod()
          • VideoFrame.ptp()
          • VideoFrame.put()
          • VideoFrame.ravel()
          • VideoFrame.real
          • VideoFrame.repeat()
          • VideoFrame.reshape()
          • VideoFrame.resize()
          • VideoFrame.round()
          • VideoFrame.searchsorted()
          • VideoFrame.setfield()
          • VideoFrame.setflags()
          • VideoFrame.shape
          • VideoFrame.size
          • VideoFrame.sort()
          • VideoFrame.squeeze()
          • VideoFrame.std()
          • VideoFrame.strides
          • VideoFrame.sum()
          • VideoFrame.swapaxes()
          • VideoFrame.take()
          • VideoFrame.tobytes()
          • VideoFrame.tofile()
          • VideoFrame.tolist()
          • VideoFrame.tostring()
          • VideoFrame.trace()
          • VideoFrame.transpose()
          • VideoFrame.var()
          • VideoFrame.view()
  • towhee.utils
    • towhee.utils.atomic_count
      • towhee.utils.atomic_count.AtomicCount
        • AtomicCount
          • AtomicCount.__init__()
    • towhee.utils.av_utils
    • towhee.utils.cv2_utils
    • towhee.utils.dependency_control
      • towhee.utils.dependency_control.get_yes_no
        • get_yes_no()
      • towhee.utils.dependency_control.prompt_install
        • prompt_install()
    • towhee.utils.faiss_utils
      • towhee.utils.faiss_utils.KVStorage
        • KVStorage
          • KVStorage.__init__()
    • towhee.utils.git_utils
      • towhee.utils.git_utils.GitUtils
        • GitUtils
          • GitUtils.__init__()
          • GitUtils.add()
          • GitUtils.clone()
          • GitUtils.commit()
          • GitUtils.exists()
          • GitUtils.pull()
          • GitUtils.push()
          • GitUtils.status()
    • towhee.utils.handler_mixin
      • towhee.utils.handler_mixin.HandlerMixin
        • HandlerMixin
    • towhee.utils.hub_file_utils
      • towhee.utils.hub_file_utils.HubFileUtils
        • HubFileUtils
          • HubFileUtils.__init__()
    • towhee.utils.hub_utils
      • towhee.utils.hub_utils.HubUtils
        • HubUtils
          • HubUtils.__init__()
          • HubUtils.add_tag()
          • HubUtils.convert_dict()
          • HubUtils.create()
          • HubUtils.create_repo()
          • HubUtils.create_token()
          • HubUtils.delete_token()
          • HubUtils.get_commits()
          • HubUtils.get_file()
          • HubUtils.get_info()
          • HubUtils.get_lfs()
          • HubUtils.get_tree()
          • HubUtils.get_user()
          • HubUtils.login()
          • HubUtils.logout()
          • HubUtils.update_text()
    • towhee.utils.ipython_utils
    • towhee.utils.log
    • towhee.utils.matplotlib_utils
    • towhee.utils.milvus_utils
    • towhee.utils.ndarray_utils
      • towhee.utils.ndarray_utils.from_ndarray
        • from_ndarray()
      • towhee.utils.ndarray_utils.from_src
        • from_src()
      • towhee.utils.ndarray_utils.from_zip
        • from_zip()
      • towhee.utils.ndarray_utils.rgb2bgr
        • rgb2bgr()
      • towhee.utils.ndarray_utils.to_ndarray
        • to_ndarray()
    • towhee.utils.numba_utils
    • towhee.utils.pandas_utils
    • towhee.utils.pil_utils
      • towhee.utils.pil_utils.from_pil
        • from_pil()
      • towhee.utils.pil_utils.from_src
        • from_src()
      • towhee.utils.pil_utils.to_pil
        • to_pil()
    • towhee.utils.plot_utils
      • towhee.utils.plot_utils.plot_img
        • plot_img()
      • towhee.utils.plot_utils.plot_img_list
        • plot_img_list()
    • towhee.utils.repo_normalize
      • towhee.utils.repo_normalize.RepoNormalize
        • RepoNormalize
          • RepoNormalize.__init__()
          • RepoNormalize.check_repo()
          • RepoNormalize.check_uri()
          • RepoNormalize.get_full_uri()
          • RepoNormalize.get_name()
          • RepoNormalize.get_op()
          • RepoNormalize.get_pipeline()
          • RepoNormalize.mapping()
          • RepoNormalize.parse_uri()
    • towhee.utils.scipy_utils
    • towhee.utils.singleton
      • towhee.utils.singleton.singleton
        • singleton()
    • towhee.utils.thirdparty
      • towhee.utils.thirdparty.pyarrow
    • towhee.utils.yaml_utils
      • towhee.utils.yaml_utils.dump_yaml
        • dump_yaml()
      • towhee.utils.yaml_utils.load_yaml
        • load_yaml()

Indices and tables

• Index

• Module Index