सामग्री पर जाएं

के लिए संदर्भ ultralytics/models/sam/modules/transformer.py

नोट

यह फ़ाइल यहाँ उपलब्ध है https://github.com/ultralytics/ultralytics/बूँद/मुख्य/ultralytics/मॉडल/sam/modules/transformer.py का उपयोग करें। यदि आप कोई समस्या देखते हैं तो कृपया पुल अनुरोध का योगदान करके इसे ठीक करने में मदद करें 🛠️। 🙏 धन्यवाद !



ultralytics.models.sam.modules.transformer.TwoWayTransformer

का रूप: Module

एक दो-तरफा ट्रांसफार्मर मॉड्यूल जो छवि और क्वेरी बिंदुओं दोनों पर एक साथ ध्यान देने में सक्षम बनाता है। यह वर्ग एक विशेष ट्रांसफार्मर डिकोडर के रूप में कार्य करता है जो प्रश्नों का उपयोग करके एक इनपुट छवि में भाग लेता है जिसका स्थितीय एम्बेडिंग आपूर्ति की जाती है। यह ऑब्जेक्ट डिटेक्शन, इमेज सेगमेंटेशन और पॉइंट क्लाउड जैसे कार्यों के लिए विशेष रूप से उपयोगी है संसाधन।

विशेषताएँ:

नाम प्रकार विवरण: __________
depth int

ट्रांसफार्मर में परतों की संख्या।

embedding_dim int

इनपुट एम्बेडिंग के लिए चैनल आयाम।

num_heads int

मल्टीहेड ध्यान के लिए सिर की संख्या।

mlp_dim int

एमएलपी ब्लॉक के लिए आंतरिक चैनल आयाम.

layers ModuleList

TwoWayAttentionBlock परतों की सूची जो ट्रांसफार्मर बनाती हैं।

final_attn_token_to_image Attention

अंतिम ध्यान परत क्वेरी से छवि पर लागू होती है।

norm_final_attn LayerNorm

परत सामान्यीकरण अंतिम प्रश्नों पर लागू होता है।

में स्रोत कोड ultralytics/models/sam/modules/transformer.py
 12 बांग्लादेश 12 बांग्लादेश 14 15 16 17 18  19 20 21 22 23 24 25 26 27 28 29 30 31 32 33  34 35 36  37  38        39 40   41 42    43 44   45        46   47 48 49 50 51 52 53 54 55 56 57 58  59 60 61 62 63 64 65 66 67 68          69 70   71 72  73 74 75  76 77          78  79 80 81 82 83 84 85 86 87 88  89 90 91 92   93 94 95 96 97  98    99  100  101  102  103  104  105  106  107108 109 110 111 112113
