Upload 10 files

added_tokens.json

@@ -0,0 +1,6 @@
+{
+  "[/א1]": 52001,
+  "[/א2]": 52003,
+  "[א1]": 52000,
+  "[א2]": 52002
+}

config.json

@@ -0,0 +1,49 @@
+{
+  "EMS1": 52000,
+  "EMS2": 52002,
+  "ES_ID": 0,
+  "_name_or_path": "onlplab/alephbert-base",
+  "architecture": "EMP",
+  "architectures": [
+    "TemporalRelationClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "auto_map": {
+    "AutoConfig": "temporal_relation_classification_config.TemporalRelationClassificationConfig",
+    "AutoModelForSequenceClassification": "temporal_relation_classification.TemporalRelationClassification"
+  },
+  "base_lm": "onlplab/alephbert-base",
+  "classifier_dropout": null,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "BEFORE",
+    "1": "AFTER",
+    "2": "EQUAL",
+    "3": "VAGUE"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "AFTER": 1,
+    "BEFORE": 0,
+    "EQUAL": 2,
+    "VAGUE": 3
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "TemporalRelationClassification",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "pool_tokens": true,
+  "position_embedding_type": "absolute",
+  "special_markers": true,
+  "tokenizer_class": "BertTokenizerFast",
+  "torch_dtype": "float32",
+  "transformers_version": "4.26.1",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 52004
+}

evaluation_report.txt

@@ -0,0 +1,21 @@
+              precision    recall  f1-score   support
+
+      BEFORE       0.72      0.73      0.73       674
+       AFTER       0.61      0.77      0.68       437
+       EQUAL       0.37      0.37      0.37       106
+       VAGUE       0.42      0.23      0.29       268
+
+    accuracy                           0.62      1485
+   macro avg       0.53      0.52      0.52      1485
+weighted avg       0.61      0.62      0.61      1485
+
+              precision    recall  f1-score   support
+
+      BEFORE       0.87      0.76      0.81       772
+       AFTER       0.79      0.81      0.80       536
+       EQUAL       0.46      0.42      0.44       116
+       VAGUE       0.42      1.00      0.59        61
+
+    accuracy                           0.76      1485
+   macro avg       0.63      0.75      0.66      1485
+weighted avg       0.79      0.76      0.77      1485

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bdd49e993a971a07961c0768a7a722d1798a23fa2eb95051b6f7ba60253ba261
+size 527633677

special_tokens_map.json

