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
    • DataProcessingMixin
• 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.update_default_cache
    • update_default_cache()
  • 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.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.datacollection
    • towhee.datacollection.data_collection
      • towhee.datacollection.data_collection.DataCollection
        • DataCollection
          • DataCollection.__add__()
          • DataCollection.__getitem__()
          • DataCollection.__init__()
          • DataCollection.__repr__()
          • DataCollection.__setitem__()
          • DataCollection.copy()
          • DataCollection.show()
          • DataCollection.to_list()
    • towhee.datacollection.entity
      • towhee.datacollection.entity.Entity
        • Entity
          • Entity.__getitem__()
          • Entity.__init__()
          • Entity.__repr__()
          • Entity.combine()
          • Entity.from_dict()
    • towhee.datacollection.mixins
      • towhee.datacollection.mixins.display
        • towhee.datacollection.mixins.display.calc_df
          • calc_df()
        • towhee.datacollection.mixins.display.get_df_on_columns
          • get_df_on_columns()
        • towhee.datacollection.mixins.display.table_display
          • table_display()
        • towhee.datacollection.mixins.display.to_html_table
          • to_html_table()
        • towhee.datacollection.mixins.display.to_plain_table
          • to_plain_table()
        • towhee.datacollection.mixins.display.to_printable_table
          • to_printable_table()
        • towhee.datacollection.mixins.display.DisplayMixin
          • DisplayMixin
            • DisplayMixin.__init__()
            • DisplayMixin.show()
  • 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.dc2
  • 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.create_op
        • create_op()
      • 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.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.combine()
          • DataCollection.compile_dag()
          • 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.group_by()
          • DataCollection.head()
          • DataCollection.image_imshow()
          • DataCollection.insert()
          • DataCollection.is_stream
          • DataCollection.map()
          • DataCollection.mmap()
          • DataCollection.netx()
          • DataCollection.notify_consumed()
          • DataCollection.pipeline_config()
          • DataCollection.pmap()
          • DataCollection.pop()
          • DataCollection.range()
          • DataCollection.ray_start()
          • DataCollection.read_camera()
          • DataCollection.read_video()
          • DataCollection.read_zip()
          • DataCollection.register_dag()
          • DataCollection.remove()
          • DataCollection.report()
          • DataCollection.resolve()
          • 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.combine()
          • DataFrame.compile_dag()
          • DataFrame.config()
          • DataFrame.copy()
          • DataFrame.count()
          • DataFrame.create_arrow_table()
          • 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.group_by()
          • DataFrame.head()
          • DataFrame.image_imshow()
          • DataFrame.insert()
          • DataFrame.is_stream
          • DataFrame.map()
          • DataFrame.mmap()
          • DataFrame.mode
          • DataFrame.netx()
          • DataFrame.notify_consumed()
          • 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.register_dag()
          • DataFrame.remove()
          • DataFrame.rename()
          • DataFrame.replace()
          • DataFrame.report()
          • DataFrame.resolve()
          • DataFrame.reverse()
          • DataFrame.rolling()
          • DataFrame.run()
          • DataFrame.safe()
          • DataFrame.sample()
          • DataFrame.select
          • 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__()
          • Entity.combine()
          • Entity.from_dict()
      • towhee.functional.entity.EntityView
        • EntityView
          • EntityView.__getattr__()
          • EntityView.__init__()
          • EntityView.__repr__()
    • towhee.functional.mixins
      • towhee.functional.mixins.DCMixins
        • DCMixins
          • DCMixins.__init__()
          • DCMixins.append()
          • DCMixins.as_function()
          • DCMixins.batch()
          • DCMixins.clear()
          • DCMixins.combine()
          • DCMixins.compile_dag()
          • 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.group_by()
          • DCMixins.head()
          • DCMixins.image_imshow()
          • DCMixins.insert()
          • DCMixins.is_stream
          • DCMixins.mmap()
          • DCMixins.netx()
          • DCMixins.notify_consumed()
          • DCMixins.pipeline_config()
          • DCMixins.pmap()
          • DCMixins.pop()
          • DCMixins.ray_start()
          • DCMixins.read_camera()
          • DCMixins.read_video()
          • DCMixins.read_zip()
          • DCMixins.register_dag()
          • DCMixins.remove()
          • DCMixins.report()
          • DCMixins.resolve()
          • 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.audio
        • towhee.functional.mixins.audio.AudioMixin
          • AudioMixin
      • towhee.functional.mixins.column
        • towhee.functional.mixins.column.ColumnMixin
          • ColumnMixin
            • ColumnMixin.ModeFlag
            • ColumnMixin.__init__()
            • ColumnMixin.cmap()
            • ColumnMixin.create_arrow_table()
            • 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.image_imshow()
            • 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__()
            • DagMixin.compile_dag()
            • DagMixin.netx()
            • DagMixin.notify_consumed()
            • DagMixin.register_dag()
      • towhee.functional.mixins.data_processing
        • towhee.functional.mixins.data_processing.DataProcessingMixin
          • DataProcessingMixin
            • DataProcessingMixin.batch()
            • DataProcessingMixin.combine()
            • DataProcessingMixin.flatten()
            • DataProcessingMixin.group_by()
            • 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()
            • DataFrameMixin.select
      • 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
            • DispatcherMixin.resolve()
      • 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.kv_storage
        • towhee.functional.mixins.kv_storage.KVStorageMixin
          • KVStorageMixin
            • KVStorageMixin.__init__()
      • 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.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__()
          • WritableTable.prepare()
          • WritableTable.seal()
          • WritableTable.write()
          • WritableTable.write_many()
  • 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.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.file_manager
    • towhee.hub.operator_manager
      • towhee.hub.operator_manager.OperatorManager
        • OperatorManager
          • OperatorManager.__init__()
          • OperatorManager.create()
          • OperatorManager.create_with_token()
          • OperatorManager.download()
          • OperatorManager.download_executor()
          • OperatorManager.download_files()
          • OperatorManager.exists()
          • OperatorManager.get_file_list()
          • OperatorManager.get_repo_type()
          • OperatorManager.init_nnoperator()
          • OperatorManager.init_pyoperator()
          • OperatorManager.latest_commit()
          • OperatorManager.obtain_lfs_extensions()
    • towhee.hub.pipeline_manager
      • towhee.hub.pipeline_manager.PipelineManager
        • PipelineManager
          • PipelineManager.__init__()
          • PipelineManager.check()
          • PipelineManager.create()
          • PipelineManager.create_with_token()
          • PipelineManager.download()
          • PipelineManager.download_executor()
          • PipelineManager.download_files()
          • PipelineManager.exists()
          • PipelineManager.get_file_list()
          • PipelineManager.get_repo_type()
          • PipelineManager.init_pipeline()
          • PipelineManager.latest_commit()
          • PipelineManager.obtain_lfs_extensions()
    • towhee.hub.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.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_load_state_dict_post_hook()
            • AcarNet.register_module()
            • AcarNet.register_parameter()
            • 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_load_state_dict_post_hook()
            • LayerNorm.register_module()
            • LayerNorm.register_parameter()
            • 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_load_state_dict_post_hook()
            • QuickGELU.register_module()
            • QuickGELU.register_parameter()
            • 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_load_state_dict_post_hook()
            • ResidualAttentionBlock.register_module()
            • ResidualAttentionBlock.register_parameter()
            • 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_load_state_dict_post_hook()
            • TAggregate.register_module()
            • TAggregate.register_parameter()
            • 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_load_state_dict_post_hook()
            • TemporalTransformer.register_module()
            • TemporalTransformer.register_parameter()
            • TemporalTransformer.requires_grad_()
            • TemporalTransformer.set_extra_state()
            • TemporalTransformer.share_memory()
            • TemporalTransformer.state_dict()
            • TemporalTransformer.to()
            • TemporalTransformer.to_empty()
            • TemporalTransformer.train()
            • TemporalTransformer.type()
            • TemporalTransformer.xpu()
            • TemporalTransformer.zero_grad()
        • towhee.models.action_clip.visual_prompt.VisualPrompt
          • VisualPrompt
            • VisualPrompt.__call__()
            • VisualPrompt.__init__()
            • VisualPrompt.__repr__()
            • VisualPrompt.add_module()
            • VisualPrompt.apply()
            • VisualPrompt.bfloat16()
            • VisualPrompt.buffers()
            • VisualPrompt.children()
            • VisualPrompt.cpu()
            • VisualPrompt.cuda()
            • VisualPrompt.double()
            • VisualPrompt.eval()
            • VisualPrompt.extra_repr()
            • VisualPrompt.float()
            • VisualPrompt.forward()
            • VisualPrompt.get_buffer()
            • VisualPrompt.get_extra_state()
            • VisualPrompt.get_parameter()
            • VisualPrompt.get_submodule()
            • VisualPrompt.half()
            • VisualPrompt.ipu()
            • VisualPrompt.load_state_dict()
            • VisualPrompt.modules()
            • VisualPrompt.named_buffers()
            • VisualPrompt.named_children()
            • VisualPrompt.named_modules()
            • VisualPrompt.named_parameters()
            • VisualPrompt.parameters()
            • VisualPrompt.register_backward_hook()
            • VisualPrompt.register_buffer()
            • VisualPrompt.register_forward_hook()
            • VisualPrompt.register_forward_pre_hook()
            • VisualPrompt.register_full_backward_hook()
            • VisualPrompt.register_load_state_dict_post_hook()
            • VisualPrompt.register_module()
            • VisualPrompt.register_parameter()
            • 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_load_state_dict_post_hook()
            • VCOPHeader.register_module()
            • VCOPHeader.register_parameter()
            • 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_load_state_dict_post_hook()
            • MultiheadAttention.register_module()
            • MultiheadAttention.register_parameter()
            • 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_load_state_dict_post_hook()
            • AttentionPool2d.register_module()
            • AttentionPool2d.register_parameter()
            • 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_load_state_dict_post_hook()
            • Bottleneck.register_module()
            • Bottleneck.register_parameter()
            • 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_load_state_dict_post_hook()
            • CLIP.register_module()
            • CLIP.register_parameter()
            • 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_load_state_dict_post_hook()
            • LayerNorm.register_module()
            • LayerNorm.register_parameter()
            • 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_load_state_dict_post_hook()
            • ModifiedResNet.register_module()
            • ModifiedResNet.register_parameter()
            • 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_load_state_dict_post_hook()
            • QuickGELU.register_module()
            • QuickGELU.register_parameter()
            • 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_load_state_dict_post_hook()
            • ResidualAttentionBlock.register_module()
            • ResidualAttentionBlock.register_parameter()
            • 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_load_state_dict_post_hook()
            • Transformer.register_module()
            • Transformer.register_parameter()
            • 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_load_state_dict_post_hook()
            • VisionTransformer.register_module()
            • VisionTransformer.register_parameter()
            • VisionTransformer.requires_grad_()
            • VisionTransformer.set_extra_state()
            • VisionTransformer.share_memory()
            • VisionTransformer.state_dict()
            • VisionTransformer.to()
            • VisionTransformer.to_empty()
            • VisionTransformer.train()
            • VisionTransformer.type()
            • VisionTransformer.xpu()
            • VisionTransformer.zero_grad()
      • towhee.models.clip.clip_utils
        • towhee.models.clip.clip_utils.base_configs
          • base_configs()
        • towhee.models.clip.clip_utils.convert_weights
          • convert_weights()
        • towhee.models.clip.clip_utils.get_configs
          • get_configs()
        • towhee.models.clip.clip_utils.get_transforms
          • get_transforms()
        • towhee.models.clip.clip_utils.patch_device
          • patch_device()
        • towhee.models.clip.clip_utils.patch_float
          • patch_float()
        • towhee.models.clip.clip_utils.tokenize
          • tokenize()
      • towhee.models.clip.simple_tokenizer
        • towhee.models.clip.simple_tokenizer.basic_clean
          • basic_clean()
        • towhee.models.clip.simple_tokenizer.bytes_to_unicode
          • bytes_to_unicode()
        • towhee.models.clip.simple_tokenizer.default_bpe
          • default_bpe()
        • towhee.models.clip.simple_tokenizer.get_pairs
          • get_pairs()
        • towhee.models.clip.simple_tokenizer.whitespace_clean
          • whitespace_clean()
        • towhee.models.clip.simple_tokenizer.SimpleTokenizer
          • SimpleTokenizer
            • SimpleTokenizer.__init__()
    • towhee.models.clip4clip
      • towhee.models.clip4clip.clip4clip
        • towhee.models.clip4clip.clip4clip.create_model
          • create_model()
        • towhee.models.clip4clip.clip4clip.CLIP4Clip
          • CLIP4Clip
            • CLIP4Clip.__call__()
            • CLIP4Clip.__init__()
            • CLIP4Clip.__repr__()
            • CLIP4Clip.add_module()
            • CLIP4Clip.apply()
            • CLIP4Clip.bfloat16()
            • CLIP4Clip.buffers()
            • CLIP4Clip.children()
            • CLIP4Clip.cpu()
            • CLIP4Clip.cuda()
            • CLIP4Clip.double()
            • CLIP4Clip.eval()
            • CLIP4Clip.extra_repr()
            • CLIP4Clip.float()
            • CLIP4Clip.forward()
            • CLIP4Clip.get_buffer()
            • CLIP4Clip.get_extra_state()
            • CLIP4Clip.get_parameter()
            • CLIP4Clip.get_submodule()
            • CLIP4Clip.half()
            • CLIP4Clip.init_weights()
            • CLIP4Clip.ipu()
            • CLIP4Clip.load_state_dict()
            • CLIP4Clip.modules()
            • CLIP4Clip.named_buffers()
            • CLIP4Clip.named_children()
            • CLIP4Clip.named_modules()
            • CLIP4Clip.named_parameters()
            • CLIP4Clip.parameters()
            • CLIP4Clip.register_backward_hook()
            • CLIP4Clip.register_buffer()
            • CLIP4Clip.register_forward_hook()
            • CLIP4Clip.register_forward_pre_hook()
            • CLIP4Clip.register_full_backward_hook()
            • CLIP4Clip.register_load_state_dict_post_hook()
            • CLIP4Clip.register_module()
            • CLIP4Clip.register_parameter()
            • 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_load_state_dict_post_hook()
            • CLIP4ClipPreTrainedModel.register_module()
            • CLIP4ClipPreTrainedModel.register_parameter()
            • 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_load_state_dict_post_hook()
            • CrossEn.register_module()
            • CrossEn.register_parameter()
            • 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_load_state_dict_post_hook()
            • LayerNorm.register_module()
            • LayerNorm.register_parameter()
            • 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_load_state_dict_post_hook()
            • PreTrainedModel.register_module()
            • PreTrainedModel.register_parameter()
            • 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_load_state_dict_post_hook()
            • CoCa.register_module()
            • CoCa.register_parameter()
            • 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_load_state_dict_post_hook()
            • ParallelTransformerBlock.register_module()
            • ParallelTransformerBlock.register_parameter()
            • 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_load_state_dict_post_hook()
            • Backbone.register_module()
            • Backbone.register_parameter()
            • 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_load_state_dict_post_hook()
            • BackboneBase.register_module()
            • BackboneBase.register_parameter()
            • 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_load_state_dict_post_hook()
            • Joiner.register_module()
            • Joiner.register_parameter()
            • 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_load_state_dict_post_hook()
            • CoFormer.register_module()
            • CoFormer.register_parameter()
            • 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_load_state_dict_post_hook()
            • Transformer.register_module()
            • Transformer.register_parameter()
            • 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_load_state_dict_post_hook()
            • TransformerDecoder.register_module()
            • TransformerDecoder.register_parameter()
            • 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_load_state_dict_post_hook()
            • TransformerDecoderLayer.register_module()
            • TransformerDecoderLayer.register_parameter()
            • 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_load_state_dict_post_hook()
            • TransformerEncoder.register_module()
            • TransformerEncoder.register_parameter()
            • 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_load_state_dict_post_hook()
            • TransformerEncoderLayer.register_module()
            • TransformerEncoderLayer.register_parameter()
            • 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_load_state_dict_post_hook()
            • CEModule.register_module()
            • CEModule.register_parameter()
            • 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_load_state_dict_post_hook()
            • CENet.register_module()
            • CENet.register_parameter()
            • 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_load_state_dict_post_hook()
            • ContextGating.register_module()
            • ContextGating.register_parameter()
            • 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_load_state_dict_post_hook()
            • ContextGatingReasoning.register_module()
            • ContextGatingReasoning.register_parameter()
            • 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_load_state_dict_post_hook()
            • G_reason.register_module()
            • G_reason.register_parameter()
            • 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_load_state_dict_post_hook()
            • GatedEmbeddingUnit.register_module()
            • GatedEmbeddingUnit.register_parameter()
            • 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_load_state_dict_post_hook()
            • GatedEmbeddingUnitReasoning.register_module()
            • GatedEmbeddingUnitReasoning.register_parameter()
            • 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_load_state_dict_post_hook()
            • MimicCEGatedEmbeddingUnit.register_module()
            • MimicCEGatedEmbeddingUnit.register_parameter()
            • 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_load_state_dict_post_hook()
            • Mish.register_module()
            • Mish.register_parameter()
            • 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_load_state_dict_post_hook()
            • ReduceDim.register_module()
            • ReduceDim.register_parameter()
            • 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_load_state_dict_post_hook()
            • RelationModuleMultiScale.register_module()
            • RelationModuleMultiScale.register_parameter()
            • 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_load_state_dict_post_hook()
            • RelationModuleMultiScale_Cat.register_module()
            • RelationModuleMultiScale_Cat.register_parameter()
            • 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_load_state_dict_post_hook()
            • SpatialMLP.register_module()
            • SpatialMLP.register_parameter()
            • 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_load_state_dict_post_hook()
            • TemporalAttention.register_module()
            • TemporalAttention.register_parameter()
            • 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()