class TwoWayTransformer(nn.Module):
    """
    A Two-Way Transformer module that enables the simultaneous attention to both image and query points. This class
    serves as a specialized transformer decoder that attends to an input image using queries whose positional embedding
    is supplied. This is particularly useful for tasks like object detection, image segmentation, and point cloud
    processing.

    Attributes:
        depth (int): The number of layers in the transformer.
        embedding_dim (int): The channel dimension for the input embeddings.
        num_heads (int): The number of heads for multihead attention.
        mlp_dim (int): The internal channel dimension for the MLP block.
        layers (nn.ModuleList): The list of TwoWayAttentionBlock layers that make up the transformer.
        final_attn_token_to_image (Attention): The final attention layer applied from the queries to the image.
        norm_final_attn (nn.LayerNorm): The layer normalization applied to the final queries.
    """

    def __init__(
        self,
        depth: int,
        embedding_dim: int,
        num_heads: int,
        mlp_dim: int,
        activation: Type[nn.Module] = nn.ReLU,
        attention_downsample_rate: int = 2,
    ) -> None:
        """
        A transformer decoder that attends to an input image using queries whose positional embedding is supplied.

        Args:
          depth (int): number of layers in the transformer
          embedding_dim (int): the channel dimension for the input embeddings
          num_heads (int): the number of heads for multihead attention. Must
            divide embedding_dim
          mlp_dim (int): the channel dimension internal to the MLP block
          activation (nn.Module): the activation to use in the MLP block
        """
        super().__init__()
        self.depth = depth
        self.embedding_dim = embedding_dim
        self.num_heads = num_heads
        self.mlp_dim = mlp_dim
        self.layers = nn.ModuleList()

        for i in range(depth):
            self.layers.append(
                TwoWayAttentionBlock(
                    embedding_dim=embedding_dim,
                    num_heads=num_heads,
                    mlp_dim=mlp_dim,
                    activation=activation,
                    attention_downsample_rate=attention_downsample_rate,
                    skip_first_layer_pe=(i == 0),
                )
            )

        self.final_attn_token_to_image = Attention(embedding_dim, num_heads, downsample_rate=attention_downsample_rate)
        self.norm_final_attn = nn.LayerNorm(embedding_dim)

    def forward(
        self,
        image_embedding: Tensor,
        image_pe: Tensor,
        point_embedding: Tensor,
    ) -> Tuple[Tensor, Tensor]:
        """
        Args:
          image_embedding (torch.Tensor): image to attend to. Should be shape B x embedding_dim x h x w for any h and w.
          image_pe (torch.Tensor): the positional encoding to add to the image. Must have same shape as image_embedding.
          point_embedding (torch.Tensor): the embedding to add to the query points.
            Must have shape B x N_points x embedding_dim for any N_points.

        Returns:
          (torch.Tensor): the processed point_embedding
          (torch.Tensor): the processed image_embedding
        """
        # BxCxHxW -> BxHWxC == B x N_image_tokens x C
        bs, c, h, w = image_embedding.shape
        image_embedding = image_embedding.flatten(2).permute(0, 2, 1)
        image_pe = image_pe.flatten(2).permute(0, 2, 1)

        # Prepare queries
        queries = point_embedding
        keys = image_embedding

        # Apply transformer blocks and final layernorm
        for layer in self.layers:
            queries, keys = layer(
                queries=queries,
                keys=keys,
                query_pe=point_embedding,
                key_pe=image_pe,
            )

        # Apply the final attention layer from the points to the image
        q = queries + point_embedding
        k = keys + image_pe
        attn_out = self.final_attn_token_to_image(q=q, k=k, v=keys)
        queries = queries + attn_out
        queries = self.norm_final_attn(queries)

        return queries, keys

__init__(depth, embedding_dim, num_heads, mlp_dim, activation=nn.ReLU, attention_downsample_rate=2)

एक ट्रांसफार्मर डिकोडर जो उन प्रश्नों का उपयोग करके इनपुट छवि में भाग लेता है जिनकी स्थितिगत एम्बेडिंग की आपूर्ति की जाती है।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
depth int

ट्रांसफार्मर में परतों की संख्या

आवश्यक
embedding_dim int

इनपुट एम्बेडिंग के लिए चैनल आयाम

आवश्यक
num_heads int

मल्टीहेड ध्यान के लिए सिर की संख्या। अनिवार्य embedding_dim विभाजित करें

आवश्यक
mlp_dim int

एमएलपी ब्लॉक के लिए आंतरिक चैनल आयाम

आवश्यक
activation Module

एमएलपी ब्लॉक में उपयोग करने के लिए सक्रियण

