ai-edge-torch-nightly 0.3.0.dev20241114__py3-none-any.whl → 0.3.0.dev20241116__py3-none-any.whl

ai_edge_torch/generative/examples/paligemma/decoder.py

@@ -15,9 +15,11 @@
 
 """Example of building a decoder of PaliGemma 3B model which is Gemma1."""
 
+from ai_edge_torch.generative.layers import kv_cache as kv_utils
 import ai_edge_torch.generative.layers.model_config as cfg
 from ai_edge_torch.generative.utilities import model_builder
 import ai_edge_torch.generative.utilities.loader as loading_utils
+import torch
 
 TENSOR_NAMES = loading_utils.ModelLoader.TensorNames(
     ff_up_proj="language_model.model.layers.{}.mlp.up_proj",
@@ -35,6 +37,41 @@ TENSOR_NAMES = loading_utils.ModelLoader.TensorNames(
 )
 
 
+class Decoder(model_builder.DecoderOnlyModel):
+  """A decoder of PaliGemma 3B model which is Gemma1.
+
+  Besides a tensor of text token IDs, forward() can also take a tensor of
+  embeddings which may include text or image or both.
+  """
+
+  @torch.inference_mode
+  def forward(
+      self,
+      tokens: torch.Tensor,
+      input_pos: torch.Tensor,
+      kv_cache: kv_utils.KVCache,
+      input_embeds: torch.Tensor = None,
+  ) -> dict[torch.Tensor, kv_utils.KVCache]:
+    if input_embeds is None:
+      return super().forward(tokens, input_pos, kv_cache)
+
+    assert input_embeds is not None
+
+    repo_pos = input_pos + 1  # PaliGemma position is 1-based.
+    cos, sin = self.rope_cache
+    rope = (cos.index_select(0, repo_pos), sin.index_select(0, repo_pos))
+
+    # The first part of input_embeds are image embeddings. Diagonal causal mask
+    # doesn't work here.
+    embeds_len = input_embeds.shape[1]
+    mask = torch.zeros(embeds_len, self.config.kv_cache_max)
+    mask[:, embeds_len:] = float("-inf")
+
+    return self.forward_with_embeds(
+        input_embeds, rope, mask, input_pos, kv_cache
+    )
+
+
 def get_decoder_config(kv_cache_max_len: int = 1024) -> cfg.ModelConfig:
   """Returns the model config for the decoder of a PaliGemma 3B model.
 
@@ -96,8 +133,9 @@ def get_fake_decoder_config(kv_cache_max_len: int = 128) -> cfg.ModelConfig:
 def build_decoder(
     checkpoint_path: str, **kwargs
 ) -> model_builder.DecoderOnlyModel:
-  return model_builder.build_decoder_only_model(
-      checkpoint_path=checkpoint_path,
-      config=get_decoder_config(**kwargs),
-      tensor_names=TENSOR_NAMES,
-  )
+  decoder = Decoder(get_decoder_config(**kwargs))
+  loader = loading_utils.ModelLoader(checkpoint_path, TENSOR_NAMES)
+  # Loose the strictness because only decoder is being loaded.
+  loader.load(decoder, strict=False)
+  decoder.eval()
+  return decoder

ai_edge_torch/generative/examples/paligemma/paligemma.py

@@ -0,0 +1,135 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# 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.
+# ==============================================================================
+
+"""Example of building a full-stack of PaliGemma model."""
+
+from dataclasses import dataclass
+
+from ai_edge_torch.generative.examples.paligemma import decoder
+from ai_edge_torch.generative.examples.paligemma import image_encoder
+import ai_edge_torch.generative.layers.kv_cache as kv_utils
+import ai_edge_torch.generative.layers.model_config as cfg
+import ai_edge_torch.generative.utilities.loader as loading_utils
+import torch
+from torch import nn
+
+PROJECTION_TENSOR_NAME = "multi_modal_projector.linear"
+
+
+@dataclass
+class PaliGemmaConfig:
+  """PaliGemma model configurations."""
+
+  image_encoder_config: cfg.ModelConfig
+  decoder_config: cfg.ModelConfig
+
+  image_token_id: int
+  image_projection_use_bias: bool = False
+
+
+class PaliGemma(nn.Module):
+  """PaliGemma model from the Edge Generative API."""
+
+  def __init__(self, config: PaliGemmaConfig):
+    super().__init__()
+
+    self.image_encoder = image_encoder.SiglipVisionEncoder(
+        config.image_encoder_config
+    )
+    self.image_projection = nn.Linear(
+        config.image_encoder_config.embedding_dim,
+        config.decoder_config.embedding_dim,
+        bias=config.image_projection_use_bias,
+    )
+    self.decoder = decoder.Decoder(config.decoder_config)
+    self.config = config
+
+  @torch.inference_mode
+  def forward(
+      self,
+      tokens: torch.Tensor,
+      input_pos: torch.Tensor,
+      kv_cache: kv_utils.KVCache,
+      pixel_values: torch.Tensor = None,
+  ) -> dict[torch.Tensor, kv_utils.KVCache]:
+    if pixel_values is None:
+      return self.decoder(tokens, input_pos, kv_cache)
+
+    input_embeds = self.decoder.tok_embedding(tokens)
+
+    image_encoded = self.image_encoder(pixel_values=pixel_values)
+    image_embeds = self.image_projection(image_encoded)
+    if self.config.decoder_config.embedding_scale is not None:
+      image_embeds = image_embeds / self.config.decoder_config.embedding_scale
+
+    # Merge image_embeds into text_embeds as PaliGemmaForConditionalGeneration.
+    image_mask = tokens == self.config.image_token_id
+    image_mask = image_mask.unsqueeze(-1).expand_as(input_embeds)
+    input_embeds = input_embeds.masked_scatter(image_mask, image_embeds)
+
+    return self.decoder(
+        tokens=None,
+        input_pos=input_pos,
+        kv_cache=kv_cache,
+        input_embeds=input_embeds,
+    )
+
+
+def get_model_config() -> PaliGemmaConfig:
+  """Returns the model config for a PaliGemma 3B-224 model.
+
+  Returns:
+    The model config for a PaliGemma 3B model.
+  """
+  return PaliGemmaConfig(
+      image_encoder_config=image_encoder.get_image_encoder_config(),
+      decoder_config=decoder.get_decoder_config(),
+      image_projection_use_bias=True,
+      image_token_id=257152,
+  )
+
+
+def get_fake_image_encoder_config() -> PaliGemmaConfig:
+  return PaliGemmaConfig(
+      image_encoder_config=image_encoder.get_fake_image_encoder_config(),
+      decoder_config=decoder.get_fake_decoder_config(),
+      image_projection_use_bias=True,
+      image_token_id=257152,
+  )
+
+
+def build_model(checkpoint_path: str) -> PaliGemma:
+  config = get_model_config()
+  model = PaliGemma(config)
+  # Load the parameters of image encoder.
+  loader = loading_utils.ModelLoader(
+      checkpoint_path, image_encoder.TENSOR_NAMES
+  )
+  loader.load(model.image_encoder, strict=False)
+  # Load the parameters of decoder.
+  loader = loading_utils.ModelLoader(checkpoint_path, decoder.TENSOR_NAMES)
+  loader.load(model.decoder, strict=False)
+
+  # Load the parameters of image projection.
+  loader = loading_utils.ModelLoader(checkpoint_path, None)
+  state = loader.get_state()
+  converted_state = dict()
+  converted_state["weight"] = state.pop(f"{PROJECTION_TENSOR_NAME}.weight")
+  if config.image_projection_use_bias:
+    converted_state["bias"] = state.pop(f"{PROJECTION_TENSOR_NAME}.bias")
+  model.image_projection.load_state_dict(converted_state)
+
+  model.eval()
+  return model

ai_edge_torch/generative/examples/paligemma/verify.py

@@ -0,0 +1,134 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# 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.
+# ==============================================================================
+
+"""Verifies the reauthored PaliGemma 3B model."""
+
+import logging
+import pathlib
+from absl import app
+from absl import flags
+from ai_edge_torch.generative.examples.paligemma import paligemma
+from ai_edge_torch.generative.layers import kv_cache
+from ai_edge_torch.generative.utilities import verifier
+from PIL import Image
+import requests
+import torch
+import transformers
+
+_IMAGE_URL = flags.DEFINE_string(
+    "image_url",
+    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true",
+    "The image URI to encode.",
+)
+_PROMPTS = flags.DEFINE_string(
+    "prompts",
+    "Caption en",
+    "The input prompts to generate answers.",
+)
+_MAX_NEW_TOKENS = flags.DEFINE_integer(
+    "max_new_tokens",
+    30,
+    "The maximum size of the generated tokens.",
+)
+
+
+class ReauthoredPaliGemmaWrapper(verifier.ReauthoredModelWrapper):
+  """Reauthored PaliGemma model wrapper."""
+
+  def _init_kv_cache(self):
+    return kv_cache.KVCache.from_model_config(self.model.config.decoder_config)
+
+
+def main(_):
+  checkpoint = "google/paligemma-3b-mix-224"
+  logging.info("Loading the original model from: %s", checkpoint)
+  original_model = (
+      transformers.PaliGemmaForConditionalGeneration.from_pretrained(checkpoint)
+  )
+
+  # Locate the cached dir.
+  cached_config_file = transformers.utils.cached_file(
+      checkpoint, transformers.utils.CONFIG_NAME
+  )
+  reauthored_checkpoint = pathlib.Path(cached_config_file).parent
+  logging.info("Building the reauthored model from: %s", reauthored_checkpoint)
+  reauthored_model = paligemma.build_model(reauthored_checkpoint)
+
+  logging.info("Loading the processor from: %s", checkpoint)
+  # It works only when GemmaTokenizerFast is available. In some environments,
+  # use_fast=False doeesn't work either if the tokenizer cannot load the
+  # sentencepiece model file properly.
+  processor = transformers.AutoProcessor.from_pretrained(checkpoint)
+
+  logging.info("Loading the image from: %s", _IMAGE_URL.value)
+  image = Image.open(requests.get(_IMAGE_URL.value, stream=True).raw)
+  inputs = processor(text=_PROMPTS.value, images=image, return_tensors="pt")
+
+  logging.info("Verifying the reauthored model with model.forward()...")
+  logging.info("Forwarding the original model...")
+  outputs_original = original_model.forward(
+      input_ids=inputs["input_ids"], pixel_values=inputs["pixel_values"]
+  )
+  outputs_original = outputs_original.logits
+  logging.info("outputs_original: %s", outputs_original)
+
+  logging.info("Forwarding the reauthored model...")
+  wrapped_reauthored_model = ReauthoredPaliGemmaWrapper(reauthored_model)
+  outputs_reauthored = wrapped_reauthored_model.forward(
+      tokens=inputs["input_ids"],
+      pixel_values=inputs["pixel_values"],
+  )
+  logging.info("outputs_reauthored: %s", outputs_reauthored)
+
+  try:
+    assert torch.allclose(outputs_original, outputs_reauthored, atol=1e-03)
+  except AssertionError as e:
+    logging.error("*** FAILED *** verify with forward()")
+    raise e
+  else:
+    logging.info("*** PASSED *** verify with forward()")
+
+  logging.info("Verifying the reauthored model with model.generate()...")
+  logging.info("Generating answer with the original model...")
+  outputs_original = original_model.generate(
+      **inputs, max_new_tokens=_MAX_NEW_TOKENS.value, do_sample=False
+  )
+  response_original = processor.decode(
+      outputs_original[0], skip_special_tokens=True
+  )
+  logging.info("outputs_from_original_model: [[%s]]", response_original)
+
+  logging.info("Generating answer with the reauthored model...")
+  outputs_reauthored = wrapped_reauthored_model.generate(
+      prompts=inputs["input_ids"],
+      pixel_values=inputs["pixel_values"],
+      max_new_tokens=_MAX_NEW_TOKENS.value,
+  )
+  response_reauthored = processor.decode(
+      outputs_reauthored[0], skip_special_tokens=True
+  )
+  logging.info("outputs from reauthored model: [[%s]]", response_reauthored)
+
+  try:
+    assert response_original == response_reauthored
+  except AssertionError as e:
+    logging.error("*** FAILED *** verify with generate()")
+    raise e
+  else:
+    logging.info("*** PASSED *** verify with generate()")
+
+
+if __name__ == "__main__":
+  app.run(main)

ai_edge_torch/generative/utilities/loader.py

@@ -131,6 +131,9 @@ class ModelLoader:
     self._names = names
     self._loader = self._get_loader()
 
+  def get_state(self) -> Dict[str, torch.Tensor]:
+    return self._loader(self._file_name)
+
   def load(
       self, model: torch.nn.Module, strict: bool = True
   ) -> Tuple[List[str], List[str]]:
@@ -150,7 +153,7 @@ class ModelLoader:
         ValueError: If conversion results in unmapped tensors and strict mode is
           enabled.
     """
-    state = self._loader(self._file_name)
+    state = self.get_state()
     state = state["model_state_dict"] if "model_state_dict" in state else state
     converted_state = dict()
     if self._names.embedding is not None:

ai_edge_torch/generative/utilities/model_builder.py

@@ -16,6 +16,7 @@
 """Utilities to be used for re-authoring transformer models."""
 
 import copy
+from typing import Tuple
 
 from ai_edge_torch.generative.layers import attention
 from ai_edge_torch.generative.layers import builder
@@ -98,26 +99,40 @@ class DecoderOnlyModel(nn.Module):
         f"Cannot forward sequence of length {seq_len}, max seq length is only"
         f" {self.config.max_seq_len}"
     )
