Upload VAD transformer model

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+vad_by_category.png filter=lfs diff=lfs merge=lfs -text
+vad_distribution.png filter=lfs diff=lfs merge=lfs -text
+vad_vs_casualties.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,50 @@
+
+# Disaster News VAD Model
+
+This model predicts Valence, Arousal, and Dominance (VAD) values for disaster news headlines. 
+It was trained on the EmoBank dataset and fine-tuned on disaster news headlines.
+
+## Model Details
+
+- **Architecture**: RoBERTa-based transformer model with regression heads for VAD prediction
+- **Training Data**: EmoBank dataset
+- **Application**: Emotional analysis of disaster news headlines
+- **Date**: 2025-03-16
+
+## Usage
+
+```python
+from transformers import RobertaTokenizer, AutoModel
+import torch
+
+# Load model and tokenizer
+tokenizer = RobertaTokenizer.from_pretrained("postgrammar/disaster-news-vad-model")
+model = AutoModel.from_pretrained("postgrammar/disaster-news-vad-model")
+
+# Prepare input
+text = "Earthquake devastates coastal town, rescue efforts underway"
+inputs = tokenizer(text, return_tensors="pt")
+
+# Get predictions
+with torch.no_grad():
+    outputs = model(**inputs)
+    
+# Extract VAD values (first three values in the output tuple)
+valence, arousal, dominance = outputs[0], outputs[1], outputs[2]
+
+print(f"Valence: {valence.item():.4f}, Arousal: {arousal.item():.4f}, Dominance: {dominance.item():.4f}")
+```
+
+## Citation
+
+If you use this model, please cite:
+
+```
+@misc{disaster-news-vad-model,
+  author = {postgrammar},
+  title = {Disaster News VAD Model},
+  year = {2024},
+  publisher = {Hugging Face},
+  howpublished = {\url{https://huggingface.co/postgrammar/disaster-news-vad-model}}
+}
+```

config.json

@@ -0,0 +1,84 @@
+{
+  "architectures": [
+    "RobertaForVADRegression"
+  ],
+  "model_type": "roberta",
+  "id2label": {
+    "0": "valence",
+    "1": "arousal",
+    "2": "dominance"
+  },
+  "label2id": {
+    "valence": 0,
+    "arousal": 1,
+    "dominance": 2
+  },
+  "problem_type": "regression",
+  "return_dict": true,
+  "output_hidden_states": false,
+  "output_attentions": false,
+  "torchscript": false,
+  "torch_dtype": "float32",
+  "use_bfloat16": false,
+  "tf_legacy_loss": false,
+  "pruned_heads": {},
+  "tie_word_embeddings": true,
+  "chunk_size_feed_forward": 0,
+  "is_encoder_decoder": false,
+  "is_decoder": false,
+  "cross_attention_hidden_size": null,
+  "add_cross_attention": false,
+  "tie_encoder_decoder": false,
+  "max_length": 20,
+  "min_length": 0,
+  "do_sample": false,
+  "early_stopping": false,
+  "num_beams": 1,
+  "num_beam_groups": 1,
+  "diversity_penalty": 0.0,
+  "temperature": 1.0,
+  "top_k": 50,
+  "top_p": 1.0,
+  "typical_p": 1.0,
+  "repetition_penalty": 1.0,
+  "length_penalty": 1.0,
+  "no_repeat_ngram_size": 0,
+  "encoder_no_repeat_ngram_size": 0,
+  "bad_words_ids": null,
+  "num_return_sequences": 1,
+  "output_scores": false,
+  "return_dict_in_generate": false,
+  "forced_bos_token_id": null,
+  "forced_eos_token_id": null,
+  "remove_invalid_values": false,
+  "exponential_decay_length_penalty": null,
+  "suppress_tokens": null,
+  "begin_suppress_tokens": null,
+  "finetuning_task": null,
+  "tokenizer_class": null,
+  "prefix": null,
+  "bos_token_id": 0,
+  "pad_token_id": 1,
+  "eos_token_id": 2,
+  "sep_token_id": null,
+  "decoder_start_token_id": null,
+  "task_specific_params": null,
+  "_name_or_path": "roberta-base",
+  "_attn_implementation_autoset": true,
+  "transformers_version": "4.49.0",
+  "vocab_size": 50265,
+  "hidden_size": 768,
+  "num_hidden_layers": 12,
+  "num_attention_heads": 12,
+  "hidden_act": "gelu",
+  "intermediate_size": 3072,
+  "hidden_dropout_prob": 0.1,
+  "attention_probs_dropout_prob": 0.1,
+  "max_position_embeddings": 514,
+  "type_vocab_size": 1,
+  "initializer_range": 0.02,
+  "layer_norm_eps": 1e-05,
+  "position_embedding_type": "absolute",
+  "use_cache": true,
+  "classifier_dropout": null
+}