ReLU
में स्रोत कोड ultralytics/models/sam/modules/transformer.py
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 545556575859606162 63646566 676869
def __init__(
    self,
    depth: int,
    embedding_dim: int,
    num_heads: int,
    mlp_dim: int,
    activation: Type[nn.Module] = nn.ReLU,
    attention_downsample_rate: int = 2,
) -> None:
    """
    A transformer decoder that attends to an input image using queries whose positional embedding is supplied.

    Args:
      depth (int): number of layers in the transformer
      embedding_dim (int): the channel dimension for the input embeddings
      num_heads (int): the number of heads for multihead attention. Must
        divide embedding_dim
      mlp_dim (int): the channel dimension internal to the MLP block
      activation (nn.Module): the activation to use in the MLP block
    """
    super().__init__()
    self.depth = depth
    self.embedding_dim = embedding_dim
    self.num_heads = num_heads
    self.mlp_dim = mlp_dim
    self.layers = nn.ModuleList()

    for i in range(depth):
        self.layers.append(
            TwoWayAttentionBlock(
                embedding_dim=embedding_dim,
                num_heads=num_heads,
                mlp_dim=mlp_dim,
                activation=activation,
                attention_downsample_rate=attention_downsample_rate,
                skip_first_layer_pe=(i == 0),
            )
        )

    self.final_attn_token_to_image = Attention(embedding_dim, num_heads, downsample_rate=attention_downsample_rate)
    self.norm_final_attn = nn.LayerNorm(embedding_dim)

forward(image_embedding, image_pe, point_embedding)

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
image_embedding Tensor

भाग लेने के लिए छवि। किसी भी h और w के लिए आकार B x embedding_dim x h x w होना चाहिए।

आवश्यक
image_pe Tensor

छवि में जोड़ने के लिए स्थितीय एन्कोडिंग। image_embedding के समान आकार होना चाहिए।

आवश्यक
point_embedding Tensor

क्वेरी बिंदुओं में जोड़ने के लिए एम्बेडिंग। किसी भी N_points के लिए आकार B x N_points x embedding_dim होना चाहिए।

आवश्यक

देता:

प्रकार विवरण: __________
Tensor

संसाधित point_embedding

Tensor

संसाधित image_embedding

में स्रोत कोड ultralytics/models/sam/modules/transformer.py
71 72 73 74 75 76 77 78  79 80 81 82 83 84 85 86 87 88  89 90 91  92 93 94 95   96  97   98           99 100 101 102   103  104  105 106 107 108 109 110 111 112 113
def forward(
    self,
    image_embedding: Tensor,
    image_pe: Tensor,
    point_embedding: Tensor,
) -> Tuple[Tensor, Tensor]:
    """
    Args:
      image_embedding (torch.Tensor): image to attend to. Should be shape B x embedding_dim x h x w for any h and w.
      image_pe (torch.Tensor): the positional encoding to add to the image. Must have same shape as image_embedding.
      point_embedding (torch.Tensor): the embedding to add to the query points.
        Must have shape B x N_points x embedding_dim for any N_points.

    Returns:
      (torch.Tensor): the processed point_embedding
      (torch.Tensor): the processed image_embedding
    """
    # BxCxHxW -> BxHWxC == B x N_image_tokens x C
    bs, c, h, w = image_embedding.shape
    image_embedding = image_embedding.flatten(2).permute(0, 2, 1)
    image_pe = image_pe.flatten(2).permute(0, 2, 1)

    # Prepare queries
    queries = point_embedding
    keys = image_embedding

    # Apply transformer blocks and final layernorm
    for layer in self.layers:
        queries, keys = layer(
            queries=queries,
            keys=keys,
            query_pe=point_embedding,
            key_pe=image_pe,
        )

    # Apply the final attention layer from the points to the image
    q = queries + point_embedding
    k = keys + image_pe
    attn_out = self.final_attn_token_to_image(q=q, k=k, v=keys)
    queries = queries + attn_out
    queries = self.norm_final_attn(queries)

    return queries, keys



ultralytics.models.sam.modules.transformer.TwoWayAttentionBlock

का रूप: Module

एक ध्यान ब्लॉक जो दो दिशाओं में आत्म-ध्यान और क्रॉस-अटेंशन दोनों करता है: कुंजियों के लिए प्रश्न और प्रश्नों की कुंजी। इस ब्लॉक में चार मुख्य परतें होती हैं: (1) विरल इनपुट पर आत्म-ध्यान, (2) क्रॉस-अटेंशन घने आदानों के लिए विरल आदानों का, (3) विरल आदानों पर एक एमएलपी ब्लॉक, और (4) घने आदानों का क्रॉस-अटेंशन विरल इनपुट।