-    assert len(self.transformer_blocks) == len(kv_cache.caches), (
-        "The number of transformer blocks and the number of KV cache entries"
-        " must be the same."
-    )
 
+    # token embeddings of shape (b, t, n_embd)
+    input_embeds = self.tok_embedding(tokens)
     cos, sin = self.rope_cache
-    cos = cos.index_select(0, input_pos)
-    sin = sin.index_select(0, input_pos)
+    rope = (cos.index_select(0, input_pos), sin.index_select(0, input_pos))
     mask = self.mask_cache.index_select(2, input_pos)
     mask = mask[:, :, :, : self.config.kv_cache_max]
 
-    # token embeddings of shape (b, t, n_embd)
-    x = self.tok_embedding(tokens)
+    return self.forward_with_embeds(
+        input_embeds, rope, mask, input_pos, kv_cache
+    )
+
+  def forward_with_embeds(
+      self,
+      input_embeds: torch.Tensor,
+      rope: Tuple[torch.Tensor, torch.Tensor],
+      mask: torch.Tensor,
+      input_pos: torch.Tensor,
+      kv_cache: kv_utils.KVCache,
+  ) -> dict[torch.Tensor, kv_utils.KVCache]:
+    """Forwards the model with input embeddings."""
+    assert len(self.transformer_blocks) == len(kv_cache.caches), (
+        "The number of transformer blocks and the number of KV cache entries"
+        " must be the same."
+    )
+
+    x = input_embeds
     if self.config.embedding_scale is not None:
       x = x * self.config.embedding_scale
 
     updated_kv_entires = []
     for i, block in enumerate(self.transformer_blocks):
       kv_entry = kv_cache.caches[i] if kv_cache else None
