Upload MM_LLMs

README.md

@@ -0,0 +1,201 @@
+---
+library_name: transformers
+tags: []
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure 
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+
+

config.json

@@ -0,0 +1,306 @@
+{
+  "_name_or_path": "vision-tinyllama-siglip-large/checkpoint-5900",
+  "architectures": [
+    "MM_LLMs"
+  ],
+  "auto_map": {
+    "AutoConfig": "modeling_vision.MM_LLMs_Config",
+    "AutoModel": "modeling_vision.MM_LLMs"
+  },
+  "image_config": {
+    "_name_or_path": "google/siglip-large-patch16-384",
+    "add_cross_attention": false,
+    "architectures": [
+      "SiglipModel"
+    ],
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": null,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": null,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_factor": 1.0,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "min_length": 0,
+    "model_type": "siglip",
+    "no_repeat_ngram_size": 0,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": null,
+    "prefix": null,
+    "problem_type": null,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "sep_token_id": null,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "text_config": {
+      "_name_or_path": "",
+      "add_cross_attention": false,
+      "architectures": null,
+      "attention_dropout": 0.0,
+      "bad_words_ids": null,
+      "begin_suppress_tokens": null,
+      "bos_token_id": 49406,
+      "chunk_size_feed_forward": 0,
+      "cross_attention_hidden_size": null,
+      "decoder_start_token_id": null,
+      "diversity_penalty": 0.0,
+      "do_sample": false,
+      "early_stopping": false,
+      "encoder_no_repeat_ngram_size": 0,
+      "eos_token_id": 49407,
+      "exponential_decay_length_penalty": null,
+      "finetuning_task": null,
+      "forced_bos_token_id": null,
+      "forced_eos_token_id": null,
+      "hidden_act": "gelu_pytorch_tanh",
+      "hidden_size": 1024,
+      "id2label": {
+        "0": "LABEL_0",
+        "1": "LABEL_1"
+      },
+      "intermediate_size": 4096,
+      "is_decoder": false,
+      "is_encoder_decoder": false,
+      "label2id": {
+        "LABEL_0": 0,
+        "LABEL_1": 1
+      },
+      "layer_norm_eps": 1e-06,
+      "length_penalty": 1.0,
+      "max_length": 20,
+      "max_position_embeddings": 64,
+      "min_length": 0,
+      "model_type": "siglip_text_model",
+      "no_repeat_ngram_size": 0,
+      "num_attention_heads": 16,
+      "num_beam_groups": 1,
+      "num_beams": 1,
+      "num_hidden_layers": 24,
+      "num_return_sequences": 1,
+      "output_attentions": false,
+      "output_hidden_states": false,
+      "output_scores": false,
+      "pad_token_id": 1,
+      "prefix": null,
+      "problem_type": null,
+      "pruned_heads": {},
+      "remove_invalid_values": false,
+      "repetition_penalty": 1.0,
+      "return_dict": true,
+      "return_dict_in_generate": false,
+      "sep_token_id": null,
+      "suppress_tokens": null,
+      "task_specific_params": null,
+      "temperature": 1.0,
+      "tf_legacy_loss": false,
+      "tie_encoder_decoder": false,
+      "tie_word_embeddings": true,
+      "tokenizer_class": null,
+      "top_k": 50,
+      "top_p": 1.0,
+      "torch_dtype": null,
+      "torchscript": false,
+      "typical_p": 1.0,
+      "use_bfloat16": false,
+      "vocab_size": 32000
+    },
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": "float32",
+    "torchscript": false,
+    "typical_p": 1.0,
+    "use_bfloat16": false,
+    "vision_config": {
+      "_name_or_path": "",
+      "add_cross_attention": false,
+      "architectures": null,
+      "attention_dropout": 0.0,
+      "bad_words_ids": null,
+      "begin_suppress_tokens": null,
+      "bos_token_id": null,
+      "chunk_size_feed_forward": 0,
+      "cross_attention_hidden_size": null,
+      "decoder_start_token_id": null,
+      "diversity_penalty": 0.0,
+      "do_sample": false,
+      "early_stopping": false,
+      "encoder_no_repeat_ngram_size": 0,
+      "eos_token_id": null,
+      "exponential_decay_length_penalty": null,
+      "finetuning_task": null,
+      "forced_bos_token_id": null,
+      "forced_eos_token_id": null,
+      "hidden_act": "gelu_pytorch_tanh",
+      "hidden_size": 1024,
+      "id2label": {
+        "0": "LABEL_0",
+        "1": "LABEL_1"
+      },
+      "image_size": 384,
+      "intermediate_size": 4096,
+      "is_decoder": false,
+      "is_encoder_decoder": false,
+      "label2id": {
+        "LABEL_0": 0,
+        "LABEL_1": 1
+      },
+      "layer_norm_eps": 1e-06,
+      "length_penalty": 1.0,
+      "max_length": 20,
+      "min_length": 0,
+      "model_type": "siglip_vision_model",
+      "no_repeat_ngram_size": 0,
+      "num_attention_heads": 16,
+      "num_beam_groups": 1,
+      "num_beams": 1,
+      "num_channels": 3,
+      "num_hidden_layers": 24,
+      "num_return_sequences": 1,
+      "output_attentions": false,
+      "output_hidden_states": false,
+      "output_scores": false,
+      "pad_token_id": null,
+      "patch_size": 16,
+      "prefix": null,
+      "problem_type": null,
+      "pruned_heads": {},
+      "remove_invalid_values": false,
+      "repetition_penalty": 1.0,
+      "return_dict": true,
+      "return_dict_in_generate": false,
+      "sep_token_id": null,
+      "suppress_tokens": null,
+      "task_specific_params": null,
+      "temperature": 1.0,
+      "tf_legacy_loss": false,
+      "tie_encoder_decoder": false,
+      "tie_word_embeddings": true,
+      "tokenizer_class": null,
+      "top_k": 50,
+      "top_p": 1.0,
+      "torch_dtype": null,
+      "torchscript": false,
+      "typical_p": 1.0,
+      "use_bfloat16": false
+    }
+  },
+  "llm_config": {
+    "_name_or_path": "mesolitica/malaysian-tinyllama-1.1b-16k-instructions-v3",
+    "add_cross_attention": false,
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": 1,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "early_stopping": false,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": 2,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "hidden_act": "silu",
+    "hidden_size": 2048,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "intermediate_size": 5632,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "max_position_embeddings": 32768,
+    "min_length": 0,
+    "model_type": "llama",
+    "no_repeat_ngram_size": 0,
+    "num_attention_heads": 32,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_hidden_layers": 22,
+    "num_key_value_heads": 4,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": null,
+    "prefix": null,
+    "pretraining_tp": 1,
+    "problem_type": null,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "repetition_penalty": 1.0,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "rms_norm_eps": 1e-05,
+    "rope_scaling": null,
+    "rope_theta": 10000.0,
+    "sep_token_id": null,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": false,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": "bfloat16",
+    "torchscript": false,
+    "typical_p": 1.0,
+    "use_bfloat16": false,
+    "use_cache": true,
+    "vocab_size": 32004
+  },
+  "model_type": "mm_llms",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.37.2",
+  "vision_select_layer": -2
+}