विशेषताएँ:

नाम प्रकार विवरण: __________
self_attn Attention

प्रश्नों के लिए आत्म-ध्यान परत।

norm1 LayerNorm

पहले ध्यान ब्लॉक के बाद परत सामान्यीकरण।

cross_attn_token_to_image Attention

प्रश्नों से कुंजियों तक क्रॉस-अटेंशन परत।

norm2 LayerNorm

दूसरे ध्यान ब्लॉक के बाद परत सामान्यीकरण।

mlp MLPBlock

एमएलपी ब्लॉक जो क्वेरी एम्बेडिंग को बदल देता है।

norm3 LayerNorm

एमएलपी ब्लॉक के बाद परत सामान्यीकरण।

norm4 LayerNorm

तीसरे ध्यान ब्लॉक के बाद परत सामान्यीकरण।

cross_attn_image_to_token Attention

कुंजियों से लेकर प्रश्नों तक क्रॉस-अटेंशन परत।

skip_first_layer_pe bool

चाहे पहली परत में स्थितीय एन्कोडिंग को छोड़ना हो।

में स्रोत कोड ultralytics/models/sam/modules/transformer.py
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140141 142 143 144 145 146 147148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170171 172 173 174 175 176177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199200201202
class TwoWayAttentionBlock(nn.Module):
    """
    An attention block that performs both self-attention and cross-attention in two directions: queries to keys and
    keys to queries. This block consists of four main layers: (1) self-attention on sparse inputs, (2) cross-attention
    of sparse inputs to dense inputs, (3) an MLP block on sparse inputs, and (4) cross-attention of dense inputs to
    sparse inputs.

    Attributes:
        self_attn (Attention): The self-attention layer for the queries.
        norm1 (nn.LayerNorm): Layer normalization following the first attention block.
        cross_attn_token_to_image (Attention): Cross-attention layer from queries to keys.
        norm2 (nn.LayerNorm): Layer normalization following the second attention block.
        mlp (MLPBlock): MLP block that transforms the query embeddings.
        norm3 (nn.LayerNorm): Layer normalization following the MLP block.
        norm4 (nn.LayerNorm): Layer normalization following the third attention block.
        cross_attn_image_to_token (Attention): Cross-attention layer from keys to queries.
        skip_first_layer_pe (bool): Whether to skip the positional encoding in the first layer.
    """

    def __init__(
        self,
        embedding_dim: int,
        num_heads: int,
        mlp_dim: int = 2048,
        activation: Type[nn.Module] = nn.ReLU,
        attention_downsample_rate: int = 2,
        skip_first_layer_pe: bool = False,
    ) -> None:
        """
        A transformer block with four layers: (1) self-attention of sparse inputs, (2) cross attention of sparse
        inputs to dense inputs, (3) mlp block on sparse inputs, and (4) cross attention of dense inputs to sparse
        inputs.

        Args:
          embedding_dim (int): the channel dimension of the embeddings
          num_heads (int): the number of heads in the attention layers
          mlp_dim (int): the hidden dimension of the mlp block
          activation (nn.Module): the activation of the mlp block
          skip_first_layer_pe (bool): skip the PE on the first layer
        """
        super().__init__()
        self.self_attn = Attention(embedding_dim, num_heads)
        self.norm1 = nn.LayerNorm(embedding_dim)

        self.cross_attn_token_to_image = Attention(embedding_dim, num_heads, downsample_rate=attention_downsample_rate)
        self.norm2 = nn.LayerNorm(embedding_dim)

        self.mlp = MLPBlock(embedding_dim, mlp_dim, activation)
        self.norm3 = nn.LayerNorm(embedding_dim)

        self.norm4 = nn.LayerNorm(embedding_dim)
        self.cross_attn_image_to_token = Attention(embedding_dim, num_heads, downsample_rate=attention_downsample_rate)

        self.skip_first_layer_pe = skip_first_layer_pe

    def forward(self, queries: Tensor, keys: Tensor, query_pe: Tensor, key_pe: Tensor) -> Tuple[Tensor, Tensor]:
        """Apply self-attention and cross-attention to queries and keys and return the processed embeddings."""

        # Self attention block
        if self.skip_first_layer_pe:
            queries = self.self_attn(q=queries, k=queries, v=queries)
        else:
            q = queries + query_pe
            attn_out = self.self_attn(q=q, k=q, v=queries)
            queries = queries + attn_out
        queries = self.norm1(queries)

        # Cross attention block, tokens attending to image embedding
        q = queries + query_pe
        k = keys + key_pe
        attn_out = self.cross_attn_token_to_image(q=q, k=k, v=keys)
        queries = queries + attn_out
        queries = self.norm2(queries)

        # MLP block
        mlp_out = self.mlp(queries)
        queries = queries + mlp_out
        queries = self.norm3(queries)

        # Cross attention block, image embedding attending to tokens
        q = queries + query_pe
        k = keys + key_pe
        attn_out = self.cross_attn_image_to_token(q=k, k=q, v=queries)
        keys = keys + attn_out
        keys = self.norm4(keys)

        return queries, keys