-      x, kv_entry = block(x, (cos, sin), mask, input_pos, kv_entry)
+      x, kv_entry = block(x, rope, mask, input_pos, kv_entry)
       if kv_entry:
         updated_kv_entires.append(kv_entry)
     updated_kv_cache = kv_utils.KVCache(tuple(updated_kv_entires))

ai_edge_torch/generative/utilities/verifier.py

@@ -41,7 +41,9 @@ class ModelWrapper(torch.nn.Module):
     super().__init__()
     self.model = model
 
-  def forward(self, tokens: torch.Tensor) -> torch.Tensor:
+  def forward(
+      self, tokens: torch.Tensor, pixel_values: torch.Tensor = None
+  ) -> torch.Tensor:
     """Gets output logits by forwarding the input tokens.
 
     Args:
@@ -54,7 +56,10 @@ class ModelWrapper(torch.nn.Module):
     raise NotImplementedError("forward() is not implemented.")
 
   def generate(
-      self, prompts: torch.Tensor, max_new_tokens: int
+      self,
+      prompts: torch.Tensor,
+      max_new_tokens: int,
+      pixel_values: torch.Tensor = None,
   ) -> torch.IntTensor:
     """Returns the response token IDs to the given prompts tensor.
 
@@ -83,35 +88,59 @@ class ReauthoredModelWrapper(ModelWrapper):
   def _forward_with_kv_cache(
       self,
       tokens: torch.Tensor,
+      input_pos: torch.Tensor,
       kv_cache: kv_utils.KVCache,
+      pixel_values: torch.Tensor,
   ) -> tuple[torch.Tensor, kv_utils.KVCache]:
     """Forwards the model and updates an external KV cache.
 
     Args:
       tokens (torch.Tensor): The input tokens to forward.
+      input_pos (torch.Tensor): The input positions to forward.
       kv_cache (KVCache): The KV cache to forward.
+      pixel_values (torch.Tensor): The input pixel values to forward.
 
     Returns:
       The output logits and the updated KV cache.
     """
