fixes in model size logic

backend/app/utils/model_validation.py

@@ -88,28 +88,34 @@ class ModelValidator:
     async def get_model_size(
         self, model_info: Any, precision: str, base_model: str, revision: str
     ) -> Tuple[Optional[float], Optional[str]]:
-        """Get model size in billions of parameters.
+        """
+        Get model size in billions of parameters.
+
+        First, try to use safetensors metadata (which includes a parameter count).
+        If that isn’t available, then as a fallback, use file metadata from the repository
+        to sum the sizes of weight files.
+
+        For the fallback, we assume (for example) that for float16 storage each parameter takes ~2 bytes.
+        For GPTQ models (detected via the precision argument or model ID), we adjust by a factor (e.g. 8).
 
-        First, try to use safetensors metadata (which provides parameter counts).
-        If that isn’t available (i.e. for non-safetensors models), then as a fallback,
-        use file metadata (summing the sizes of weight files) and estimate the parameter count.
+        Returns:
+            Tuple of (model_size_in_billions, error_message). If successful, error_message is None.
         """
         try:
             logger.info(
                 LogFormatter.info(f"Checking model size for {model_info.modelId}")
             )
 
-            # Check if model is adapter
+            # Check if model is an adapter by looking for an adapter config file.
             is_adapter = any(
-                s.rfilename == "adapter_config.json"
+                hasattr(s, "rfilename") and s.rfilename == "adapter_config.json"
                 for s in model_info.siblings
-                if hasattr(s, "rfilename")
             )
 
-            model_size = None  # will hold total parameter count (as a number)
+            model_size = None  # This will hold the total parameter count if available.
 
             if is_adapter and base_model:
-                # For adapters, we need both adapter and base model sizes from safetensors metadata.
+                # For adapters, we need to get both the adapter and base model metadata.
                 adapter_meta = await self.get_safetensors_metadata(
                     model_info.id, is_adapter=True, revision=revision
                 )
@@ -129,23 +135,37 @@ class ModelValidator:
                     model_size = sum(meta.parameter_count.values())
 
             if model_size is not None:
-                # Adjust size for GPTQ models if needed
+                # Adjust for GPTQ models if necessary.
                 factor = (
                     8 if (precision == "GPTQ" or "gptq" in model_info.id.lower()) else 1
                 )
-                # Convert parameter count to billions
                 model_size = round((model_size / 1e9) * factor, 3)
                 logger.info(
-                    LogFormatter.success(f"Model size: {model_size}B parameters")
+                    LogFormatter.success(
+                        f"Model size: {model_size}B parameters (from safetensors metadata)"
+                    )
                 )
                 return model_size, None
 
-            # Fallback: use file metadata (siblings) to estimate model size
+            # Fallback: use file metadata from the repository.
             logger.info(
                 "Safetensors metadata not available. Falling back to file metadata to estimate model size."
             )
             weight_file_extensions = [".bin", ".safetensors"]
             fallback_size_bytes = 0
+
+            # If model_info does not contain file metadata, re-fetch with files_metadata=True.
+            if not model_info.siblings or all(
+                getattr(s, "size", None) is None for s in model_info.siblings
+            ):
+                logger.info(
+                    "Re-fetching model info with file metadata for fallback estimation."
+                )
+                model_info = await asyncio.to_thread(
+                    self.api.model_info, model_info.id, files_metadata=True
+                )
+
+            # Sum up the sizes of files that appear to be weight files.
             for sibling in model_info.siblings:
                 if hasattr(sibling, "rfilename") and sibling.size is not None:
                     if any(
@@ -155,8 +175,8 @@ class ModelValidator:
                         fallback_size_bytes += sibling.size
 
             if fallback_size_bytes > 0:
-                # Assume float16 storage where each parameter takes ~2 bytes.
-                # Then estimate parameter count and adjust for GPTQ if needed.
+                # Estimate parameter count based on file size.
+                # For float16 weights we assume ~2 bytes per parameter.
                 factor = (
                     8 if (precision == "GPTQ" or "gptq" in model_info.id.lower()) else 1
                 )