add fallback logic for getting the model size

backend/app/utils/model_validation.py

@@ -88,7 +88,12 @@ 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 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.
+        """
         try:
             logger.info(
                 LogFormatter.info(f"Checking model size for {model_info.modelId}")
@@ -101,43 +106,73 @@ class ModelValidator:
                 if hasattr(s, "rfilename")
             )
 
-            # Try to get size from safetensors first
-            model_size = None
+            model_size = None  # will hold total parameter count (as a number)
 
             if is_adapter and base_model:
-                # For adapters, we need both adapter and base model sizes
+                # For adapters, we need both adapter and base model sizes from safetensors metadata.
                 adapter_meta = await self.get_safetensors_metadata(
                     model_info.id, is_adapter=True, revision=revision
                 )
                 base_meta = await self.get_safetensors_metadata(
                     base_model, revision="main"
                 )
-
                 if adapter_meta and base_meta:
                     adapter_size = sum(adapter_meta.parameter_count.values())
                     base_size = sum(base_meta.parameter_count.values())
                     model_size = adapter_size + base_size
             else:
-                # For regular models, just get the model size
+                # For regular models, try to get the model size from safetensors metadata.
                 meta = await self.get_safetensors_metadata(
                     model_info.id, revision=revision
                 )
                 if meta:
-                    model_size = sum(meta.parameter_count.values())  # total params
+                    model_size = sum(meta.parameter_count.values())
 
-            if model_size is None:
-                # If model size could not be determined, return an error
-                return None, "Model size could not be determined"
+            if model_size is not None:
+                # Adjust size for GPTQ models if needed
+                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")
+                )
+                return model_size, None
 
-            # Adjust size for GPTQ models
-            size_factor = (
-                8 if (precision == "GPTQ" or "gptq" in model_info.id.lower()) else 1
+            # Fallback: use file metadata (siblings) to estimate model size
+            logger.info(
+                "Safetensors metadata not available. Falling back to file metadata to estimate model size."
             )
-            model_size = model_size / 1e9  # Convert to billions, assuming float16
-            model_size = round(size_factor * model_size, 3)
-
-            logger.info(LogFormatter.success(f"Model size: {model_size}B parameters"))
-            return model_size, None
+            weight_file_extensions = [".bin", ".safetensors"]
+            fallback_size_bytes = 0
+            for sibling in model_info.siblings:
+                if hasattr(sibling, "rfilename") and sibling.size is not None:
+                    if any(
+                        sibling.rfilename.endswith(ext)
+                        for ext in weight_file_extensions
+                    ):
+                        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.
+                factor = (
+                    8 if (precision == "GPTQ" or "gptq" in model_info.id.lower()) else 1
+                )
+                estimated_param_count = (fallback_size_bytes / 2) * factor
+                model_size = round(estimated_param_count / 1e9, 3)  # in billions
+                logger.info(
+                    LogFormatter.success(
+                        f"Fallback model size: {model_size}B parameters"
+                    )
+                )
+                return model_size, None
+            else:
+                return (
+                    None,
+                    "Model size could not be determined using file metadata fallback",
+                )
 
         except Exception as e:
             logger.error(LogFormatter.error(f"Error while determining model size: {e}"))