-    input_pos = torch.arange(0, tokens.shape[1], dtype=torch.int)
-    output = self.model.forward(tokens, input_pos, kv_cache)
+    # Since the reauthored model doesn't include keyword arguments, pass
+    # pixel_values only when it is not None. Otherwise, it may raise an error.
+    if pixel_values is None:
+      output = self.model.forward(tokens, input_pos, kv_cache)
+    else:
+      output = self.model.forward(
+          tokens, input_pos, kv_cache, pixel_values=pixel_values
+      )
     return output["logits"], output["kv_cache"]
 
-  def forward(self, tokens: torch.Tensor) -> torch.Tensor:
-    logits, _ = self._forward_with_kv_cache(tokens, self._init_kv_cache())
+  def forward(
+      self, tokens: torch.Tensor, pixel_values: torch.Tensor = None
+  ) -> torch.Tensor:
+    input_pos = torch.arange(0, tokens.shape[1], dtype=torch.int)
+    logits, _ = self._forward_with_kv_cache(
+        tokens, input_pos, self._init_kv_cache(), pixel_values
+    )
     return logits
 
   def generate(
-      self, prompts: torch.Tensor, max_new_tokens: int
+      self,
+      prompts: torch.Tensor,
+      max_new_tokens: int,
+      pixel_values: torch.Tensor = None,
   ) -> torch.IntTensor:
     input_ids = prompts[0].int().tolist()
