text stringlengths 0 4.99k |
|---|
embed_dim = 64 # Embedding dimension |
num_mlp = 256 # MLP layer size |
qkv_bias = True # Convert embedded patches to query, key, and values with a learnable additive value |
window_size = 2 # Size of attention window |
shift_size = 1 # Size of shifting window |
image_dimension = 32 # Initial image size |
num_patch_x = input_shape[0] // patch_size[0] |
num_patch_y = input_shape[1] // patch_size[1] |
learning_rate = 1e-3 |
batch_size = 128 |
num_epochs = 40 |
validation_split = 0.1 |
weight_decay = 0.0001 |
label_smoothing = 0.1 |
Helper functions |
We create two helper functions to help us get a sequence of patches from the image, merge patches, and apply dropout. |
def window_partition(x, window_size): |
_, height, width, channels = x.shape |
patch_num_y = height // window_size |
patch_num_x = width // window_size |
x = tf.reshape( |
x, shape=(-1, patch_num_y, window_size, patch_num_x, window_size, channels) |
) |
x = tf.transpose(x, (0, 1, 3, 2, 4, 5)) |
windows = tf.reshape(x, shape=(-1, window_size, window_size, channels)) |
return windows |
def window_reverse(windows, window_size, height, width, channels): |
patch_num_y = height // window_size |
patch_num_x = width // window_size |
x = tf.reshape( |
windows, |
shape=(-1, patch_num_y, patch_num_x, window_size, window_size, channels), |
) |
x = tf.transpose(x, perm=(0, 1, 3, 2, 4, 5)) |
x = tf.reshape(x, shape=(-1, height, width, channels)) |
return x |
class DropPath(layers.Layer): |
def __init__(self, drop_prob=None, **kwargs): |
super(DropPath, self).__init__(**kwargs) |
self.drop_prob = drop_prob |
def call(self, x): |
input_shape = tf.shape(x) |
batch_size = input_shape[0] |
rank = x.shape.rank |
shape = (batch_size,) + (1,) * (rank - 1) |
random_tensor = (1 - self.drop_prob) + tf.random.uniform(shape, dtype=x.dtype) |
path_mask = tf.floor(random_tensor) |
output = tf.math.divide(x, 1 - self.drop_prob) * path_mask |
return output |
Window based multi-head self-attention |
Usually Transformers perform global self-attention, where the relationships between a token and all other tokens are computed. The global computation leads to quadratic complexity with respect to the number of tokens. Here, as the original paper suggests, we compute self-attention within local windows, in a non-overlap... |
class WindowAttention(layers.Layer): |
def __init__( |
self, dim, window_size, num_heads, qkv_bias=True, dropout_rate=0.0, **kwargs |
): |
super(WindowAttention, self).__init__(**kwargs) |
self.dim = dim |
self.window_size = window_size |
self.num_heads = num_heads |
self.scale = (dim // num_heads) ** -0.5 |
self.qkv = layers.Dense(dim * 3, use_bias=qkv_bias) |
self.dropout = layers.Dropout(dropout_rate) |
self.proj = layers.Dense(dim) |
def build(self, input_shape): |
num_window_elements = (2 * self.window_size[0] - 1) * ( |
2 * self.window_size[1] - 1 |
) |
self.relative_position_bias_table = self.add_weight( |
shape=(num_window_elements, self.num_heads), |
initializer=tf.initializers.Zeros(), |
trainable=True, |
) |
coords_h = np.arange(self.window_size[0]) |
coords_w = np.arange(self.window_size[1]) |
coords_matrix = np.meshgrid(coords_h, coords_w, indexing=\"ij\") |
coords = np.stack(coords_matrix) |
coords_flatten = coords.reshape(2, -1) |
relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] |
relative_coords = relative_coords.transpose([1, 2, 0]) |
relative_coords[:, :, 0] += self.window_size[0] - 1 |
relative_coords[:, :, 1] += self.window_size[1] - 1 |
relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1 |
relative_position_index = relative_coords.sum(-1) |
self.relative_position_index = tf.Variable( |
initial_value=tf.convert_to_tensor(relative_position_index), trainable=False |
) |
def call(self, x, mask=None): |
_, size, channels = x.shape |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.