@@ -0,0 +1,13 @@
+{
+  "additional_special_tokens": [
+    "[א1]",
+    "[/א1]",
+    "[א2]",
+    "[/א2]"
+  ],
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

temporal_relation_classification.py

@@ -0,0 +1,174 @@
+from typing import Optional, Tuple, Union
+
+import torch
+from torch import nn
+from torch.nn import CrossEntropyLoss, BCEWithLogitsLoss, MSELoss
+from transformers import BertPreTrainedModel, BertModel, BertForSequenceClassification
+from transformers.modeling_outputs import SequenceClassifierOutput
+
+from trc_model.temporal_relation_classification_config import TemporalRelationClassificationConfig
+
+
+class TokenPooler(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.activation = nn.Tanh()
+
+    def forward(self, token_tensor: torch.Tensor) -> torch.Tensor:
+        # We "pool" the model by simply taking the hidden state corresponding
+        # to the first token.
+        pooled_output = self.dense(token_tensor)
+        pooled_output = self.activation(pooled_output)
+        return pooled_output
+
+
+class TemporalRelationClassification(BertForSequenceClassification):
+    config_class = TemporalRelationClassificationConfig
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.special_markers = config.special_markers
+        self.pool_tokens = config.pool_tokens
+        self.ES_ID = config.ES_ID
+        self.EMS1 = config.EMS1
+        self.EMS2 = config.EMS2
+        self.architecture = config.architecture
+        self.config = config
+
+        self.bert = BertModel.from_pretrained(config.base_lm)
+        if self.bert.config.vocab_size != config.vocab_size:
+            self.bert.resize_token_embeddings(config.vocab_size)
+
+        classifier_dropout = (
+            config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
+        )
+        if config.pool_tokens:
+            self.ems_1_pooler = TokenPooler(config)
+            self.ems_2_pooler = TokenPooler(config)
+            self.e_1_pooler = TokenPooler(config)
+            self.e_2_pooler = TokenPooler(config)
+
+        self.dropout = nn.Dropout(classifier_dropout)
+
+        self.classification_layers = None
+        if self.architecture == 'SEQ_CLS':
+            self.classification_layers = nn.Sequential(
+                nn.Linear(config.hidden_size, config.num_labels)
+            )
+        if self.architecture == 'EMP':
+            self.e_1_linear = nn.Linear(config.hidden_size * 2, config.hidden_size)
+            self.e_2_linear = nn.Linear(config.hidden_size * 2, config.hidden_size)
+
+        if self.architecture in ['ESS', 'EF', 'EMP']:
+            self.classification_layers = nn.Sequential(
+                nn.Linear(config.hidden_size * 2, config.hidden_size),
+                nn.Linear(config.hidden_size, config.num_labels)
+            )
+
+        # Initialize weights and apply final processing
+        # self.post_init()
+
+    def _get_entities_and_start_markers_indices(self, input_ids):
+        if not self.special_markers:
+            event_1_start, event_2_start = torch.tensor(
+                [(ids == self.ES_ID).nonzero().squeeze().tolist() for ids in input_ids]).T
+            return event_1_start, event_1_start + 1, event_2_start, event_2_start + 1
+
+        em1_s = torch.tensor([(ids == self.EMS1).nonzero().item() for ids in input_ids], device=self.device)
+        entity_1 = em1_s + 1
+
+        em2_s = torch.tensor([(ids == self.EMS2).nonzero().item() for ids in input_ids], device=self.device)
+        entity_2 = em2_s + 1
+        return em1_s, entity_1, em2_s, entity_2
+
+    def forward(
+            self,
+            input_ids: Optional[torch.Tensor] = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            token_type_ids: Optional[torch.Tensor] = None,
+            position_ids: Optional[torch.Tensor] = None,
+            head_mask: Optional[torch.Tensor] = None,
+            inputs_embeds: Optional[torch.Tensor] = None,
+            labels: Optional[torch.Tensor] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], SequenceClassifierOutput]:
+        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
+
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        logits = None
+        if self.architecture == 'SEQ_CLS':
+            pooled_output = outputs[1]
+
+            pooled_output = self.dropout(pooled_output)
+            logits = self.classification_layers(pooled_output)
+        else:
+            sequence_output = outputs[0]
+
+            sequence_output = self.dropout(sequence_output)
+
+            entity_mark_1_s, entity_1, entity_mark_2_s, entity_2 = self._get_entities_and_start_markers_indices(
+                input_ids)
+
+            e1_start_mark_tensors = sequence_output[torch.arange(sequence_output.size(0)), entity_mark_1_s]
+            e2_start_mark_tensors = sequence_output[torch.arange(sequence_output.size(0)), entity_mark_2_s]
+
+            e1_tensor = sequence_output[torch.arange(sequence_output.size(0)), entity_1]
+            e2_tensor = sequence_output[torch.arange(sequence_output.size(0)), entity_2]
+
+            if self.pool_tokens:
+                e1_start_mark_tensors = self.ems_1_pooler(e1_start_mark_tensors)
+                e2_start_mark_tensors = self.ems_2_pooler(e2_start_mark_tensors)
+
+                e1_tensor = self.e_1_pooler(e1_tensor)
+                e2_tensor = self.e_2_pooler(e2_tensor)
+
+            if self.architecture == 'ESS':
+                e_start_markers_cat = torch.cat((e1_start_mark_tensors, e2_start_mark_tensors), 1)
+                logits = self.classification_layers(e_start_markers_cat)
+
+            if self.architecture == 'EF':
+                events_cat = torch.cat((e1_tensor, e2_tensor), 1)
+                logits = self.classification_layers(events_cat)
+
+            if self.architecture == 'EMP':
+                e1_and_start_mark = self.e_1_linear(torch.cat((e1_start_mark_tensors, e1_tensor), 1))
+                e2_and_start_mark = self.e_2_linear(torch.cat((e2_start_mark_tensors, e2_tensor), 1))
+                both_e_cat = torch.cat((e1_and_start_mark, e2_and_start_mark), 1)
+                logits = self.classification_layers(both_e_cat)
+
+        loss = None
+        if labels is not None:
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return SequenceClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )

temporal_relation_classification_config.py

@@ -0,0 +1,15 @@
+from transformers import PretrainedConfig, BertConfig
+
+
+class TemporalRelationClassificationConfig(BertConfig):
+    model_type = "TemporalRelationClassification"
+
+    def __init__(self, special_markers=False, pool_tokens=False, ES_ID=0, EMS1=0, EMS2=0, architecture=0, **kwargs):
+        super().__init__(**kwargs)
+        self.base_lm = self.name_or_path
+        self.pool_tokens = pool_tokens
+        self.special_markers = special_markers
+        self.architecture = architecture
+        self.EMS1 = EMS1
+        self.EMS2 = EMS2
+        self.ES_ID = ES_ID

tokenizer_config.json

@@ -0,0 +1,17 @@
+{
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "max_len": 512,
+  "model_max_length": 512,
+  "name_or_path": "onlplab/alephbert-base",
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "special_tokens_map_file": null,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21ac59d2913711397a63f441cc16d3162d1b0218c47185750d13da6a5dde2800
+size 3567