+    tokens = torch.tensor([input_ids])
+    input_pos = torch.arange(0, tokens.shape[1], dtype=torch.int)
     kv_cache = self._init_kv_cache()
     for _ in range(max_new_tokens):
-      tokens = torch.tensor([input_ids])
-      logits, kv_cache = self._forward_with_kv_cache(tokens, kv_cache)
+      logits, kv_cache = self._forward_with_kv_cache(
+          tokens, input_pos, kv_cache, pixel_values
+      )
       generated_token = logits[0][-1].argmax().item()
       input_ids.append(generated_token)
+      tokens = torch.tensor([[generated_token]])
+      input_pos = torch.tensor([len(input_ids) - 1])
+      pixel_values = None  # Pass only for the first time.
     return torch.tensor([input_ids])
 
 

ai_edge_torch/version.py

@@ -13,4 +13,4 @@
 # limitations under the License.
 # ==============================================================================
 
-__version__ = "0.3.0.dev20241114"
+__version__ = "0.3.0.dev20241116"

{ai_edge_torch_nightly-0.3.0.dev20241114.dist-info → ai_edge_torch_nightly-0.3.0.dev20241116.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ai-edge-torch-nightly
-Version: 0.3.0.dev20241114
+Version: 0.3.0.dev20241116
 Summary: Supporting PyTorch models with the Google AI Edge TFLite runtime.
 Home-page: https://github.com/google-ai-edge/ai-edge-torch
 Keywords: On-Device ML,AI,Google,TFLite,PyTorch,LLMs,GenAI

{ai_edge_torch_nightly-0.3.0.dev20241114.dist-info → ai_edge_torch_nightly-0.3.0.dev20241116.dist-info}/RECORD

@@ -3,7 +3,7 @@ ai_edge_torch/config.py,sha256=FMWeCH2b7HYILBvaI1iZNnYCO4WAhDOwBZBmIE-xrF0,909
 ai_edge_torch/conftest.py,sha256=r0GTrhMRhlmOGrrkvumHN8hkmyug6WvF60vWq8wRIBI,758
 ai_edge_torch/fx_pass_base.py,sha256=518ziQ0TUxqum2qZXqlD8qr65pHPh8ZNLnwFC6zvK3k,4253
 ai_edge_torch/model.py,sha256=N-pNpTxzhaFGhWhnSGd70lBzb9VlEhTOq5mddU7bvvI,5542
-ai_edge_torch/version.py,sha256=kPX3PxeMGiRGAaIsITYzfPxu3_FKKLg91pGrqXOP6OY,706
+ai_edge_torch/version.py,sha256=VA2R7z515pfD79tg2AjlwXASYb6LSz0-kch5NJzdj3k,706
 ai_edge_torch/_convert/__init__.py,sha256=hHLluseD2R0Hh4W6XZRIXY_dRQeYudjsrKGf6LZz65g,671
 ai_edge_torch/_convert/conversion.py,sha256=HwzfRx_DX5TLtPqwEH1_NOm38_INvHzHl4_mX67KOdQ,5448
 ai_edge_torch/_convert/conversion_utils.py,sha256=Sr8qXVcTwc-ZnZmK7yxVrIOOp1S_vNrwzC0zUvLTI2o,2160
@@ -61,8 +61,10 @@ ai_edge_torch/generative/examples/openelm/convert_to_tflite.py,sha256=85FVEt6cKF
 ai_edge_torch/generative/examples/openelm/openelm.py,sha256=sFakstoPDcOHSak0IGFEEq_HQMBBSMcx-WVCDZqcVDo,4411
 ai_edge_torch/generative/examples/openelm/verify.py,sha256=VkigoqhAr8ew95neb3TifYv-SLOSheaWKv2AH0iKDrc,2441
 ai_edge_torch/generative/examples/paligemma/__init__.py,sha256=hHLluseD2R0Hh4W6XZRIXY_dRQeYudjsrKGf6LZz65g,671
-ai_edge_torch/generative/examples/paligemma/decoder.py,sha256=JSb9h3gcIh5oYrbLU6rI8OU8FzfWeTCFJT5XRWu4btE,3675
+ai_edge_torch/generative/examples/paligemma/decoder.py,sha256=XMeznGBbjRJidv725L6_7XzkYskS2cDjf8NGB18FNhg,4944
 ai_edge_torch/generative/examples/paligemma/image_encoder.py,sha256=v19_EKALhAP9FjkINKqpv8JsVaQ6iH_7X5FpnhE6abw,5500
+ai_edge_torch/generative/examples/paligemma/paligemma.py,sha256=mbq9CBp2znXPIQdzIQTiQGRh4Ql3bn9kyX-k_LXKTms,4537
+ai_edge_torch/generative/examples/paligemma/verify.py,sha256=Bkbgy-GFjnMNYjduWUM7YLWarPTwmj1v38eHY-PdBlM,4874
 ai_edge_torch/generative/examples/paligemma/verify_decoder.py,sha256=al5wMPWri4IRVWrLmCplPi6uoCzwh0vBHMGnCt-XUqo,2690
 ai_edge_torch/generative/examples/paligemma/verify_image_encoder.py,sha256=pSekf1BybhieQz3cQx_llbRQHxczXbTqool8fOyGj_0,3114
 ai_edge_torch/generative/examples/phi/__init__.py,sha256=hHLluseD2R0Hh4W6XZRIXY_dRQeYudjsrKGf6LZz65g,671
@@ -139,12 +141,12 @@ ai_edge_torch/generative/test/test_quantize.py,sha256=8geJhKwYBU20m0mdGPD1BUFwQ0
 ai_edge_torch/generative/test/utils.py,sha256=YvEhO2HIj1LkBs5du1UxY-cGRW9HMyAYsOUhgsTrTpA,1796
 ai_edge_torch/generative/utilities/__init__.py,sha256=-_jxnnFnCgnTU4oTm4MnRsvL5lqhomBNdFBbqfmfHPo,720
 ai_edge_torch/generative/utilities/converter.py,sha256=17O83wVifH1vQJCI4WC3DaNiCIOyK2gys1GzohbLrRs,5554
-ai_edge_torch/generative/utilities/loader.py,sha256=k5fjCokNomte4ymy9IJrEWAuCSMhsPCJfmv1y5s0ZEc,13452
-ai_edge_torch/generative/utilities/model_builder.py,sha256=89jt80UUfDzYBi-x077HBavWeuNJuYPXym9fiKCY1Tk,5278
+ai_edge_torch/generative/utilities/loader.py,sha256=A3SOjPXp--AsvoP1hqj5QKWE4sgxoFc3H5EBUz_Eogc,13531
+ai_edge_torch/generative/utilities/model_builder.py,sha256=OcHJhEqc3LjI3STli6cyn71m1mdzr7QbzF9fqSNCXrg,5730
 ai_edge_torch/generative/utilities/stable_diffusion_loader.py,sha256=dqPD9qRXEWtU3ombslOC-BE2l_dMwHoCNu7NsIJhsso,36158
 ai_edge_torch/generative/utilities/t5_loader.py,sha256=tEsfy8-ymzbbjOIc-oesXF3yGyyWtJgFXn2s7VOavt8,16961
 ai_edge_torch/generative/utilities/transformers_verifier.py,sha256=8sp9m_FMcXn7nqOrochtu2jIANkJKhnhIBUmH0ZTDR4,1549
-ai_edge_torch/generative/utilities/verifier.py,sha256=h5hGyIpYGyPZwvelbzpdkjy99Kpd4JkvhqWtQN9cm-M,10413
+ai_edge_torch/generative/utilities/verifier.py,sha256=GLh7h8pcpSKtCKoPyxJhv3TmvENd2h6ek_cnbe2s3Ak,11418
 ai_edge_torch/hlfb/__init__.py,sha256=sH4um75na-O8tzxN6chFyp6Y4xnexsE7kUQpZySv6dE,735
 ai_edge_torch/hlfb/mark_pattern/__init__.py,sha256=cjTprggj_cuktSCm7-A25e7Shop3k63ylp7sdZmtZ8o,4790
 ai_edge_torch/hlfb/mark_pattern/passes.py,sha256=pjkKcI1nHECPluAt87cFBrt1DP0f3ge7rHq1NhCkBIE,1936
@@ -191,8 +193,8 @@ ai_edge_torch/quantize/quant_config.py,sha256=U0KisSW-uZkoMJcy-ZP9W57p3tsa594fr9
 ai_edge_torch/testing/__init__.py,sha256=hHLluseD2R0Hh4W6XZRIXY_dRQeYudjsrKGf6LZz65g,671
 ai_edge_torch/testing/model_coverage/__init__.py,sha256=5P8J6Zk5YYtDvTBucFvB9NGSRI7Gw_24WnrbhXgycEE,765
 ai_edge_torch/testing/model_coverage/model_coverage.py,sha256=UPB448aMDUyC0HNYVqio2rcJPnDN0tBQMP08J6vPYew,4718
-ai_edge_torch_nightly-0.3.0.dev20241114.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-ai_edge_torch_nightly-0.3.0.dev20241114.dist-info/METADATA,sha256=LApNIpUONX7p4MYLOsx9QbWyD31PtVQDgQShvzqW-ec,1897
-ai_edge_torch_nightly-0.3.0.dev20241114.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
-ai_edge_torch_nightly-0.3.0.dev20241114.dist-info/top_level.txt,sha256=5KXRaF2hwkApYxf7Y8y_tVb9aulGTlbOoNdbx1aKRkE,14
-ai_edge_torch_nightly-0.3.0.dev20241114.dist-info/RECORD,,
+ai_edge_torch_nightly-0.3.0.dev20241116.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+ai_edge_torch_nightly-0.3.0.dev20241116.dist-info/METADATA,sha256=OyMmJ6EACAhEKbHNgLaGAogbjR8DwCLHYfIDdKW7iMI,1897
+ai_edge_torch_nightly-0.3.0.dev20241116.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+ai_edge_torch_nightly-0.3.0.dev20241116.dist-info/top_level.txt,sha256=5KXRaF2hwkApYxf7Y8y_tVb9aulGTlbOoNdbx1aKRkE,14
+ai_edge_torch_nightly-0.3.0.dev20241116.dist-info/RECORD,,