(self, qkv: torch.Tensor)

( model: nn.Module, data_loader: list, sync=True, progress_bar=False, )

( self, network: nn.Module or None = None, subset_size: int = 16000, subset_ba

(batch_id: int)

( self, checkpoint=None, only_state_dict=True, epoch=0, model_name=Non

(self, epoch: int)

(self, image: np.ndarray, image_format: str = "RGB")

(model: nn.Module, eps: float or None = None)

(self)

(self)

( ema: nn.Module, new_state_dict: dict[str, torch.Tensor], decay: float )

(self, epoch, batch_id=0)

( self, model=None, data_loader=None, is_test=True, epoch=0 )

(model: nn.Module, init_val=0)

(self, image: torch.Tensor)

(self, image: np.ndarray)

(self)

(self)

(self, is_distributed=True)

(self, model: nn.Module, decay: float, warmup_steps=2000)

( self, optimizer: torch.optim.Optimizer, warmup_steps: int, warmup_lr: float,

(self, path: str, model: nn.Module, data_provider: DataProvider)

(self, **kwargs)

( self, train_batch_size: int, test_batch_size: int or None, valid_size: int o

(self)

(self, loader: RRSDataLoader)

(self, loader)

(self, loader)

(self)

(self, **kwargs)

( self, scale=(0.08, 1.0), ratio=(3.0 / 4.0, 4.0 / 3.0), interpolation: str =

(self, brightness=0, contrast=0, saturation=0, hue=0, key="data")

( self, backbone: EfficientViTBackbone or EfficientViTLargeBackbone, head: ClsHead )

(self, size: int)

( self, fid_list: list[str], in_channel_list: list[int], head_width: int,

( self, backbone: EfficientViTBackbone or EfficientViTLargeBackbone, neck: SamNeck )

( self, image_encoder: EfficientViTSamImageEncoder, prompt_encoder: PromptEncoder,

(self, sam_model: EfficientViTSam)

( self, model: EfficientViTSam, points_per_side: int or None = 32, points_per_

( self, width_list: list[int], depth_list: list[int], block_list: list[str] or

( self, backbone: EfficientViTBackbone or EfficientViTLargeBackbone, head: SegHead )

( self, main: nn.Module, shortcut: nn.Module or None, post_act=None, p

( self, in_channels: int, out_channels: int, kernel_size=3, stride=1,

( self, mode="bicubic", size: int or tuple[int, int] or list[int] or None = None,

( self, in_features: int, out_features: int, use_bias=True, dropout=0,

( self, in_channels: int, out_channels: int, kernel_size=3, stride=1,

( self, in_channels: int, out_channels: int, kernel_size=3, stride=1,

( self, in_channels: int, out_channels: int, kernel_size=3, stride=1,

( self, in_channels: int, out_channels: int, heads: int or None = None,

( self, in_channels: int, heads_ratio: float = 1.0, dim=32, expand_rat

( self, main: nn.Module or None, shortcut: nn.Module or None, post_act=None,

( self, inputs: dict[str, nn.Module], merge: str, post_input: nn.Module or Non

(self, op_list: list[nn.Module or None])

(self)

(self)

(self)

(self)

(self)

(self)

(self)

(self)

(self)

(self)

(self, attr, val)

(self, key, val)

(self)

(w)

(num_worker_suggest, num_worker_created, cpuset_checked)

(self)

(self)

(self)

(worker_init_fn, world_size, rank_id, worker_id)

( dataset_kind, dataset, index_queue, data_queue, done_event, auto_collation, coll

(self)

(network: nn.Module, drop_config: dict[str, any] or None)

( network: nn.Module, drop_prob: float, linear_decay=True, scheduled=True, skip=0, )

(self, image: Image.Image)

(self, image: Image.Image)

(self)

(self, feed_dict: dict[str, any])

(self, node)

(self)

( image: np.ndarray, query: str, confidence_threshold: float, nms_threshold: float, )

(self)

(**kwargs)

(**kwargs)

(**kwargs)

(**kwargs)

(**kwargs)

(**kwargs)

(**kwargs)

(image_size: int = 512, **kwargs)

(image_size: int = 512, **kwargs)

(image_size: int = 512, **kwargs)

(image_size: int = 1024, **kwargs)

(image_size: int = 1024, **kwargs)

(dataset: str, **kwargs)

(dataset: str, **kwargs)