__init__(embedding_dim, num_heads, mlp_dim=2048, activation=nn.ReLU, attention_downsample_rate=2, skip_first_layer_pe=False)

चार परतों वाला एक ट्रांसफार्मर ब्लॉक: (1) विरल आदानों का आत्म-ध्यान, (2) विरल का क्रॉस ध्यान सघन आदानों के लिए इनपुट, (3) विरल आदानों पर एमएलपी ब्लॉक, और (4) विरल आदानों पर सघन आदानों का पार ध्यान जानकारी।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
embedding_dim int

एम्बेडिंग का चैनल आयाम

आवश्यक
num_heads int

ध्यान परतों में सिर की संख्या

आवश्यक
mlp_dim int

एमएलपी ब्लॉक का छिपा हुआ आयाम

2048
activation Module

एमएलपी ब्लॉक की सक्रियता

ReLU
skip_first_layer_pe bool

पहली परत पर पीई छोड़ें

False
में स्रोत कोड ultralytics/models/sam/modules/transformer.py
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158159 160161 162 163 164 165 166 167168 169
def __init__(
    self,
    embedding_dim: int,
    num_heads: int,
    mlp_dim: int = 2048,
    activation: Type[nn.Module] = nn.ReLU,
    attention_downsample_rate: int = 2,
    skip_first_layer_pe: bool = False,
) -> None:
    """
    A transformer block with four layers: (1) self-attention of sparse inputs, (2) cross attention of sparse
    inputs to dense inputs, (3) mlp block on sparse inputs, and (4) cross attention of dense inputs to sparse
    inputs.

    Args:
      embedding_dim (int): the channel dimension of the embeddings
      num_heads (int): the number of heads in the attention layers
      mlp_dim (int): the hidden dimension of the mlp block
      activation (nn.Module): the activation of the mlp block
      skip_first_layer_pe (bool): skip the PE on the first layer
    """
    super().__init__()
    self.self_attn = Attention(embedding_dim, num_heads)
    self.norm1 = nn.LayerNorm(embedding_dim)

    self.cross_attn_token_to_image = Attention(embedding_dim, num_heads, downsample_rate=attention_downsample_rate)
    self.norm2 = nn.LayerNorm(embedding_dim)

    self.mlp = MLPBlock(embedding_dim, mlp_dim, activation)
    self.norm3 = nn.LayerNorm(embedding_dim)

    self.norm4 = nn.LayerNorm(embedding_dim)
    self.cross_attn_image_to_token = Attention(embedding_dim, num_heads, downsample_rate=attention_downsample_rate)

    self.skip_first_layer_pe = skip_first_layer_pe