metadata.json

@@ -0,0 +1,20 @@
+{
+  "language": "en",
+  "license": "mit",
+  "tags": [
+    "disaster",
+    "news",
+    "emotion",
+    "vad",
+    "valence",
+    "arousal",
+    "dominance",
+    "roberta"
+  ],
+  "datasets": [
+    "emobank"
+  ],
+  "metrics": [
+    "mse"
+  ]
+}

modeling_vad.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+VAD Transformer Model Definition
+
+This module defines the custom RoBERTa-based model for VAD prediction
+that will be uploaded to Hugging Face.
+
+Author: AI Assistant
+"""
+
+import torch
+from transformers import RobertaModel, RobertaPreTrainedModel
+
+class RobertaForVADRegression(RobertaPreTrainedModel):
+    """
+    RoBERTa model for predicting Valence, Arousal, and Dominance values.
+    This model extends RobertaPreTrainedModel to be compatible with the Hugging Face ecosystem.
+    """
+    
+    def __init__(self, config):
+        super().__init__(config)
+        self.roberta = RobertaModel(config)
+        self.dropout = torch.nn.Dropout(config.hidden_dropout_prob)
+        self.valence_head = torch.nn.Linear(config.hidden_size, 1)
+        self.arousal_head = torch.nn.Linear(config.hidden_size, 1)
+        self.dominance_head = torch.nn.Linear(config.hidden_size, 1)
+        
+        # Initialize weights
+        self.init_weights()
+    
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        """
+        Forward pass of the model.
+        
+        Returns:
+            tuple: Tuple containing valence, arousal, and dominance predictions
+            or
+            dict: Dictionary containing loss and predictions if labels are provided
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        
+        outputs = self.roberta(
+            input_ids=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,
+        )
+        
+        sequence_output = outputs[0]
+        pooled_output = sequence_output[:, 0, :]  # Take CLS token representation
+        pooled_output = self.dropout(pooled_output)
+        
+        valence = self.valence_head(pooled_output)
+        arousal = self.arousal_head(pooled_output)
+        dominance = self.dominance_head(pooled_output)
+        
+        loss = None
+        if labels is not None:
+            # If labels are provided, calculate loss
+            # Assuming labels is a tensor of shape [batch_size, 3] with VAD values
+            loss_fct = torch.nn.MSELoss()
+            v_loss = loss_fct(valence.squeeze(), labels[:, 0])
+            a_loss = loss_fct(arousal.squeeze(), labels[:, 1])
+            d_loss = loss_fct(dominance.squeeze(), labels[:, 2])
+            loss = v_loss + a_loss + d_loss
+        
+        if not return_dict:
+            output = (valence.squeeze(), arousal.squeeze(), dominance.squeeze()) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+        
+        return {
+            "loss": loss,
+            "valence": valence.squeeze(),
+            "arousal": arousal.squeeze(),
+            "dominance": dominance.squeeze(),
+            "hidden_states": outputs.hidden_states,
+            "attentions": outputs.attentions,
+        } 

pytorch_model.bin

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

special_tokens_map.json

@@ -0,0 +1,51 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<mask>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer_config.json

@@ -0,0 +1,57 @@
+{
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "50264": {
+      "content": "<mask>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "mask_token": "<mask>",
+  "model_max_length": 512,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "tokenizer_class": "RobertaTokenizer",
+  "unk_token": "<unk>"
+}