# coding=utf-8
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
New VGCN-BERT model
Paper: https://arxiv.org/abs/2004.05707
"""
from collections import Counter
import math
from typing import Dict, List, Optional, Set, Tuple, Union
import scipy.sparse as sp
import numpy as np
import torch
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
from transformers.configuration_utils import PretrainedConfig
from transformers.activations import get_activation
from transformers.deepspeed import is_deepspeed_zero3_enabled
from transformers.modeling_outputs import (
BaseModelOutput,
MaskedLMOutput,
MultipleChoiceModelOutput,
QuestionAnsweringModelOutput,
SequenceClassifierOutput,
TokenClassifierOutput,
)
from transformers.modeling_utils import PreTrainedModel
from transformers.tokenization_utils import PreTrainedTokenizerBase
from transformers.pytorch_utils import apply_chunking_to_forward, find_pruneable_heads_and_indices, prune_linear_layer
from transformers.utils import (
add_code_sample_docstrings,
add_start_docstrings,
add_start_docstrings_to_model_forward,
logging,
replace_return_docstrings,
)
from .configuration_vgcn_bert import VGCNBertConfig
logger = logging.get_logger(__name__)
_CHECKPOINT_FOR_DOC = "zhibinlu/vgcn-bert-distilbert-base-uncased"
_CONFIG_FOR_DOC = "VGCNBertConfig"
VGCNBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [
"zhibinlu/vgcn-bert-distilbert-base-uncased",
# See all VGCN-BERT models at https://huggingface.co/models?filter=vgcn-bert
]
# Word Graph construction utils #
ENGLISH_STOP_WORDS = frozenset(
{
"herself",
"each",
"him",
"been",
"only",
"yourselves",
"into",
"where",
"them",
"very",
"we",
"that",
"re",
"too",
"some",
"what",
"those",
"me",
"whom",
"have",
"yours",
"an",
"during",
"any",
"nor",
"ourselves",
"has",
"do",
"when",
"about",
"same",
"our",
"then",
"himself",
"their",
"all",
"no",
"a",
"hers",
"off",
"why",
"how",
"more",
"between",
"until",
"not",
"over",
"your",
"by",
"here",
"most",
"above",
"up",
"of",
"is",
"after",
"from",
"being",
"i",
"as",
"other",
"so",
"her",
"ours",
"on",
"because",
"against",
"and",
"out",
"had",
"these",
"at",
"both",
"down",
"you",
"can",
"she",
"few",
"the",
"if",
"it",
"to",
"but",
"its",
"be",
"he",
"once",
"further",
"such",
"there",
"through",
"are",
"themselves",
"which",
"in",
"now",
"his",
"yourself",
"this",
"were",
"below",
"should",
"my",
"myself",
"am",
"or",
"while",
"itself",
"again",
"with",
"they",
"will",
"own",
"than",
"before",
"under",
"was",
"for",
"who",
}
)
def _normalize_adj(adj):
"""Symmetrically normalize adjacency matrix."""
rowsum = np.array(adj.sum(1)) # D-degree matrix
d_inv_sqrt = np.power(rowsum, -0.5).flatten()
d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0.0
d_mat_inv_sqrt = sp.diags(d_inv_sqrt)
return adj.dot(d_mat_inv_sqrt).transpose().dot(d_mat_inv_sqrt)
def _scipy_to_torch(sparse):
sparse = sparse.tocoo() if sparse.getformat() != "coo" else sparse
i = torch.LongTensor(np.vstack((sparse.row, sparse.col)))
v = torch.from_numpy(sparse.data)
return torch.sparse_coo_tensor(i, v, torch.Size(sparse.shape)).coalesce()
def _delete_special_terms(words: list, terms: set):
return set([w for w in words if w not in terms])
def _build_pmi_graph(
texts: List[str],
tokenizer: PreTrainedTokenizerBase,
window_size=20,
algorithm="npmi",
edge_threshold=0.0,
remove_stopwords=False,
min_freq_to_keep=2,
) -> Tuple[sp.csr_matrix, Dict[str, int], Dict[int, int]]:
"""
Build statistical word graph from text samples using PMI or NPMI algorithm.
"""
# Tokenize the text samples. The tokenizer should be same as that in the combined Bert-like model.
# Remove stopwords and special terms
# Get vocabulary and the word frequency
words_to_remove = (
set({"[CLS]", "[SEP]"}).union(ENGLISH_STOP_WORDS) if remove_stopwords else set({"[CLS]", "[SEP]"})
)
vocab_counter = Counter()
texts_words = []
for t in texts:
words = tokenizer.tokenize(t)
words = _delete_special_terms(words, words_to_remove)
if len(words) > 0:
vocab_counter.update(Counter(words))
texts_words.append(words)
# Set [PAD] as the head of vocabulary
# Remove word with freq<n and re generate texts
new_vocab_counter = Counter({"[PAD]": 0})
new_vocab_counter.update(
Counter({k: v for k, v in vocab_counter.items() if v >= min_freq_to_keep})
if min_freq_to_keep > 1
else vocab_counter
)
vocab_counter = new_vocab_counter
# Generate new texts by removing words with freq<n
if min_freq_to_keep > 1:
texts_words = [list(filter(lambda w: vocab_counter[w] >= min_freq_to_keep, words)) for words in texts_words]
texts = [" ".join(words).strip() for words in texts_words if len(words) > 0]
vocab_size = len(vocab_counter)
vocab = list(vocab_counter.keys())
assert vocab[0] == "[PAD]"
vocab_indices = {k: i for i, k in enumerate(vocab)}
# Get the pieces from sliding windows
windows = []
for t in texts:
words = t.split()
word_ids = [vocab_indices[w] for w in words]
length = len(word_ids)
if length <= window_size:
windows.append(word_ids)
else:
for j in range(length - window_size + 1):
word_ids = word_ids[j : j + window_size]
windows.append(word_ids)
# Get the window-count that every word appeared (count 1 for the same window).
# Get window-count that every word-pair appeared (count 1 for the same window).
vocab_window_counter = Counter()
word_pair_window_counter = Counter()
for word_ids in windows:
word_ids = list(set(word_ids))
vocab_window_counter.update(Counter(word_ids))
word_pair_window_counter.update(
Counter(
[
f(i, j)
# (word_ids[i], word_ids[j])
for i in range(1, len(word_ids))
for j in range(i)
# adding inverse pair
for f in (lambda x, y: (word_ids[x], word_ids[y]), lambda x, y: (word_ids[y], word_ids[x]))
]
)
)
# Calculate NPMI
vocab_adj_row = []
vocab_adj_col = []
vocab_adj_weight = []
total_windows = len(windows)
for wid_pair in word_pair_window_counter.keys():
i, j = wid_pair
pair_count = word_pair_window_counter[wid_pair]
i_count = vocab_window_counter[i]
j_count = vocab_window_counter[j]
value = (
(log(1.0 * i_count * j_count / (total_windows**2)) / log(1.0 * pair_count / total_windows) - 1)
if algorithm == "npmi"
else (log((1.0 * pair_count / total_windows) / (1.0 * i_count * j_count / (total_windows**2))))
)
if value > edge_threshold:
vocab_adj_row.append(i)
vocab_adj_col.append(j)
vocab_adj_weight.append(value)
# Build vocabulary adjacency matrix
vocab_adj = sp.csr_matrix(
(vocab_adj_weight, (vocab_adj_row, vocab_adj_col)),
shape=(vocab_size, vocab_size),
dtype=np.float32,
)
vocab_adj.setdiag(1.0)
# Padding the first row and column, "[PAD]" is the first word in the vocabulary.
assert vocab_adj[0, :].sum() == 1
assert vocab_adj[:, 0].sum() == 1
vocab_adj[:, 0] = 0
vocab_adj[0, :] = 0
wgraph_id_to_tokenizer_id_map = {v: tokenizer.vocab[k] for k, v in vocab_indices.items()}
wgraph_id_to_tokenizer_id_map = dict(sorted(wgraph_id_to_tokenizer_id_map.items()))
return (
vocab_adj,
vocab_indices,
wgraph_id_to_tokenizer_id_map,
)
def _build_predefined_graph(
words_relations: List[Tuple[str, str, float]], tokenizer: PreTrainedTokenizerBase, remove_stopwords: bool = False
) -> Tuple[sp.csr_matrix, Dict[str, int], Dict[int, int]]:
"""
Build pre-defined wgraph from a list of word pairs and their pre-defined relations (edge value).
"""
# Tokenize the text samples. The tokenizer should be same as that in the combined Bert-like model.
# Remove stopwords and special terms
# Get vocabulary and the word frequency
words_to_remove = (
set({"[CLS]", "[SEP]"}).union(ENGLISH_STOP_WORDS) if remove_stopwords else set({"[CLS]", "[SEP]"})
)
vocab_counter = Counter({"[PAD]": 0})
word_pairs = {}
for w1, w2, v in words_relations:
w1_subwords = tokenizer.tokenize(w1)
w1_subwords = _delete_special_terms(w1_subwords, words_to_remove)
w2_subwords = tokenizer.tokenize(w2)
w2_subwords = _delete_special_terms(w2_subwords, words_to_remove)
vocab_counter.update(Counter(w1_subwords))
vocab_counter.update(Counter(w2_subwords))
for sw1 in w1_subwords:
for sw2 in w2_subwords:
if sw1 != sw2:
word_pairs.setdefault((sw1, sw2), v)
vocab_size = len(vocab_counter)
vocab = list(vocab_counter.keys())
assert vocab[0] == "[PAD]"
vocab_indices = {k: i for i, k in enumerate(vocab)}
# bulid adjacency matrix
vocab_adj_row = []
vocab_adj_col = []
vocab_adj_weight = []
for (w1, w2), v in word_pairs.items():
vocab_adj_row.append(vocab_indices[w1])
vocab_adj_col.append(vocab_indices[w2])
vocab_adj_weight.append(v)
# adding inverse
vocab_adj_row.append(vocab_indices[w2])
vocab_adj_col.append(vocab_indices[w1])
vocab_adj_weight.append(v)
# Build vocabulary adjacency matrix
vocab_adj = sp.csr_matrix(
(vocab_adj_weight, (vocab_adj_row, vocab_adj_col)),
shape=(vocab_size, vocab_size),
dtype=np.float32,
)
vocab_adj.setdiag(1.0)
# Padding the first row and column, "[PAD]" is the first word in the vocabulary.
assert vocab_adj[0, :].sum() == 1
assert vocab_adj[:, 0].sum() == 1
vocab_adj[:, 0] = 0
vocab_adj[0, :] = 0
wgraph_id_to_tokenizer_id_map = {v: tokenizer.vocab[k] for k, v in vocab_indices.items()}
wgraph_id_to_tokenizer_id_map = dict(sorted(wgraph_id_to_tokenizer_id_map.items()))
return (
vocab_adj,
vocab_indices,
wgraph_id_to_tokenizer_id_map,
)
# TODO: build knowledge graph from a list of RDF triples
class WordGraphBuilder:
"""
Word graph based on adjacency matrix, construct from text samples or pre-defined word-pair relations
You may (or not) first preprocess the text before build the graph,
e.g. Stopword removal, String cleaning, Stemming, Nomolization, Lemmatization
Params:
`rows`: List[str] of text samples, or pre-defined word-pair relations: List[Tuple[str, str, float]]
`tokenizer`: The same pretrained tokenizer that is used for the model late.
`window_size`: Available only for statistics generation (rows is text samples).
Size of the sliding window for collecting the pieces of text
and further calculate the NPMI value, default is 20.
`algorithm`: Available only for statistics generation (rows is text samples) -- "npmi" or "pmi", default is "npmi".
`edge_threshold`: Available only for statistics generation (rows is text samples). Graph edge value threshold, default is 0. Edge value is between -1 to 1.
`remove_stopwords`: Build word graph with the words that are not stopwords, default is False.
`min_freq_to_keep`: Available only for statistics generation (rows is text samples). Build word graph with the words that occurred at least n times in the corpus, default is 2.
Properties:
`adjacency_matrix`: scipy.sparse.csr_matrix, the word graph in sparse adjacency matrix form.
`vocab_indices`: indices of word graph vocabulary words.
`wgraph_id_to_tokenizer_id_map`: map from word graph vocabulary word id to tokenizer vocabulary word id.
"""
def __init__(self):
super().__init__()
def __call__(
self,
rows: list,
tokenizer: PreTrainedTokenizerBase,
window_size=20,
algorithm="npmi",
edge_threshold=0.0,
remove_stopwords=False,
min_freq_to_keep=2,
):
if type(rows[0]) == tuple:
(
adjacency_matrix,
_,
wgraph_id_to_tokenizer_id_map,
) = _build_predefined_graph(rows, tokenizer, remove_stopwords)
else:
(
adjacency_matrix,
_,
wgraph_id_to_tokenizer_id_map,
) = _build_pmi_graph(
rows, tokenizer, window_size, algorithm, edge_threshold, remove_stopwords, min_freq_to_keep
)
adjacency_matrix=_scipy_to_torch(_normalize_adj(adjacency_matrix)) if adjacency_matrix is not None else None
return adjacency_matrix, wgraph_id_to_tokenizer_id_map
class VgcnParameterList(nn.ParameterList):
def __init__(self, values=None, requires_grad=True) -> None:
super().__init__(values)
self.requires_grad = requires_grad
def _load_from_state_dict(
self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
):
keys = filter(lambda x: x.startswith(prefix), state_dict.keys())
for k in keys:
self.append(nn.Parameter(state_dict[k], requires_grad=self.requires_grad))
super()._load_from_state_dict(
state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
)
for i in range(len(self)):
if self[i].layout is torch.sparse_coo and not self[i].is_coalesced():
self[i] = self[i].coalesce()
self[i].requires_grad = self.requires_grad
class VocabGraphConvolution(nn.Module):
"""Vocabulary GCN module.
Params:
`wgraphs`: List of vocabulary graph, normally adjacency matrix
`wgraph_id_to_tokenizer_id_maps`: wgraph.vocabulary to tokenizer.vocabulary id-mapping
`hid_dim`: The hidden dimension after `GCN=XAW` (GCN layer)
`out_dim`: The output dimension after `out=Relu(XAW)W` (GCN output)
`activation`: The activation function in `out=act(XAW)W`
`dropout_rate`: The dropout probabilitiy in `out=dropout(act(XAW))W`.
Inputs:
`X_dv`: the feature of mini batch document, can be TF-IDF (batch, vocab), or word embedding (batch, word_embedding_dim, vocab)
Outputs:
The graph embedding representation, dimension (batch, `out_dim`) or (batch, word_embedding_dim, `out_dim`)
"""
def __init__(
self,
hid_dim: int,
out_dim: int,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
activation=None,
dropout_rate=0.1,
):
super().__init__()
self.hid_dim = hid_dim
self.out_dim = out_dim
self.fc_hg = nn.Linear(hid_dim, out_dim)
self.fc_hg._is_vgcn_linear = True
self.activation = get_activation(activation) if activation else None
self.dropout = nn.Dropout(dropout_rate) if dropout_rate > 0 else None
# TODO: add a Linear layer for vgcn fintune/pretrain task
# after init.set_wgraphs, _init_weights will set again the mode (transparent,normal,uniform)
# but if load wgraph parameters from checkpoint/pretrain, the mode weights will be updated from to checkpoint
# you can call again set_parameters to change the mode
self.set_wgraphs(wgraphs, wgraph_id_to_tokenizer_id_maps)
def set_parameters(self, mode="transparent"):
"""Set the parameters of the model (transparent, uniform, normal)."""
assert mode in ["transparent", "uniform", "normal"]
for n, p in self.named_parameters():
if n.startswith("W"):
nn.init.constant_(p, 1.0) if mode == "transparent" else nn.init.normal_(
p, mean=0.0, std=0.02
) if mode == "normal" else nn.init.kaiming_uniform_(p, a=math.sqrt(5))
self.fc_hg.weight.data.fill_(1.0) if mode == "transparent" else self.fc_hg.weight.data.normal_(
mean=0.0, std=0.02
) if mode == "normal" else nn.init.kaiming_uniform_(self.fc_hg.weight, a=math.sqrt(5))
self.fc_hg.bias.data.zero_()
def set_wgraphs(
self,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
mode="transparent",
):
assert (
wgraphs is None
and wgraph_id_to_tokenizer_id_maps is None
or wgraphs is not None
and wgraph_id_to_tokenizer_id_maps is not None
)
self.wgraphs: VgcnParameterList = (
self._prepare_wgraphs(wgraphs) if wgraphs else VgcnParameterList(requires_grad=False)
)
self.gvoc_ordered_tokenizer_id_arrays, self.tokenizer_id_to_wgraph_id_arrays = VgcnParameterList(
requires_grad=False
), VgcnParameterList(requires_grad=False)
if wgraph_id_to_tokenizer_id_maps:
(
self.gvoc_ordered_tokenizer_id_arrays,
self.tokenizer_id_to_wgraph_id_arrays,
) = self._prepare_inverted_arrays(wgraph_id_to_tokenizer_id_maps)
self.W_vh_list = VgcnParameterList(requires_grad=True)
self.W_vh_list._is_vgcn_weights = True
for g in self.wgraphs:
self.W_vh_list.append(nn.Parameter(torch.randn(g.shape[0], self.hid_dim)))
# self.W_vh_list.append(nn.Parameter(torch.ones(g.shape[0], self.hid_dim)))
self.set_parameters(mode=mode)
def _prepare_wgraphs(self, wgraphs: list) -> VgcnParameterList:
# def _zero_padding_graph(adj_matrix: torch.Tensor):
# if adj_matrix.layout is not torch.sparse_coo:
# adj_matrix=adj_matrix.to_sparse_coo()
# indices=adj_matrix.indices()+1
# padded_adj= torch.sparse_coo_tensor(indices=indices, values=adj_matrix.values(), size=(adj_matrix.shape[0]+1,adj_matrix.shape[1]+1))
# return padded_adj.coalesce()
glist = VgcnParameterList(requires_grad=False)
for g in wgraphs:
assert g.layout is torch.sparse_coo
# g[0,:] and g[:,0] should be 0
assert 0 not in g.indices()
glist.append(nn.Parameter(g.coalesce(), requires_grad=False))
return glist
def _prepare_inverted_arrays(self, wgraph_id_to_tokenizer_id_maps: List[dict]):
wgraph_id_to_tokenizer_id_maps = [dict(sorted(m.items())) for m in wgraph_id_to_tokenizer_id_maps]
assert all([list(m.keys())[-1] == len(m) - 1 for m in wgraph_id_to_tokenizer_id_maps])
gvoc_ordered_tokenizer_id_arrays = VgcnParameterList(
[
nn.Parameter(torch.LongTensor(list(m.values())), requires_grad=False)
for m in wgraph_id_to_tokenizer_id_maps
],
requires_grad=False,
)
tokenizer_id_to_wgraph_id_arrays = VgcnParameterList(
[
nn.Parameter(torch.zeros(max(m.values()) + 1, dtype=torch.long), requires_grad=False)
for m in wgraph_id_to_tokenizer_id_maps
],
requires_grad=False,
)
for m, t in zip(wgraph_id_to_tokenizer_id_maps, tokenizer_id_to_wgraph_id_arrays):
for graph_id, tok_id in m.items():
t[tok_id] = graph_id
return gvoc_ordered_tokenizer_id_arrays, tokenizer_id_to_wgraph_id_arrays
def get_subgraphs(self, adj_matrix: torch.Tensor, gx_ids: torch.LongTensor):
device = gx_ids.device
batch_size = gx_ids.shape[0]
batch_masks = torch.any(
torch.any(
(adj_matrix.indices().view(-1) == gx_ids.unsqueeze(-1)).view(batch_size, gx_ids.shape[1], 2, -1), dim=1
),
dim=1,
)
nnz_len = len(adj_matrix.values())
batch_values = adj_matrix.values().unsqueeze(0).repeat(batch_size, 1)
batch_values = batch_values.view(-1)[batch_masks.view(-1)]
batch_positions = torch.arange(batch_size, device=device).unsqueeze(1).repeat(1, nnz_len)
indices = torch.cat([batch_positions.view(1, -1), adj_matrix.indices().repeat(1, batch_size)], dim=0)
indices = indices[batch_masks.view(-1).expand(3, -1)].view(3, -1)
batch_sub_adj_matrix = torch.sparse_coo_tensor(
indices=indices,
values=batch_values.view(-1),
size=(batch_size, adj_matrix.size(0), adj_matrix.size(1)),
dtype=adj_matrix.dtype,
device=device,
)
return batch_sub_adj_matrix.coalesce()
def forward(self, word_embeddings: nn.Embedding, input_ids: torch.Tensor): # , position_ids: torch.Tensor = None):
if not self.wgraphs:
raise ValueError(
"No wgraphs is provided. There are 3 ways to initalize wgraphs:"
" instantiate VGCN_BERT with wgraphs, or call model.vgcn_bert.set_wgraphs(),"
" or load from_pretrained/checkpoint (make sure there is wgraphs in checkpoint"
" or you should call set_wgraphs)."
)
device = input_ids.device
batch_size = input_ids.shape[0]
word_emb_dim = word_embeddings.weight.shape[1]
gx_ids_list = []
# positon_embeddings_in_gvocab_order_list=[]
for m in self.tokenizer_id_to_wgraph_id_arrays:
# tmp_ids is still in sentence order, but value is graph id, e.g. [0, 5, 2, 2, 0, 10,0]
# 0 means no correspond graph id (like padding in graph), so we need to replace it with 0
tmp_ids = input_ids.clone()
tmp_ids[tmp_ids > len(m) - 1] = 0
tmp_ids = m[tmp_ids]
# # position in graph is meaningless and computationally expensive
# if position_ids:
# position_ids_in_g=torch.zeros(g.shape[0], dtype=torch.LongTensor)
# # maybe gcn_swop_eye in original vgcn_bert preprocess is more efficient?
# for p_id, g_id in zip(position_ids, tmp_ids):
# position_ids_in_g[g_id]=p_id
# position_embeddings_in_g=self.position_embeddings(position_ids_in_g)
# position_embeddings_in_g*=position_ids_in_g>0
# positon_embeddings_in_gvocab_order_list.append(position_embeddings_in_g)
gx_ids_list.append(torch.unique(tmp_ids, dim=1))
# G_embedding=(act(V1*A1_sub*W1_vh)+act(V2*A2_sub*W2_vh)）*W_hg
fused_H = torch.zeros((batch_size, word_emb_dim, self.hid_dim), device=device)
for gv_ids, g, gx_ids, W_vh in zip( # , position_in_gvocab_ev
self.gvoc_ordered_tokenizer_id_arrays,
self.wgraphs,
gx_ids_list,
self.W_vh_list,
# positon_embeddings_in_gvocab_order_list,
):
# batch_A1_sub*W1_vh, batch_A2_sub*W2_vh, ...
sub_wgraphs = self.get_subgraphs(g, gx_ids)
H_vh = torch.bmm(sub_wgraphs, W_vh.unsqueeze(0).expand(batch_size, *W_vh.shape))
# V1*batch_A1_sub*W1_vh, V2*batch_A2_sub*W2_vh, ...
gvocab_ev = word_embeddings(gv_ids).t()
# if position_ids:
# gvocab_ev += position_in_gvocab_ev
H_eh = gvocab_ev.matmul(H_vh)
# fc -> act -> dropout
if self.activation:
H_eh = self.activation(H_eh)
if self.dropout:
H_eh = self.dropout(H_eh)
fused_H += H_eh
# fused_H=LayerNorm(fused_H) # embedding assemble layer will do LayerNorm
out_ge = self.fc_hg(fused_H).transpose(1, 2)
# self.dropout(out_ge) # embedding assemble layer will do dropout
return out_ge
# UTILS AND BUILDING BLOCKS OF THE ARCHITECTURE #
def create_sinusoidal_embeddings(n_pos: int, dim: int, out: torch.Tensor):
if is_deepspeed_zero3_enabled():
import deepspeed
with deepspeed.zero.GatheredParameters(out, modifier_rank=0):
if torch.distributed.get_rank() == 0:
_create_sinusoidal_embeddings(n_pos=n_pos, dim=dim, out=out)
else:
_create_sinusoidal_embeddings(n_pos=n_pos, dim=dim, out=out)
def _create_sinusoidal_embeddings(n_pos: int, dim: int, out: torch.Tensor):
position_enc = np.array([[pos / np.power(10000, 2 * (j // 2) / dim) for j in range(dim)] for pos in range(n_pos)])
out.requires_grad = False
out[:, 0::2] = torch.FloatTensor(np.sin(position_enc[:, 0::2]))
out[:, 1::2] = torch.FloatTensor(np.cos(position_enc[:, 1::2]))
out.detach_()
class VGCNEmbeddings(nn.Module):
"""Construct the embeddings from word, VGCN graph, position and token_type embeddings."""
def __init__(
self,
config: PretrainedConfig,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
):
super().__init__()
self.word_embeddings = nn.Embedding(config.vocab_size, config.dim, padding_idx=config.pad_token_id)
self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.dim)
self.vgcn_graph_embds_dim = config.vgcn_graph_embds_dim
self.vgcn = VocabGraphConvolution(
hid_dim=config.vgcn_hidden_dim,
out_dim=config.vgcn_graph_embds_dim,
wgraphs=wgraphs,
wgraph_id_to_tokenizer_id_maps=wgraph_id_to_tokenizer_id_maps,
activation=config.vgcn_activation,
dropout_rate=config.vgcn_dropout,
)
if config.sinusoidal_pos_embds:
create_sinusoidal_embeddings(
n_pos=config.max_position_embeddings, dim=config.dim, out=self.position_embeddings.weight
)
self.LayerNorm = nn.LayerNorm(config.dim, eps=1e-12)
self.dropout = nn.Dropout(config.dropout)
self.register_buffer(
"position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)), persistent=False
)
def forward(self, input_ids: torch.Tensor, input_embeds: Optional[torch.Tensor] = None) -> torch.Tensor:
"""
Parameters:
input_ids (torch.Tensor):
torch.tensor(bs, max_seq_length) The token ids to embed.
input_ids is mandatory in vgcn-bert.
Returns: torch.tensor(bs, max_seq_length, dim) The embedded tokens (plus position embeddings, no token_type
embeddings)
"""
# input_ids is mandatory in vgcn-bert
input_embeds = self.word_embeddings(input_ids) # (bs, max_seq_length, dim)
# device = input_embeds.device
# input_lengths = (
# (input_ids > 0).sum(-1)
# if input_ids is not None
# else torch.ones(input_embeds.size(0), device=device, dtype=torch.int64) * input_embeds.size(1)
# )
seq_length = input_embeds.size(1)
# Setting the position-ids to the registered buffer in constructor, it helps
# when tracing the model without passing position-ids, solves
# isues similar to issue #5664
if hasattr(self, "position_ids"):
position_ids = self.position_ids[:, :seq_length]
else:
position_ids = torch.arange(seq_length, dtype=torch.long, device=input_ids.device) # (max_seq_length)
position_ids = position_ids.unsqueeze(0).expand_as(input_ids) # (bs, max_seq_length)
position_embeddings = self.position_embeddings(position_ids) # (bs, max_seq_length, dim)
embeddings = input_embeds + position_embeddings # (bs, max_seq_length, dim)
if self.vgcn_graph_embds_dim > 0:
graph_embeds = self.vgcn(self.word_embeddings, input_ids) # , position_ids)
# vgcn_words_embeddings = input_embeds.clone()
# for i in range(self.vgcn_graph_embds_dim):
# tmp_pos = (input_lengths - 2 - self.vgcn_graph_embds_dim + 1 + i) + torch.arange(
# 0, input_embeds.shape[0]
# ).to(device) * input_embeds.shape[1]
# vgcn_words_embeddings.flatten(start_dim=0, end_dim=1)[tmp_pos, :] = graph_embeds[:, :, i]
embeddings = torch.cat([embeddings, graph_embeds], dim=1) # (bs, max_seq_length+graph_emb_dim_size, dim)
embeddings = self.LayerNorm(embeddings) # (bs, max_seq_length, dim)
embeddings = self.dropout(embeddings) # (bs, max_seq_length, dim)
return embeddings
class MultiHeadSelfAttention(nn.Module):
def __init__(self, config: PretrainedConfig):
super().__init__()
self.n_heads = config.n_heads
self.dim = config.dim
self.dropout = nn.Dropout(p=config.attention_dropout)
# Have an even number of multi heads that divide the dimensions
if self.dim % self.n_heads != 0:
# Raise value errors for even multi-head attention nodes
raise ValueError(f"self.n_heads: {self.n_heads} must divide self.dim: {self.dim} evenly")
self.q_lin = nn.Linear(in_features=config.dim, out_features=config.dim)
self.k_lin = nn.Linear(in_features=config.dim, out_features=config.dim)
self.v_lin = nn.Linear(in_features=config.dim, out_features=config.dim)
self.out_lin = nn.Linear(in_features=config.dim, out_features=config.dim)
self.pruned_heads: Set[int] = set()
self.attention_head_size = self.dim // self.n_heads
def prune_heads(self, heads: List[int]):
if len(heads) == 0:
return
heads, index = find_pruneable_heads_and_indices(
heads, self.n_heads, self.attention_head_size, self.pruned_heads
)
# Prune linear layers
self.q_lin = prune_linear_layer(self.q_lin, index)
self.k_lin = prune_linear_layer(self.k_lin, index)
self.v_lin = prune_linear_layer(self.v_lin, index)
self.out_lin = prune_linear_layer(self.out_lin, index, dim=1)
# Update hyper params
self.n_heads = self.n_heads - len(heads)
self.dim = self.attention_head_size * self.n_heads
self.pruned_heads = self.pruned_heads.union(heads)
def forward(
self,
query: torch.Tensor,
key: torch.Tensor,
value: torch.Tensor,
mask: torch.Tensor,
head_mask: Optional[torch.Tensor] = None,
output_attentions: bool = False,
) -> Tuple[torch.Tensor, ...]:
"""
Parameters:
query: torch.tensor(bs, seq_length, dim)
key: torch.tensor(bs, seq_length, dim)
value: torch.tensor(bs, seq_length, dim)
mask: torch.tensor(bs, seq_length)
Returns:
weights: torch.tensor(bs, n_heads, seq_length, seq_length) Attention weights context: torch.tensor(bs,
seq_length, dim) Contextualized layer. Optional: only if `output_attentions=True`
"""
bs, q_length, dim = query.size()
k_length = key.size(1)
# assert dim == self.dim, f'Dimensions do not match: {dim} input vs {self.dim} configured'
# assert key.size() == value.size()
dim_per_head = self.dim // self.n_heads
mask_reshp = (bs, 1, 1, k_length)
def shape(x: torch.Tensor) -> torch.Tensor:
"""separate heads"""
return x.view(bs, -1, self.n_heads, dim_per_head).transpose(1, 2)
def unshape(x: torch.Tensor) -> torch.Tensor:
"""group heads"""
return x.transpose(1, 2).contiguous().view(bs, -1, self.n_heads * dim_per_head)
q = shape(self.q_lin(query)) # (bs, n_heads, q_length, dim_per_head)
k = shape(self.k_lin(key)) # (bs, n_heads, k_length, dim_per_head)
v = shape(self.v_lin(value)) # (bs, n_heads, k_length, dim_per_head)
q = q / math.sqrt(dim_per_head) # (bs, n_heads, q_length, dim_per_head)
scores = torch.matmul(q, k.transpose(2, 3)) # (bs, n_heads, q_length, k_length)
mask = (mask == 0).view(mask_reshp).expand_as(scores) # (bs, n_heads, q_length, k_length)
scores = scores.masked_fill(
mask, torch.tensor(torch.finfo(scores.dtype).min)
) # (bs, n_heads, q_length, k_length)
weights = nn.functional.softmax(scores, dim=-1) # (bs, n_heads, q_length, k_length)
weights = self.dropout(weights) # (bs, n_heads, q_length, k_length)
# Mask heads if we want to
if head_mask is not None:
weights = weights * head_mask
context = torch.matmul(weights, v) # (bs, n_heads, q_length, dim_per_head)
context = unshape(context) # (bs, q_length, dim)
context = self.out_lin(context) # (bs, q_length, dim)
if output_attentions:
return (context, weights)
else:
return (context,)
class FFN(nn.Module):
def __init__(self, config: PretrainedConfig):
super().__init__()
self.dropout = nn.Dropout(p=config.dropout)
self.chunk_size_feed_forward = config.chunk_size_feed_forward
self.seq_len_dim = 1
self.lin1 = nn.Linear(in_features=config.dim, out_features=config.hidden_dim)
self.lin2 = nn.Linear(in_features=config.hidden_dim, out_features=config.dim)
self.activation = get_activation(config.activation)
def forward(self, input: torch.Tensor) -> torch.Tensor:
return apply_chunking_to_forward(self.ff_chunk, self.chunk_size_feed_forward, self.seq_len_dim, input)
def ff_chunk(self, input: torch.Tensor) -> torch.Tensor:
x = self.lin1(input)
x = self.activation(x)
x = self.lin2(x)
x = self.dropout(x)
return x
class TransformerBlock(nn.Module):
def __init__(self, config: PretrainedConfig):
super().__init__()
# Have an even number of Configure multi-heads
if config.dim % config.n_heads != 0:
raise ValueError(f"config.n_heads {config.n_heads} must divide config.dim {config.dim} evenly")
self.attention = MultiHeadSelfAttention(config)
self.sa_layer_norm = nn.LayerNorm(normalized_shape=config.dim, eps=1e-12)
self.ffn = FFN(config)
self.output_layer_norm = nn.LayerNorm(normalized_shape=config.dim, eps=1e-12)
def forward(
self,
x: torch.Tensor,
attn_mask: Optional[torch.Tensor] = None,
head_mask: Optional[torch.Tensor] = None,
output_attentions: bool = False,
) -> Tuple[torch.Tensor, ...]:
"""
Parameters:
x: torch.tensor(bs, seq_length, dim)
attn_mask: torch.tensor(bs, seq_length)
Returns:
sa_weights: torch.tensor(bs, n_heads, seq_length, seq_length) The attention weights ffn_output:
torch.tensor(bs, seq_length, dim) The output of the transformer block contextualization.
"""
# Self-Attention
sa_output = self.attention(
query=x,
key=x,
value=x,
mask=attn_mask,
head_mask=head_mask,
output_attentions=output_attentions,
)
if output_attentions:
sa_output, sa_weights = sa_output # (bs, seq_length, dim), (bs, n_heads, seq_length, seq_length)
else: # To handle these `output_attentions` or `output_hidden_states` cases returning tuples
if type(sa_output) != tuple:
raise TypeError(f"sa_output must be a tuple but it is {type(sa_output)} type")
sa_output = sa_output[0]
sa_output = self.sa_layer_norm(sa_output + x) # (bs, seq_length, dim)
# Feed Forward Network
ffn_output = self.ffn(sa_output) # (bs, seq_length, dim)
ffn_output: torch.Tensor = self.output_layer_norm(ffn_output + sa_output) # (bs, seq_length, dim)
output = (ffn_output,)
if output_attentions:
output = (sa_weights,) + output
return output
class Transformer(nn.Module):
def __init__(self, config: PretrainedConfig):
super().__init__()
self.n_layers = config.n_layers
self.layer = nn.ModuleList([TransformerBlock(config) for _ in range(config.n_layers)])
def forward(
self,
x: torch.Tensor,
attn_mask: Optional[torch.Tensor] = None,
head_mask: Optional[torch.Tensor] = None,
output_attentions: bool = False,
output_hidden_states: bool = False,
return_dict: Optional[bool] = None,
) -> Union[BaseModelOutput, Tuple[torch.Tensor, ...]]: # docstyle-ignore
"""
Parameters:
x: torch.tensor(bs, seq_length, dim) Input sequence embedded.
attn_mask: torch.tensor(bs, seq_length) Attention mask on the sequence.
Returns:
hidden_state: torch.tensor(bs, seq_length, dim) Sequence of hidden states in the last (top)
layer all_hidden_states: Tuple[torch.tensor(bs, seq_length, dim)]
Tuple of length n_layers with the hidden states from each layer.
Optional: only if output_hidden_states=True
all_attentions: Tuple[torch.tensor(bs, n_heads, seq_length, seq_length)]
Tuple of length n_layers with the attention weights from each layer
Optional: only if output_attentions=True
"""
all_hidden_states = () if output_hidden_states else None
all_attentions = () if output_attentions else None
hidden_state = x
for i, layer_module in enumerate(self.layer):
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_state,)
layer_outputs = layer_module(
x=hidden_state, attn_mask=attn_mask, head_mask=head_mask[i], output_attentions=output_attentions
)
hidden_state = layer_outputs[-1]
if output_attentions:
if len(layer_outputs) != 2:
raise ValueError(f"The length of the layer_outputs should be 2, but it is {len(layer_outputs)}")
attentions = layer_outputs[0]
all_attentions = all_attentions + (attentions,)
else:
if len(layer_outputs) != 1:
raise ValueError(f"The length of the layer_outputs should be 1, but it is {len(layer_outputs)}")
# Add last layer
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_state,)
if not return_dict:
return tuple(v for v in [hidden_state, all_hidden_states, all_attentions] if v is not None)
return BaseModelOutput(
last_hidden_state=hidden_state, hidden_states=all_hidden_states, attentions=all_attentions
)
# INTERFACE FOR ENCODER AND TASK SPECIFIC MODEL #
# Copied from transformers.models.distilbert.modeling_distilbert.DistilBertPreTrainedModel with DistilBert->VGCNBert,distilbert->vgcn_bert
class VGCNBertPreTrainedModel(PreTrainedModel):
"""
An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
models.
"""
config_class = VGCNBertConfig
load_tf_weights = None
base_model_prefix = "vgcn_bert"
def _init_weights(self, module: nn.Module):
"""Initialize the weights."""
if isinstance(module, nn.Linear):
# Slightly different from the TF version which uses truncated_normal for initialization
# cf https://github.com/pytorch/pytorch/pull/5617
if getattr(module, "_is_vgcn_linear", False):
if self.config.vgcn_weight_init_mode == "transparent":
module.weight.data.fill_(1.0)
elif self.config.vgcn_weight_init_mode == "normal":
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
elif self.config.vgcn_weight_init_mode == "uniform":
nn.init.kaiming_uniform_(module.weight, a=math.sqrt(5))
else:
raise ValueError(f"Unknown VGCN-BERT weight init mode: {self.config.vgcn_weight_init_mode}.")
if module.bias is not None:
module.bias.data.zero_()
else:
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
if module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.Embedding):
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
if module.padding_idx is not None:
module.weight.data[module.padding_idx].zero_()
elif isinstance(module, nn.LayerNorm):
module.bias.data.zero_()
module.weight.data.fill_(1.0)
elif isinstance(module, nn.ParameterList):
if getattr(module, "_is_vgcn_weights", False):
for p in module:
if self.config.vgcn_weight_init_mode == "transparent":
nn.init.constant_(p, 1.0)
elif self.config.vgcn_weight_init_mode == "normal":
nn.init.normal_(p, mean=0.0, std=self.config.initializer_range)
elif self.config.vgcn_weight_init_mode == "uniform":
nn.init.kaiming_uniform_(p, a=math.sqrt(5))
else:
raise ValueError(f"Unknown VGCN-BERT weight init mode: {self.config.vgcn_weight_init_mode}.")
VGCNBERT_START_DOCSTRING = r"""
This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
etc.)
This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.
Parameters:
config ([`VGCNBertConfig`]): Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the
configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""
VGCNBERT_INPUTS_DOCSTRING = r"""
Args:
input_ids (`torch.LongTensor` of shape `({0})`):
Indices of input sequence tokens in the vocabulary.
Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
[`PreTrainedTokenizer.__call__`] for details.
[What are input IDs?](../glossary#input-ids)
attention_mask (`torch.FloatTensor` of shape `({0})`, *optional*):
Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
- 1 for tokens that are **not masked**,
- 0 for tokens that are **masked**.
[What are attention masks?](../glossary#attention-mask)
head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:
- 1 indicates the head is **not masked**,
- 0 indicates the head is **masked**.
inputs_embeds (`torch.FloatTensor` of shape `({0}, hidden_size)`, *optional*):
Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
model's internal embedding lookup matrix.
output_attentions (`bool`, *optional*):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
tensors for more detail.
output_hidden_states (`bool`, *optional*):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
more detail.
return_dict (`bool`, *optional*):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""
@add_start_docstrings(
"The bare VGCN-BERT encoder/transformer outputting raw hidden-states without any specific head on top.",
VGCNBERT_START_DOCSTRING,
)
# Copied from transformers.models.distilbert.modeling_distilbert.DistilBertModel with DISTILBERT->VGCNBERT,DistilBert->VGCNBert
class VGCNBertModel(VGCNBertPreTrainedModel):
def __init__(
self,
config: PretrainedConfig,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
):
super().__init__(config)
self.embeddings = VGCNEmbeddings(config, wgraphs, wgraph_id_to_tokenizer_id_maps) # Graph Embeddings
self.transformer = Transformer(config) # Encoder
self.wgraph_builder = WordGraphBuilder()
# Initialize weights and apply final processing
self.post_init()
def set_wgraphs(
self,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
mode="transparent",
):
self.embeddings.vgcn.set_wgraphs(wgraphs, wgraph_id_to_tokenizer_id_maps, mode)
def get_position_embeddings(self) -> nn.Embedding:
"""
Returns the position embeddings
"""
return self.embeddings.position_embeddings
def resize_position_embeddings(self, new_num_position_embeddings: int):
"""
Resizes position embeddings of the model if `new_num_position_embeddings != config.max_position_embeddings`.
Arguments:
new_num_position_embeddings (`int`):
The number of new position embedding matrix. If position embeddings are learned, increasing the size
will add newly initialized vectors at the end, whereas reducing the size will remove vectors from the
end. If position embeddings are not learned (*e.g.* sinusoidal position embeddings), increasing the
size will add correct vectors at the end following the position encoding algorithm, whereas reducing
the size will remove vectors from the end.
"""
num_position_embeds_diff = new_num_position_embeddings - self.config.max_position_embeddings
# no resizing needs to be done if the length stays the same
if num_position_embeds_diff == 0:
return
logger.info(f"Setting `config.max_position_embeddings={new_num_position_embeddings}`...")
self.config.max_position_embeddings = new_num_position_embeddings
old_position_embeddings_weight = self.embeddings.position_embeddings.weight.clone()
self.embeddings.position_embeddings = nn.Embedding(self.config.max_position_embeddings, self.config.dim)
if self.config.sinusoidal_pos_embds:
create_sinusoidal_embeddings(
n_pos=self.config.max_position_embeddings, dim=self.config.dim, out=self.position_embeddings.weight
)
else:
with torch.no_grad():
if num_position_embeds_diff > 0:
self.embeddings.position_embeddings.weight[:-num_position_embeds_diff] = nn.Parameter(
old_position_embeddings_weight
)
else:
self.embeddings.position_embeddings.weight = nn.Parameter(
old_position_embeddings_weight[:num_position_embeds_diff]
)
# move position_embeddings to correct device
self.embeddings.position_embeddings.to(self.device)
def get_input_embeddings(self) -> nn.Embedding:
return self.embeddings.word_embeddings
def set_input_embeddings(self, new_embeddings: nn.Embedding):
self.embeddings.word_embeddings = new_embeddings
def _prune_heads(self, heads_to_prune: Dict[int, List[List[int]]]):
"""
Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
class PreTrainedModel
"""
for layer, heads in heads_to_prune.items():
self.transformer.layer[layer].attention.prune_heads(heads)
@add_start_docstrings_to_model_forward(VGCNBERT_INPUTS_DOCSTRING.format("batch_size, num_choices"))
@add_code_sample_docstrings(
checkpoint=_CHECKPOINT_FOR_DOC,
output_type=BaseModelOutput,
config_class=_CONFIG_FOR_DOC,
)
def forward(
self,
input_ids: Optional[torch.Tensor] = None,
attention_mask: Optional[torch.Tensor] = None,
head_mask: Optional[torch.Tensor] = None,
inputs_embeds: Optional[torch.Tensor] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[BaseModelOutput, Tuple[torch.Tensor, ...]]:
output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
)
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
if input_ids is not None and inputs_embeds is not None:
raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
elif input_ids is not None:
input_shape = input_ids.size()
elif inputs_embeds is not None:
input_shape = inputs_embeds.size()[:-1]
else:
raise ValueError("You have to specify either input_ids or inputs_embeds")
device = input_ids.device if input_ids is not None else inputs_embeds.device
if attention_mask is None:
attention_mask = torch.ones(input_shape, device=device) # (bs, seq_length)
# Prepare head mask if needed
head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
embeddings = self.embeddings(input_ids, inputs_embeds) # (bs, seq_length, dim)
if self.embeddings.vgcn_graph_embds_dim > 0:
attention_mask = torch.cat(
[attention_mask, torch.ones((input_shape[0], self.embeddings.vgcn_graph_embds_dim), device=device)],
dim=1,
)
return self.transformer(
x=embeddings,
attn_mask=attention_mask,
head_mask=head_mask,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
@add_start_docstrings(
"""VGCNBert Model with a `masked language modeling` head on top.""",
VGCNBERT_START_DOCSTRING,
)
# Copied from transformers.models.distilbert.modeling_distilbert.DistilBertForMaskedLM with DISTILBERT->VGCNBERT,DistilBert->VGCNBert,distilbert->vgcn_bert
class VGCNBertForMaskedLM(VGCNBertPreTrainedModel):
_keys_to_ignore_on_load_missing = ["vocab_projector.weight"]
def __init__(
self,
config: PretrainedConfig,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
):
super().__init__(config)
self.activation = get_activation(config.activation)
self.vgcn_bert = VGCNBertModel(config, wgraphs, wgraph_id_to_tokenizer_id_maps)
self.vocab_transform = nn.Linear(config.dim, config.dim)
self.vocab_layer_norm = nn.LayerNorm(config.dim, eps=1e-12)
self.vocab_projector = nn.Linear(config.dim, config.vocab_size)
# Initialize weights and apply final processing
self.post_init()
self.mlm_loss_fct = nn.CrossEntropyLoss()
def get_position_embeddings(self) -> nn.Embedding:
"""
Returns the position embeddings
"""
return self.vgcn_bert.get_position_embeddings()
def resize_position_embeddings(self, new_num_position_embeddings: int):
"""
Resizes position embeddings of the model if `new_num_position_embeddings != config.max_position_embeddings`.
Arguments:
new_num_position_embeddings (`int`):
The number of new position embedding matrix. If position embeddings are learned, increasing the size
will add newly initialized vectors at the end, whereas reducing the size will remove vectors from the
end. If position embeddings are not learned (*e.g.* sinusoidal position embeddings), increasing the
size will add correct vectors at the end following the position encoding algorithm, whereas reducing
the size will remove vectors from the end.
"""
self.vgcn_bert.resize_position_embeddings(new_num_position_embeddings)
def get_output_embeddings(self) -> nn.Module:
return self.vocab_projector
def set_output_embeddings(self, new_embeddings: nn.Module):
self.vocab_projector = new_embeddings
@add_start_docstrings_to_model_forward(VGCNBERT_INPUTS_DOCSTRING.format("batch_size, num_choices"))
@add_code_sample_docstrings(
checkpoint=_CHECKPOINT_FOR_DOC,
output_type=MaskedLMOutput,
config_class=_CONFIG_FOR_DOC,
)
def forward(
self,
input_ids: Optional[torch.Tensor] = None,
attention_mask: Optional[torch.Tensor] = None,
head_mask: Optional[torch.Tensor] = None,
inputs_embeds: Optional[torch.Tensor] = None,
labels: Optional[torch.LongTensor] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[MaskedLMOutput, Tuple[torch.Tensor, ...]]:
r"""
labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the
loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
"""
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
dlbrt_output = self.vgcn_bert(
input_ids=input_ids,
attention_mask=attention_mask,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = dlbrt_output[0] # (bs, seq_length, dim)
prediction_logits = self.vocab_transform(hidden_states) # (bs, seq_length, dim)
prediction_logits = self.activation(prediction_logits) # (bs, seq_length, dim)
prediction_logits = self.vocab_layer_norm(prediction_logits) # (bs, seq_length, dim)
prediction_logits = self.vocab_projector(prediction_logits) # (bs, seq_length, vocab_size)
# remove graph embedding outputs
prediction_logits = prediction_logits[:, : input_ids.size(1), :]
mlm_loss = None
if labels is not None:
mlm_loss = self.mlm_loss_fct(prediction_logits.reshape(-1, prediction_logits.size(-1)), labels.view(-1))
if not return_dict:
output = (prediction_logits,) + dlbrt_output[1:]
return ((mlm_loss,) + output) if mlm_loss is not None else output
return MaskedLMOutput(
loss=mlm_loss,
logits=prediction_logits,
hidden_states=dlbrt_output.hidden_states,
attentions=dlbrt_output.attentions,
)
@add_start_docstrings(
"""
VGCNBert Model transformer with a sequence classification/regression head on top (a linear layer on top of the
pooled output) e.g. for GLUE tasks.
""",
VGCNBERT_START_DOCSTRING,
)
# Copied from transformers.models.distilbert.modeling_distilbert.DistilBertForSequenceClassification with DISTILBERT->VGCNBERT,DistilBert->VGCNBert,distilbert->vgcn_bert
class VGCNBertForSequenceClassification(VGCNBertPreTrainedModel):
def __init__(
self,
config: PretrainedConfig,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
):
super().__init__(config)
self.num_labels = config.num_labels
self.config = config
self.vgcn_bert = VGCNBertModel(config, wgraphs, wgraph_id_to_tokenizer_id_maps)
self.pre_classifier = nn.Linear(config.dim, config.dim)
self.classifier = nn.Linear(config.dim, config.num_labels)
self.dropout = nn.Dropout(config.seq_classif_dropout)
# Initialize weights and apply final processing
self.post_init()
def get_position_embeddings(self) -> nn.Embedding:
"""
Returns the position embeddings
"""
return self.vgcn_bert.get_position_embeddings()
def resize_position_embeddings(self, new_num_position_embeddings: int):
"""
Resizes position embeddings of the model if `new_num_position_embeddings != config.max_position_embeddings`.
Arguments:
new_num_position_embeddings (`int`):
The number of new position embedding matrix. If position embeddings are learned, increasing the size
will add newly initialized vectors at the end, whereas reducing the size will remove vectors from the
end. If position embeddings are not learned (*e.g.* sinusoidal position embeddings), increasing the
size will add correct vectors at the end following the position encoding algorithm, whereas reducing
the size will remove vectors from the end.
"""
self.vgcn_bert.resize_position_embeddings(new_num_position_embeddings)
@add_start_docstrings_to_model_forward(VGCNBERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
@add_code_sample_docstrings(
checkpoint=_CHECKPOINT_FOR_DOC,
output_type=SequenceClassifierOutput,
config_class=_CONFIG_FOR_DOC,
)
def forward(
self,
input_ids: Optional[torch.Tensor] = None,
attention_mask: Optional[torch.Tensor] = None,
head_mask: Optional[torch.Tensor] = None,
inputs_embeds: Optional[torch.Tensor] = None,
labels: Optional[torch.LongTensor] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[SequenceClassifierOutput, Tuple[torch.Tensor, ...]]:
r"""
labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
"""
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
vgcn_bert_output = self.vgcn_bert(
input_ids=input_ids,
attention_mask=attention_mask,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_state = vgcn_bert_output[0] # (bs, seq_len, dim)
pooled_output = hidden_state[:, 0] # (bs, dim)
pooled_output = self.pre_classifier(pooled_output) # (bs, dim)
pooled_output = nn.ReLU()(pooled_output) # (bs, dim)
pooled_output = self.dropout(pooled_output) # (bs, dim)
logits = self.classifier(pooled_output) # (bs, num_labels)
loss = None
if labels is not None:
if self.config.problem_type is None:
if self.num_labels == 1:
self.config.problem_type = "regression"
elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
self.config.problem_type = "single_label_classification"
else:
self.config.problem_type = "multi_label_classification"
if self.config.problem_type == "regression":
loss_fct = MSELoss()
if self.num_labels == 1:
loss = loss_fct(logits.squeeze(), labels.squeeze())
else:
loss = loss_fct(logits, labels)
elif self.config.problem_type == "single_label_classification":
loss_fct = CrossEntropyLoss()
loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
elif self.config.problem_type == "multi_label_classification":
loss_fct = BCEWithLogitsLoss()
loss = loss_fct(logits, labels)
if not return_dict:
output = (logits,) + vgcn_bert_output[1:]
return ((loss,) + output) if loss is not None else output
return SequenceClassifierOutput(
loss=loss,
logits=logits,
hidden_states=vgcn_bert_output.hidden_states,
attentions=vgcn_bert_output.attentions,
)
@add_start_docstrings(
"""
VGCNBert Model with a span classification head on top for extractive question-answering tasks like SQuAD (a
linear layers on top of the hidden-states output to compute `span start logits` and `span end logits`).
""",
VGCNBERT_START_DOCSTRING,
)
# Copied from transformers.models.distilbert.modeling_distilbert.DistilBertForQuestionAnswering with DISTILBERT->VGCNBERT,DistilBert->VGCNBert,distilbert->vgcn_bert
class VGCNBertForQuestionAnswering(VGCNBertPreTrainedModel):
def __init__(
self,
config: PretrainedConfig,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
):
super().__init__(config)
self.vgcn_bert = VGCNBertModel(config, wgraphs, wgraph_id_to_tokenizer_id_maps)
self.qa_outputs = nn.Linear(config.dim, config.num_labels)
if config.num_labels != 2:
raise ValueError(f"config.num_labels should be 2, but it is {config.num_labels}")
self.dropout = nn.Dropout(config.qa_dropout)
# Initialize weights and apply final processing
self.post_init()
def get_position_embeddings(self) -> nn.Embedding:
"""
Returns the position embeddings
"""
return self.vgcn_bert.get_position_embeddings()
def resize_position_embeddings(self, new_num_position_embeddings: int):
"""
Resizes position embeddings of the model if `new_num_position_embeddings != config.max_position_embeddings`.
Arguments:
new_num_position_embeddings (`int`):
The number of new position embedding matrix. If position embeddings are learned, increasing the size
will add newly initialized vectors at the end, whereas reducing the size will remove vectors from the
end. If position embeddings are not learned (*e.g.* sinusoidal position embeddings), increasing the
size will add correct vectors at the end following the position encoding algorithm, whereas reducing
the size will remove vectors from the end.
"""
self.vgcn_bert.resize_position_embeddings(new_num_position_embeddings)
@add_start_docstrings_to_model_forward(VGCNBERT_INPUTS_DOCSTRING.format("batch_size, num_choices"))
@add_code_sample_docstrings(
checkpoint=_CHECKPOINT_FOR_DOC,
output_type=QuestionAnsweringModelOutput,
config_class=_CONFIG_FOR_DOC,
)
def forward(
self,
input_ids: Optional[torch.Tensor] = None,
attention_mask: Optional[torch.Tensor] = None,
head_mask: Optional[torch.Tensor] = None,
inputs_embeds: Optional[torch.Tensor] = None,
start_positions: Optional[torch.Tensor] = None,
end_positions: Optional[torch.Tensor] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[QuestionAnsweringModelOutput, Tuple[torch.Tensor, ...]]:
r"""
start_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
Labels for position (index) of the start of the labelled span for computing the token classification loss.
Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
are not taken into account for computing the loss.
end_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
Labels for position (index) of the end of the labelled span for computing the token classification loss.
Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
are not taken into account for computing the loss.
"""
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
vgcn_bert_output = self.vgcn_bert(
input_ids=input_ids,
attention_mask=attention_mask,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = vgcn_bert_output[0] # (bs, max_query_len, dim)
hidden_states = self.dropout(hidden_states) # (bs, max_query_len, dim)
logits = self.qa_outputs(hidden_states) # (bs, max_query_len, 2)
# remove graph embedding outputs
logits = logits[:, : input_ids.size(1), :]
start_logits, end_logits = logits.split(1, dim=-1)
start_logits = start_logits.squeeze(-1).contiguous() # (bs, max_query_len)
end_logits = end_logits.squeeze(-1).contiguous() # (bs, max_query_len)
total_loss = None
if start_positions is not None and end_positions is not None:
# If we are on multi-GPU, split add a dimension
if len(start_positions.size()) > 1:
start_positions = start_positions.squeeze(-1)
if len(end_positions.size()) > 1:
end_positions = end_positions.squeeze(-1)
# sometimes the start/end positions are outside our model inputs, we ignore these terms
ignored_index = start_logits.size(1)
start_positions = start_positions.clamp(0, ignored_index)
end_positions = end_positions.clamp(0, ignored_index)
loss_fct = nn.CrossEntropyLoss(ignore_index=ignored_index)
start_loss = loss_fct(start_logits, start_positions)
end_loss = loss_fct(end_logits, end_positions)
total_loss = (start_loss + end_loss) / 2
if not return_dict:
output = (start_logits, end_logits) + vgcn_bert_output[1:]
return ((total_loss,) + output) if total_loss is not None else output
return QuestionAnsweringModelOutput(
loss=total_loss,
start_logits=start_logits,
end_logits=end_logits,
hidden_states=vgcn_bert_output.hidden_states,
attentions=vgcn_bert_output.attentions,
)
@add_start_docstrings(
"""
VGCNBert Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g.
for Named-Entity-Recognition (NER) tasks.
""",
VGCNBERT_START_DOCSTRING,
)
# Copied from transformers.models.distilbert.modeling_distilbert.DistilBertForTokenClassification with DISTILBERT->VGCNBERT,DistilBert->VGCNBert,distilbert->vgcn_bert
class VGCNBertForTokenClassification(VGCNBertPreTrainedModel):
def __init__(
self,
config: PretrainedConfig,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
):
super().__init__(config)
self.num_labels = config.num_labels
self.vgcn_bert = VGCNBertModel(config, wgraphs, wgraph_id_to_tokenizer_id_maps)
self.dropout = nn.Dropout(config.dropout)
self.classifier = nn.Linear(config.hidden_size, config.num_labels)
# Initialize weights and apply final processing
self.post_init()
def get_position_embeddings(self) -> nn.Embedding:
"""
Returns the position embeddings
"""
return self.vgcn_bert.get_position_embeddings()
def resize_position_embeddings(self, new_num_position_embeddings: int):
"""
Resizes position embeddings of the model if `new_num_position_embeddings != config.max_position_embeddings`.
Arguments:
new_num_position_embeddings (`int`):
The number of new position embedding matrix. If position embeddings are learned, increasing the size
will add newly initialized vectors at the end, whereas reducing the size will remove vectors from the
end. If position embeddings are not learned (*e.g.* sinusoidal position embeddings), increasing the
size will add correct vectors at the end following the position encoding algorithm, whereas reducing
the size will remove vectors from the end.
"""
self.vgcn_bert.resize_position_embeddings(new_num_position_embeddings)
@add_start_docstrings_to_model_forward(VGCNBERT_INPUTS_DOCSTRING)
@add_code_sample_docstrings(
checkpoint=_CHECKPOINT_FOR_DOC,
output_type=TokenClassifierOutput,
config_class=_CONFIG_FOR_DOC,
)
def forward(
self,
input_ids: Optional[torch.Tensor] = None,
attention_mask: Optional[torch.Tensor] = None,
head_mask: Optional[torch.Tensor] = None,
inputs_embeds: Optional[torch.Tensor] = None,
labels: Optional[torch.LongTensor] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[TokenClassifierOutput, Tuple[torch.Tensor, ...]]:
r"""
labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
"""
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
outputs = self.vgcn_bert(
input_ids,
attention_mask=attention_mask,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
sequence_output = outputs[0]
sequence_output = self.dropout(sequence_output)
logits = self.classifier(sequence_output)
# remove graph embedding outputs
logits = logits[:, : input_ids.size(1), :]
loss = None
if labels is not None:
loss_fct = CrossEntropyLoss()
loss = loss_fct(logits.reshape(-1, self.num_labels), labels.view(-1))
if not return_dict:
output = (logits,) + outputs[1:]
return ((loss,) + output) if loss is not None else output
return TokenClassifierOutput(
loss=loss,
logits=logits,
hidden_states=outputs.hidden_states,
attentions=outputs.attentions,
)
@add_start_docstrings(
"""
VGCNBert Model with a multiple choice classification head on top (a linear layer on top of the pooled output and
a softmax) e.g. for RocStories/SWAG tasks.
""",
VGCNBERT_START_DOCSTRING,
)
# Copied from transformers.models.distilbert.modeling_distilbert.DistilBertForMultipleChoice with DISTILBERT->VGCNBERT,DistilBert->VGCNBert,distilbert->vgcn_bert
class VGCNBertForMultipleChoice(VGCNBertPreTrainedModel):
def __init__(
self,
config: PretrainedConfig,
wgraphs: Optional[list] = None,
wgraph_id_to_tokenizer_id_maps: Optional[List[dict]] = None,
):
super().__init__(config)
self.vgcn_bert = VGCNBertModel(config, wgraphs, wgraph_id_to_tokenizer_id_maps)
self.pre_classifier = nn.Linear(config.dim, config.dim)
self.classifier = nn.Linear(config.dim, 1)
self.dropout = nn.Dropout(config.seq_classif_dropout)
# Initialize weights and apply final processing
self.post_init()
def get_position_embeddings(self) -> nn.Embedding:
"""
Returns the position embeddings
"""
return self.vgcn_bert.get_position_embeddings()
def resize_position_embeddings(self, new_num_position_embeddings: int):
"""
Resizes position embeddings of the model if `new_num_position_embeddings != config.max_position_embeddings`.
Arguments:
new_num_position_embeddings (`int`)
The number of new position embeddings. If position embeddings are learned, increasing the size will add
newly initialized vectors at the end, whereas reducing the size will remove vectors from the end. If
position embeddings are not learned (*e.g.* sinusoidal position embeddings), increasing the size will
add correct vectors at the end following the position encoding algorithm, whereas reducing the size
will remove vectors from the end.
"""
self.vgcn_bert.resize_position_embeddings(new_num_position_embeddings)
@add_start_docstrings_to_model_forward(
VGCNBERT_INPUTS_DOCSTRING.format("batch_size, num_choices, sequence_length")
)
@replace_return_docstrings(output_type=MultipleChoiceModelOutput, config_class=_CONFIG_FOR_DOC)
def forward(
self,
input_ids: Optional[torch.Tensor] = None,
attention_mask: Optional[torch.Tensor] = None,
head_mask: Optional[torch.Tensor] = None,
inputs_embeds: Optional[torch.Tensor] = None,
labels: Optional[torch.LongTensor] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[MultipleChoiceModelOutput, Tuple[torch.Tensor, ...]]:
r"""
labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
Labels for computing the multiple choice classification loss. Indices should be in `[0, ...,
num_choices-1]` where `num_choices` is the size of the second dimension of the input tensors. (See
`input_ids` above)
Returns:
Examples:
```python
>>> from transformers import AutoTokenizer, VGCNBertForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("vgcn_bert-base-cased")
>>> model = VGCNBertForMultipleChoice.from_pretrained("vgcn_bert-base-cased")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([[prompt, choice0], [prompt, choice1]], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits
```"""
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
num_choices = input_ids.shape[1] if input_ids is not None else inputs_embeds.shape[1]
input_ids = input_ids.view(-1, input_ids.size(-1)) if input_ids is not None else None
attention_mask = attention_mask.view(-1, attention_mask.size(-1)) if attention_mask is not None else None
inputs_embeds = (
inputs_embeds.view(-1, inputs_embeds.size(-2), inputs_embeds.size(-1))
if inputs_embeds is not None
else None
)
outputs = self.vgcn_bert(
input_ids,
attention_mask=attention_mask,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_state = outputs[0] # (bs * num_choices, seq_len, dim)
pooled_output = hidden_state[:, 0] # (bs * num_choices, dim)
pooled_output = self.pre_classifier(pooled_output) # (bs * num_choices, dim)
pooled_output = nn.ReLU()(pooled_output) # (bs * num_choices, dim)
pooled_output = self.dropout(pooled_output) # (bs * num_choices, dim)
logits = self.classifier(pooled_output) # (bs * num_choices, 1)
reshaped_logits = logits.view(-1, num_choices) # (bs, num_choices)
loss = None
if labels is not None:
loss_fct = CrossEntropyLoss()
loss = loss_fct(reshaped_logits, labels)
if not return_dict:
output = (reshaped_logits,) + outputs[1:]
return ((loss,) + output) if loss is not None else output
return MultipleChoiceModelOutput(
loss=loss,
logits=reshaped_logits,
hidden_states=outputs.hidden_states,
attentions=outputs.attentions,
)