forward(queries, keys, query_pe, key_pe)

प्रश्नों और कुंजियों पर आत्म-ध्यान और क्रॉस-ध्यान लागू करें और संसाधित एम्बेडिंग वापस करें।

में स्रोत कोड ultralytics/models/sam/modules/transformer.py
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201202
def forward(self, queries: Tensor, keys: Tensor, query_pe: Tensor, key_pe: Tensor) -> Tuple[Tensor, Tensor]:
    """Apply self-attention and cross-attention to queries and keys and return the processed embeddings."""

    # Self attention block
    if self.skip_first_layer_pe:
        queries = self.self_attn(q=queries, k=queries, v=queries)
    else:
        q = queries + query_pe
        attn_out = self.self_attn(q=q, k=q, v=queries)
        queries = queries + attn_out
    queries = self.norm1(queries)

    # Cross attention block, tokens attending to image embedding
    q = queries + query_pe
    k = keys + key_pe
    attn_out = self.cross_attn_token_to_image(q=q, k=k, v=keys)
    queries = queries + attn_out
    queries = self.norm2(queries)

    # MLP block
    mlp_out = self.mlp(queries)
    queries = queries + mlp_out
    queries = self.norm3(queries)

    # Cross attention block, image embedding attending to tokens
    q = queries + query_pe
    k = keys + key_pe
    attn_out = self.cross_attn_image_to_token(q=k, k=q, v=queries)
    keys = keys + attn_out
    keys = self.norm4(keys)

    return queries, keys



ultralytics.models.sam.modules.transformer.Attention

का रूप: Module

एक ध्यान परत जो प्रश्नों, कुंजियों और के प्रक्षेपण के बाद एम्बेडिंग के आकार को कम करने की अनुमति देती है मान।

