mcy98's picture
Upload folder using huggingface_hub
6077218 verified
Raw History Blame Contribute Delete
19.2 kB
import math
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class PositionwiseFeedForward(nn.Module):
def __init__(self, d_in, d_hid, dropout=0.1):
super().__init__()
self.w_1 = nn.Conv1d(d_in, d_hid, 1)
self.w_2 = nn.Conv1d(d_hid, d_in, 1)
self.layer_norm = nn.LayerNorm(d_in)
self.dropout = nn.Dropout(dropout)
def forward(self, x):
residual = x
output = x.transpose(1, 2)
output = self.w_2(F.relu(self.w_1(output)))
output = output.transpose(1, 2)
output = self.dropout(output)
output = self.layer_norm(output + residual)
return output
class SinusoidalPositionEmbeddings(nn.Module):
def __init__(self, dim):
super().__init__()
self.dim = dim
def forward(self, time):
device = time.device
half_dim = self.dim // 2
embeddings = math.log(10000) / (half_dim - 1)
embeddings = torch.exp(torch.arange(half_dim, device=device) * -embeddings)
embeddings = time[:, None] * embeddings[None, :]
embeddings = torch.cat((embeddings.sin(), embeddings.cos()), dim=-1)
return embeddings
class MultiHeadAttention(nn.Module):
def __init__(self, hidden_size, num_units, num_heads, dropout_rate, bidirectional=False):
super().__init__()
self.hidden_size = hidden_size
self.num_heads = num_heads
assert hidden_size % num_heads == 0
self.linear_q = nn.Linear(hidden_size, num_units)
self.linear_k = nn.Linear(hidden_size, num_units)
self.linear_v = nn.Linear(hidden_size, num_units)
self.dropout = nn.Dropout(dropout_rate)
self.softmax = nn.Softmax(dim=-1)
self.bidirectional = bidirectional
def forward(self, queries, keys):
"""
:param queries: A 3d tensor with shape of [N, T_q, C_q]
:param keys: A 3d tensor with shape of [N, T_k, C_k]
:return: A 3d tensor with shape of (N, T_q, C)
"""
Q = self.linear_q(queries) # (N, T_q, C)
K = self.linear_k(keys) # (N, T_k, C)
V = self.linear_v(keys) # (N, T_k, C)
# Split and Concat
split_size = self.hidden_size // self.num_heads
Q_ = torch.cat(torch.split(Q, split_size, dim=2), dim=0) # (h*N, T_q, C/h)
K_ = torch.cat(torch.split(K, split_size, dim=2), dim=0) # (h*N, T_k, C/h)
V_ = torch.cat(torch.split(V, split_size, dim=2), dim=0) # (h*N, T_k, C/h)
# Multiplication
matmul_output = torch.bmm(Q_, K_.transpose(1, 2)) / self.hidden_size ** 0.5 # (h*N, T_q, T_k)
# Key Masking
key_mask = torch.sign(torch.abs(keys.sum(dim=-1))).repeat(self.num_heads, 1) # (h*N, T_k)
key_mask_reshaped = key_mask.unsqueeze(1).repeat(1, queries.shape[1], 1) # (h*N, T_q, T_k)
key_paddings = torch.ones_like(matmul_output) * (-2 ** 32 + 1)
matmul_output_m1 = torch.where(torch.eq(key_mask_reshaped, 0), key_paddings, matmul_output) # (h*N, T_q, T_k)
if not self.bidirectional:
# Causality - Future Blinding
diag_vals = torch.ones_like(matmul_output[0, :, :]) # (T_q, T_k)
tril = torch.tril(diag_vals) # (T_q, T_k)
causality_mask = tril.unsqueeze(0).repeat(matmul_output.shape[0], 1, 1) # (h*N, T_q, T_k)
causality_paddings = torch.ones_like(causality_mask) * (-2 ** 32 + 1)
matmul_output_m2 = torch.where(torch.eq(causality_mask, 0), causality_paddings,
matmul_output_m1) # (h*N, T_q, T_k)
# Activation
matmul_output_sm = self.softmax(matmul_output_m2) # (h*N, T_q, T_k)
else:
matmul_output_sm = self.softmax(matmul_output_m1) # (h*N, T_q, T_k)
# Query Masking
query_mask = torch.sign(torch.abs(queries.sum(dim=-1))).repeat(self.num_heads, 1) # (h*N, T_q)
query_mask = query_mask.unsqueeze(-1).repeat(1, 1, keys.shape[1]) # (h*N, T_q, T_k)
matmul_output_qm = matmul_output_sm * query_mask
# Dropout
matmul_output_dropout = self.dropout(matmul_output_qm)
# Weighted Sum
output_ws = torch.bmm(matmul_output_dropout, V_) # ( h*N, T_q, C/h)
# Restore Shape
output = torch.cat(torch.split(output_ws, output_ws.shape[0] // self.num_heads, dim=0), dim=2) # (N, T_q, C)
# Residual Connection
output_res = output + queries
return output_res
class TransformerEncoder(nn.Module):
def __init__(self, config):
super(TransformerEncoder, self).__init__()
self.ln_1 = nn.LayerNorm(config['hidden_size'])
self.ln_2 = nn.LayerNorm(config['hidden_size'])
self.ln_3 = nn.LayerNorm(config['hidden_size'])
self.mh_attn = MultiHeadAttention(config['hidden_size'], config['hidden_size'], config['num_heads'], config['dropout'], config.get('bidirectional', False))
self.feed_forward = PositionwiseFeedForward(config['hidden_size'], config['hidden_size'], config['dropout'])
self._reset_parameters()
def _reset_parameters(self):
def init_weights(m):
if isinstance(m, nn.Linear):
nn.init.xavier_uniform_(m.weight)
if m.bias is not None:
nn.init.zeros_(m.bias)
elif isinstance(m, nn.LayerNorm):
nn.init.ones_(m.weight)
nn.init.zeros_(m.bias)
self.apply(init_weights)
def forward(self, seq, mask):
seq = seq * mask
seq_normalized = self.ln_1(seq)
mh_attn_out = self.mh_attn(seq_normalized, seq)
seq = seq + mh_attn_out # Residual connection
ff_out = self.feed_forward(self.ln_2(seq))
ff_out *= mask
seq = seq + ff_out
ff_out = self.ln_3(seq)
return ff_out
def in_batch_negative_sampling(batch_items):
B = batch_items.size(0)
expanded_items = batch_items.unsqueeze(0).repeat(B, 1)
mask = ~torch.eye(B, dtype=torch.bool, device=batch_items.device)
neg_items = expanded_items[mask].view(B, B - 1)
return neg_items
import torch
def in_batch_negative_sampling_sample(batch_items, num_neg=16):
B = batch_items.size(0)
expanded_items = batch_items.unsqueeze(0).repeat(B, 1)
mask = ~torch.eye(B, dtype=torch.bool, device=batch_items.device)
neg_items = expanded_items.masked_select(mask).view(B, B - 1)
weights = torch.ones_like(neg_items, dtype=torch.float)
sample_indices = torch.multinomial(weights, num_neg, replacement=False)
neg_sampled = neg_items.gather(1, sample_indices)
return neg_sampled
def extract_axis_1(data, indices):
"""
Extracts elements from axis 1 based on the provided indices.
"""
return torch.stack([data[i, indices[i], :] for i in range(data.shape[0])], dim=0).unsqueeze(1)
def diagonalize_and_scale(e, epsilon=1e-7):
var_e = torch.cov(e.T)
mean_e = torch.mean(e, axis=0)
eigvals, eigvecs = torch.linalg.eigh(var_e)
eigvals = eigvals + epsilon
D = torch.diag(1.0 / torch.sqrt(eigvals))
O = eigvecs
transformed_e = (e - mean_e) @ O @ D
return transformed_e
# Diffusion
import torch
def extract(a, t, x_shape):
batch_size = t.shape[0]
out = a.gather(-1, t.cpu())
return out.reshape(batch_size, *((1,) * (len(x_shape) - 1))).to(t.device)
def linear_beta_schedule(timesteps, beta_start, beta_end):
beta_start = beta_start
beta_end = beta_end
return torch.linspace(beta_start, beta_end, timesteps)
def cosine_beta_schedule(timesteps, s=0.008):
steps = timesteps + 1
x = torch.linspace(0, timesteps, steps)
alphas_cumprod = torch.cos(((x / timesteps) + s) / (1 + s) * torch.pi * 0.5) ** 2
alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
return torch.clip(betas, 0.0001, 0.9999)
def exp_beta_schedule(timesteps, beta_min=0.1, beta_max=10):
x = torch.linspace(1, 2 * timesteps + 1, timesteps)
betas = 1 - torch.exp(- beta_min / timesteps - x * 0.5 * (beta_max - beta_min) / (timesteps * timesteps))
return betas
def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.999):
"""
Create a beta schedule that discretizes the given alpha_t_bar function,
which defines the cumulative product of (1-beta) over time from t = [0,1].
:param num_diffusion_timesteps: the number of betas to produce.
:param alpha_bar: a lambda that takes an argument t from 0 to 1 and
produces the cumulative product of (1-beta) up to that
part of the diffusion process.
:param max_beta: the maximum beta to use; use values lower than 1 to
prevent singularities.
"""
betas = []
for i in range(num_diffusion_timesteps):
t1 = i / num_diffusion_timesteps
t2 = (i + 1) / num_diffusion_timesteps
betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta))
return np.array(betas)
class SinusoidalPositionEmbeddings(nn.Module):
def __init__(self, dim):
super().__init__()
self.dim = dim
def forward(self, time):
device = time.device
half_dim = self.dim // 2
embeddings = math.log(10000) / (half_dim - 1)
embeddings = torch.exp(torch.arange(half_dim, device=device) * -embeddings)
embeddings = time[:, None] * embeddings[None, :]
embeddings = torch.cat((embeddings.sin(), embeddings.cos()), dim=-1)
return embeddings
class PWLayer(nn.Module):
"""Single Parametric Whitening Layer
"""
def __init__(self, input_size, output_size, dropout=0.0):
super(PWLayer, self).__init__()
self.dropout = nn.Dropout(p=dropout)
self.bias = nn.Parameter(torch.zeros(input_size), requires_grad=True)
self.lin = nn.Linear(input_size, output_size, bias=False)
self.apply(self._init_weights)
def _init_weights(self, module):
if isinstance(module, nn.Linear):
module.weight.data.normal_(mean=0.0, std=0.02)
def forward(self, x):
return self.lin(self.dropout(x) - self.bias)
# UniSRec
class MoEAdaptorLayer(nn.Module):
"""MoE-enhanced Adaptor
"""
def __init__(self, n_exps, layers, dropout=0.0, noise=True):
super(MoEAdaptorLayer, self).__init__()
self.n_exps = n_exps
self.noisy_gating = noise
self.experts = nn.ModuleList([PWLayer(layers[0], layers[1], dropout) for i in range(n_exps)])
self.w_gate = nn.Parameter(torch.zeros(layers[0], n_exps), requires_grad=True)
self.w_noise = nn.Parameter(torch.zeros(layers[0], n_exps), requires_grad=True)
def noisy_top_k_gating(self, x, train, noise_epsilon=1e-2):
clean_logits = x @ self.w_gate
if self.noisy_gating and train:
raw_noise_stddev = x @ self.w_noise
noise_stddev = ((F.softplus(raw_noise_stddev) + noise_epsilon))
noisy_logits = clean_logits + (torch.randn_like(clean_logits).to(x.device) * noise_stddev)
logits = noisy_logits
else:
logits = clean_logits
gates = F.softmax(logits, dim=-1)
return gates
def forward(self, x):
gates = self.noisy_top_k_gating(x, self.training) # (B, n_E)
expert_outputs = [self.experts[i](x).unsqueeze(-2) for i in range(self.n_exps)] # [(B, 1, D)]
expert_outputs = torch.cat(expert_outputs, dim=-2)
multiple_outputs = gates.unsqueeze(-1) * expert_outputs
return multiple_outputs.sum(dim=-2)
class PLMEmb:
def __init__(self, config, plm_embeddings):
self.item_drop_ratio = config['item_drop_ratio']
self.plm_embeddings = plm_embeddings
def __call__(self, interaction):
'''Sequence augmentation and PLM embedding fetching
'''
item_seq_len = interaction['item_length']
item_seq = interaction['item_id_list']
item_emb_seq = self.plm_embeddings[item_seq]
pos_item_id = interaction['item_id']
pos_item_emb = self.plm_embeddings[pos_item_id]
mask_p = torch.full_like(item_seq, 1 - self.item_drop_ratio, dtype=torch.float)
mask = torch.bernoulli(mask_p).to(torch.bool)
# Augmentation
seq_mask = item_seq.eq(0).to(torch.bool)
mask = torch.logical_or(mask, seq_mask)
mask[:, 0] = True
drop_index = torch.cumsum(mask, dim=1) - 1
item_seq_aug = torch.zeros_like(item_seq).scatter(dim=-1, index=drop_index, src=item_seq)
item_seq_len_aug = torch.gather(drop_index, 1, (item_seq_len - 1).unsqueeze(1)).squeeze() + 1
item_emb_seq_aug = self.plm_embeddings[item_seq_aug]
interaction.update({
'item_emb_list': item_emb_seq,
'pos_item_emb': pos_item_emb,
'item_id_list_aug': item_seq_aug,
'item_length_aug': item_seq_len_aug,
'item_emb_list_aug': item_emb_seq_aug,
})
return interaction
class PointwiseAggregatedAttention(nn.Module):
def __init__(self, d_model, num_heads):
super().__init__()
self.num_heads = num_heads
self.head_dim = d_model // num_heads
# TODO: add relative attention bias based on time
self.rab_p = RelativeAttentionBias(num_heads, relative_attention_num_buckets=32,
relative_attention_max_distance=128)
def split_heads(self, x, batch_size):
x = x.view(batch_size, -1, self.num_heads, self.head_dim)
return x.permute(0, 2, 1, 3)
def forward(self, v, k, q, mask=None):
batch_size = q.shape[0]
q = self.split_heads(q, batch_size)
k = self.split_heads(k, batch_size)
v = self.split_heads(v, batch_size)
attention_scores = torch.matmul(q, k.transpose(-2, -1))
# attention_scores=torch.matmul(q, k.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32))
rab = self.rab_p(q.shape[2], k.shape[2], device=q.device)
att_w_bias = attention_scores + rab
av = (F.silu(att_w_bias) @ v)
return av.transpose(1, 2).flatten(2)
class RelativeAttentionBias(nn.Module):
def __init__(self, num_heads, relative_attention_num_buckets, relative_attention_max_distance=128):
super().__init__()
self.relative_attention_num_buckets = relative_attention_num_buckets
self.relative_attention_max_distance = relative_attention_max_distance
self.relative_attention_bias = nn.Embedding(relative_attention_num_buckets, num_heads)
def forward(self, query_length, key_length, device=None):
"""Compute binned relative position bias"""
if device is None:
device = self.relative_attention_bias.weight.device
context_position = torch.arange(query_length, dtype=torch.long, device=device)[:, None]
memory_position = torch.arange(key_length, dtype=torch.long, device=device)[None, :]
relative_position = memory_position - context_position # shape (query_length, key_length)
relative_position_bucket = self._relative_position_bucket(
relative_position, # shape (query_length, key_length)
bidirectional=False,
num_buckets=self.relative_attention_num_buckets,
max_distance=self.relative_attention_max_distance,
)
values = self.relative_attention_bias(relative_position_bucket) # shape (query_length, key_length, num_heads)
values = values.permute([2, 0, 1]).unsqueeze(0) # shape (1, num_heads, query_length, key_length)
return values
# https://github.com/huggingface/transformers/blob/6cdbd73e01a9719bfaec07d91fd108e8d932bbbb/src/transformers/models/t5/modeling_t5.py#L384
@staticmethod
def _relative_position_bucket(relative_position, bidirectional=True, num_buckets=32, max_distance=128):
"""
Adapted from Mesh Tensorflow:
https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593
Translate relative position to a bucket number for relative attention. The relative position is defined as
memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to
position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for
small absolute relative_position and larger buckets for larger absolute relative_positions. All relative
positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket.
This should allow for more graceful generalization to longer sequences than the model has been trained on
Args:
relative_position: an int32 Tensor
bidirectional: a boolean - whether the attention is bidirectional
num_buckets: an integer
max_distance: an integer
Returns:
a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets)
"""
relative_buckets = 0
if bidirectional:
num_buckets //= 2
relative_buckets += (relative_position > 0).to(torch.long) * num_buckets
relative_position = torch.abs(relative_position)
else:
relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
# now relative_position is in the range [0, inf)
# half of the buckets are for exact increments in positions
max_exact = num_buckets // 2
is_small = relative_position < max_exact
# The other half of the buckets are for logarithmically bigger bins in positions up to max_distance
relative_position_if_large = max_exact + (
torch.log(relative_position.float() / max_exact)
/ math.log(max_distance / max_exact)
* (num_buckets - max_exact)
).to(torch.long)
relative_position_if_large = torch.min(
relative_position_if_large, torch.full_like(relative_position_if_large, num_buckets - 1)
)
relative_buckets += torch.where(is_small, relative_position, relative_position_if_large)
return relative_buckets
class HSTUBlock(nn.Module):
def __init__(self, d_model, num_heads, dropout=0.1):
super().__init__()
self.f1 = nn.Linear(d_model, d_model * 4) # Transform and split
self.pointwise_attn = PointwiseAggregatedAttention(d_model, num_heads)
self.f2 = nn.Linear(d_model, d_model)
self.norm = nn.LayerNorm(d_model)
def split(self, x):
u, v, q, k = x.chunk(4, dim=-1)
return u, v, q, k
def forward(self, x):
# Pointwise Projection
x_proj = F.silu(self.f1(x))
u, v, q, k = self.split(x_proj)
# Spatial Aggregation
av = self.pointwise_attn(v, k, q)
# Pointwise Transformation
y = self.f2(self.norm(av * u))
return y