generation_config.json

@@ -0,0 +1,4 @@
+{
+  "_from_model_config": true,
+  "transformers_version": "4.37.2"
+}

model.safetensors

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

modeling_vision.py

@@ -0,0 +1,255 @@
+from collections import Counter, defaultdict
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+from torch import nn
+from torch.nn import CrossEntropyLoss
+import copy
+import math
+from transformers.activations import gelu
+from typing import List, Optional, Tuple, Union
+from transformers.modeling_utils import PreTrainedModel, PretrainedConfig
+from transformers import CONFIG_MAPPING
+from transformers.modeling_outputs import BaseModelOutput
+from transformers import GenerationConfig
+from transformers import CLIPConfig, CLIPProcessor, CLIPModel, AutoModel
+from transformers import WhisperConfig, WhisperPreTrainedModel, WhisperModel
+from transformers import AutoConfig, AutoModelForCausalLM, LlamaConfig
+
+
+def most_frequent_element(tensor):
+    flattened_list = tensor.flatten().tolist()
+    counter = Counter(flattened_list)
+    most_common_element = counter.most_common(1)[0][1]
+
+    return most_common_element
+
+
+class MM_LLMs_Config(PretrainedConfig):
+    model_type = 'mm_llms'
+    is_composition = True
+
+    def __init__(
+        self,
+        image_config=None,
+        llm_config=None,
+        vision_select_layer=None,
+        **kwargs
+    ):
+
+        self.image_config = image_config
+        self.llm_config = llm_config
+        self.vision_select_layer = vision_select_layer
+
+        if isinstance(self.image_config, dict):
+            image_config["model_type"] = (
+                image_config["model_type"] if "model_type" in image_config else "clip"
+            )
+            self.image_config = CONFIG_MAPPING[image_config["model_type"]](**image_config)
+
+        if isinstance(self.llm_config, dict):
+            llm_config["model_type"] = llm_config["model_type"] if "model_type" in llm_config else "llama"
+            self.llm_config = CONFIG_MAPPING[llm_config["model_type"]](**llm_config)
+
+        super().__init__(**kwargs)
+
+
+class LlavaMultiModalProjector(nn.Module):
+    def __init__(self, in_hidden_size, out_hidden_size, conv_kernel=None, conv_stride=3):
+        super().__init__()
+
+        self.conv_kernel = conv_kernel
+
+        if conv_kernel:
+            self.linear_1 = nn.Conv1d(
+                in_hidden_size,
+                out_hidden_size,
+                kernel_size=conv_kernel,
+                stride=conv_stride)
+        else:
+            self.linear_1 = nn.Linear(
+                in_hidden_size,
+                out_hidden_size,
+                bias=True,
+            )
+        self.act = gelu
+        self.linear_2 = nn.Linear(
+            out_hidden_size,
+            out_hidden_size,
+            bias=True
+        )
+
+    def forward(self, image_features):
+        hidden_states = self.linear_1(image_features)
+        if self.conv_kernel:
+            hidden_states = hidden_states.transpose(1, 2).contiguous()
+        hidden_states = self.act(hidden_states)
+        hidden_states = self.linear_2(hidden_states)
+        return hidden_states
+
+
+class MM_LLMs(PreTrainedModel):
+    config_class = MM_LLMs_Config
+    supports_gradient_checkpointing = True
+    _supports_flash_attn_2 = True
+
+    def __init__(self, config, flash_attention=False, dtype=torch.float32):
+        super().__init__(config)
+        self.config = config
+
+        self.image_encoder = AutoModel.from_config(config.image_config)
+
+        self.llm = AutoModelForCausalLM.from_config(
+            config.llm_config,
+            use_flash_attention_2=flash_attention,
+            torch_dtype=dtype,
+        )
+
+        self.image_projector = LlavaMultiModalProjector(
+            config.image_config.vision_config.hidden_size,
+            config.llm_config.hidden_size
+        )
+
+    def forward(self,
+                input_ids: torch.LongTensor = None,
+                image_index: torch.LongTensor = None,
+                audio_index: torch.LongTensor = None,
+                image_starts: torch.int = None,
+                image_ends: torch.int = None,
+                audio_starts: torch.int = None,
+                audio_ends: torch.int = None,
+                images: torch.FloatTensor = None,
+                audios: torch.FloatTensor = None,
+                attention_mask: Optional[torch.Tensor] = None,
+                position_ids: Optional[torch.LongTensor] = None,
+                past_key_values: Optional[List[torch.FloatTensor]] = None,
+                inputs_embeds: Optional[torch.FloatTensor] = None,
+                labels: Optional[torch.LongTensor] = None,
+                output_attentions: Optional[bool] = None,
+                output_hidden_states: Optional[bool] = None,
+                use_cache: Optional[bool] = None,
+                return_dict: Optional[bool] = None, **kwargs):
+
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        images = images.type(self.image_encoder.dtype) if images is not None else None
+        audios = audios.type(self.audio_encoder.dtype) if audios is not None else None
+
+        model_inputs = self.prepare_inputs_for_generation(
+            input_ids=input_ids,
+            image_index=image_index,
+            audio_index=audio_index,
+            image_starts=image_starts,
+            image_ends=image_ends,
+            audio_starts=audio_starts,
+            audio_ends=audio_ends,
+            images=images,
+            audios=audios,
+            attention_mask=attention_mask,
+            labels=labels)
+
+        outputs = self.llm(
+            inputs_embeds=model_inputs['inputs_embeds'],
+            attention_mask=model_inputs['attention_mask'],
+            labels=model_inputs['labels'],
+            return_dict=return_dict)
+
+        return outputs
+
+    def prepare_inputs_for_generation(
+            self,
+            input_ids,
+            past_key_values=None,
+            inputs_embeds=None,
+            images=None,
+            audios=None,
+            audio_starts=None,
+            audio_ends=None,
+            image_starts=None,
+            image_ends=None,
+            attention_mask=None,
+            labels=None,
+            audio_index=None,
+            image_index=None,
+            **kwargs):
+
+        image_features = self.encode_image(
+            images) if images is not None else None
+        embed_tokens = self.llm.model.embed_tokens
+        text_embeddings = embed_tokens(input_ids)
+        batch_size = text_embeddings.shape[0]
+        seq_len = text_embeddings.shape[1]
+        embed_dim = text_embeddings.shape[2]
+
+        max_count_image = most_frequent_element(image_index)
+        seq_image = image_features.shape[1]
+
+        new_len = text_embeddings.shape[1] + seq_image * max_count_image
+        final_embedding = torch.zeros(
+            batch_size, new_len, embed_dim,
+            device=text_embeddings.device,
+            dtype=text_embeddings.dtype
+        )
+        final_embedding[:, :seq_len] = text_embeddings
+        final_attention_mask = torch.zeros(
+            batch_size, new_len,
+            device=attention_mask.device,
+            dtype=attention_mask.dtype
+        )
+        final_attention_mask[:, :seq_len] = attention_mask
+        if labels is not None:
+            final_labels = torch.full(
+                (batch_size, new_len),
+                -100,
+                device=labels.device,
+                dtype=labels.dtype
+            )
+            final_labels[:, :seq_len] = labels
+        else:
+            final_labels = None
+
+        image_id = int(image_starts[0])
+
+        where_is = torch.where(input_ids == image_id)
+        positions = defaultdict(int)
+        b_image = 0
+
+        for i in range(len(where_is[0])):
+            b, k = where_is[0][i], where_is[1][i]
+            int_b = int(b)
+            int_k = int(k)
+            l = int(input_ids[b, k])
+            f = image_features[b_image]
+            b_image += 1
+
+            c = torch.cat([final_embedding[b, :int_k + 1 + positions[int_b]],
+                          f, text_embeddings[b, k + 1:]])
+            final_embedding[b, :len(c)] = c
+            final_attention_mask[b, :len(c)] = 1.0
+
+            if labels is not None:
+                ignore = torch.tensor([-100] * len(f), device=labels.device)
+                c_label = torch.cat(
+                    [final_labels[b, :int_k + 1 + positions[int_b]], ignore, labels[b, k + 1:]])
+                final_labels[b, :len(c)] = c_label
+
+            positions[int_b] += len(f)
+
+        model_inputs = {
+            "input_ids": input_ids,
+            "inputs_embeds": final_embedding,
+            "use_cache": kwargs.get("use_cache"),
+            "attention_mask": final_attention_mask,
+            "labels": final_labels,
+        }
+        return model_inputs
+
+    def encode_image(self, images):
+        if self.config.vision_select_layer is not None:
+            encoded = self.image_encoder.vision_model(images, output_hidden_states=True)
+            encoded = encoded.hidden_states[self.config.vision_select_layer]
+        else:
+            encoded = self.image_encoder.vision_model(images)[0]
+        image_features = self.image_projector(encoded)
+        return image_features