में स्रोत कोड ultralytics/models/sam/modules/transformer.py
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230231 232 233 234 235 236237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258259 260 261 262 263 264 265 266 267268 269 270 271 272 273 274
class Attention(nn.Module):
    """An attention layer that allows for downscaling the size of the embedding after projection to queries, keys, and
    values.
    """

    def __init__(
        self,
        embedding_dim: int,
        num_heads: int,
        downsample_rate: int = 1,
    ) -> None:
        """
        Initializes the Attention model with the given dimensions and settings.

        Args:
            embedding_dim (int): The dimensionality of the input embeddings.
            num_heads (int): The number of attention heads.
            downsample_rate (int, optional): The factor by which the internal dimensions are downsampled. Defaults to 1.

        Raises:
            AssertionError: If 'num_heads' does not evenly divide the internal dimension (embedding_dim / downsample_rate).
        """
        super().__init__()
        self.embedding_dim = embedding_dim
        self.internal_dim = embedding_dim // downsample_rate
        self.num_heads = num_heads
        assert self.internal_dim % num_heads == 0, "num_heads must divide embedding_dim."

        self.q_proj = nn.Linear(embedding_dim, self.internal_dim)
        self.k_proj = nn.Linear(embedding_dim, self.internal_dim)
        self.v_proj = nn.Linear(embedding_dim, self.internal_dim)
        self.out_proj = nn.Linear(self.internal_dim, embedding_dim)

    @staticmethod
    def _separate_heads(x: Tensor, num_heads: int) -> Tensor:
        """Separate the input tensor into the specified number of attention heads."""
        b, n, c = x.shape
        x = x.reshape(b, n, num_heads, c // num_heads)
        return x.transpose(1, 2)  # B x N_heads x N_tokens x C_per_head

    @staticmethod
    def _recombine_heads(x: Tensor) -> Tensor:
        """Recombine the separated attention heads into a single tensor."""
        b, n_heads, n_tokens, c_per_head = x.shape
        x = x.transpose(1, 2)
        return x.reshape(b, n_tokens, n_heads * c_per_head)  # B x N_tokens x C

    def forward(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor:
        """Compute the attention output given the input query, key, and value tensors."""

        # Input projections
        q = self.q_proj(q)
        k = self.k_proj(k)
        v = self.v_proj(v)

        # Separate into heads
        q = self._separate_heads(q, self.num_heads)
        k = self._separate_heads(k, self.num_heads)
        v = self._separate_heads(v, self.num_heads)

        # Attention
        _, _, _, c_per_head = q.shape
        attn = q @ k.permute(0, 1, 3, 2)  # B x N_heads x N_tokens x N_tokens
        attn = attn / math.sqrt(c_per_head)
        attn = torch.softmax(attn, dim=-1)

        # Get output
        out = attn @ v
        out = self._recombine_heads(out)
        return self.out_proj(out)

__init__(embedding_dim, num_heads, downsample_rate=1)

दिए गए आयामों और सेटिंग्स के साथ ध्यान मॉडल को इनिशियलाइज़ करता है।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
embedding_dim int

इनपुट एम्बेडिंग की आयामीता।

आवश्यक
num_heads int

ध्यान की संख्या प्रमुख।

आवश्यक
downsample_rate int

वह कारक जिसके द्वारा आंतरिक आयामों को डाउनसैंपल किया जाता है। 1 के लिए डिफ़ॉल्ट।

1

उठाती:

प्रकार विवरण: __________
AssertionError

यदि 'num_heads' आंतरिक आयाम (embedding_dim downsample_rate/

में स्रोत कोड ultralytics/models/sam/modules/transformer.py
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228229 230 231 232 233 234235236
def __init__(
    self,
    embedding_dim: int,
    num_heads: int,
    downsample_rate: int = 1,
) -> None:
    """
    Initializes the Attention model with the given dimensions and settings.

    Args:
        embedding_dim (int): The dimensionality of the input embeddings.
        num_heads (int): The number of attention heads.
        downsample_rate (int, optional): The factor by which the internal dimensions are downsampled. Defaults to 1.

    Raises:
        AssertionError: If 'num_heads' does not evenly divide the internal dimension (embedding_dim / downsample_rate).
    """
    super().__init__()
    self.embedding_dim = embedding_dim
    self.internal_dim = embedding_dim // downsample_rate
    self.num_heads = num_heads
    assert self.internal_dim % num_heads == 0, "num_heads must divide embedding_dim."

    self.q_proj = nn.Linear(embedding_dim, self.internal_dim)
    self.k_proj = nn.Linear(embedding_dim, self.internal_dim)
    self.v_proj = nn.Linear(embedding_dim, self.internal_dim)
    self.out_proj = nn.Linear(self.internal_dim, embedding_dim)

forward(q, k, v)

इनपुट क्वेरी, कुंजी और मान टेंसर को देखते हुए ध्यान आउटपुट की गणना करें।

में स्रोत कोड ultralytics/models/sam/modules/transformer.py
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268269 270 271 272273 274
def forward(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor:
    """Compute the attention output given the input query, key, and value tensors."""

    # Input projections
    q = self.q_proj(q)
    k = self.k_proj(k)
    v = self.v_proj(v)

    # Separate into heads
    q = self._separate_heads(q, self.num_heads)
    k = self._separate_heads(k, self.num_heads)
    v = self._separate_heads(v, self.num_heads)

    # Attention
    _, _, _, c_per_head = q.shape
    attn = q @ k.permute(0, 1, 3, 2)  # B x N_heads x N_tokens x N_tokens
    attn = attn / math.sqrt(c_per_head)
    attn = torch.softmax(attn, dim=-1)

    # Get output
    out = attn @ v
    out = self._recombine_heads(out)
    return self.out_proj(out)





2023-11-12 बनाया गया, अपडेट किया गया 2023-11-25
लेखक: ग्लेन-जोचर (3), लाफिंग-क्यू (1)