fallback for from_pretrained model loading

app.py

@@ -30,6 +30,7 @@ from hf_utils.css_and_html import (
     get_header_html,
 )
 from hf_utils.visual_util import predictions_to_glb
+from mapanything.models import MapAnything
 from mapanything.utils.geometry import depthmap_to_world_frame, points_to_normals
 from mapanything.utils.image import load_images, rgb
 
@@ -149,68 +150,78 @@ def run_model(target_dir, model_placeholder, apply_mask=True, mask_edges=True):
             high_level_config["path"], overrides=high_level_config["config_overrides"]
         )
 
-        print("Loading MapAnything model...")
-        # Create model from local configuration instead of using from_pretrained
-        from mapanything.models import init_model
-
-        model = init_model(
-            model_str=cfg.model.model_str,
-            model_config=cfg.model.model_config,
-            torch_hub_force_reload=high_level_config.get(
-                "torch_hub_force_reload", False
-            ),
-        )
-
-        # Load the pretrained weights from HuggingFace Hub
+        # Try using from_pretrained first
         try:
-            from huggingface_hub import hf_hub_download, list_repo_files
+            print("Loading MapAnything model from_pretrained...")
+            model = MapAnything.from_pretrained(high_level_config["hf_model_name"]).to(
+                device
+            )
+            print("Loading MapAnything model from_pretrained succeeded...")
+        except Exception as e:
+            print(f"from_pretrained failed: {e}")
+            print("Falling back to local configuration approach...")
+            
+            # Create model from local configuration instead of using from_pretrained
+            from mapanything.models import init_model
+
+            model = init_model(
+                model_str=cfg.model.model_str,
+                model_config=cfg.model.model_config,
+                torch_hub_force_reload=high_level_config.get(
+                    "torch_hub_force_reload", False
+                ),
+            )
 
-            # First, let's see what files are available in the repository
+            # Load the pretrained weights from HuggingFace Hub
             try:
-                repo_files = list_repo_files(
-                    repo_id=high_level_config["hf_model_name"], token=load_hf_token()
-                )
-                print(f"Available files in repository: {repo_files}")
-
-                checkpoint_filename = "model.safetensors"
+                from huggingface_hub import hf_hub_download, list_repo_files
 
-                # Download the model weights
-                checkpoint_path = hf_hub_download(
-                    repo_id=high_level_config["hf_model_name"],
-                    filename=checkpoint_filename,
-                    token=load_hf_token(),
-                )
+                # First, let's see what files are available in the repository
+                try:
+                    repo_files = list_repo_files(
+                        repo_id=high_level_config["hf_model_name"], token=load_hf_token()
+                    )
+                    print(f"Available files in repository: {repo_files}")
 
-                # Load the weights
-                print("start loading checkpoint")
-                if checkpoint_filename.endswith(".safetensors"):
-                    from safetensors.torch import load_file
+                    checkpoint_filename = "model.safetensors"
 
-                    checkpoint = load_file(checkpoint_path)
-                else:
-                    checkpoint = torch.load(
-                        checkpoint_path, map_location="cpu", weights_only=True
+                    # Download the model weights
+                    checkpoint_path = hf_hub_download(
+                        repo_id=high_level_config["hf_model_name"],
+                        filename=checkpoint_filename,
+                        token=load_hf_token(),
                     )
 
-                print("start loading state_dict")
-                if "model" in checkpoint:
-                    model.load_state_dict(checkpoint["model"])
-                elif "state_dict" in checkpoint:
-                    model.load_state_dict(checkpoint["state_dict"])
-                else:
-                    model.load_state_dict(checkpoint)
+                    # Load the weights
+                    print("start loading checkpoint")
+                    if checkpoint_filename.endswith(".safetensors"):
+                        from safetensors.torch import load_file
 
-                print(
-                    f"Successfully loaded pretrained weights from HuggingFace Hub ({checkpoint_filename})"
-                )
+                        checkpoint = load_file(checkpoint_path)
+                    else:
+                        checkpoint = torch.load(
+                            checkpoint_path, map_location="cpu", weights_only=True
+                        )
+
+                    print("start loading state_dict")
+                    if "model" in checkpoint:
+                        model.load_state_dict(checkpoint["model"])
+                    elif "state_dict" in checkpoint:
+                        model.load_state_dict(checkpoint["state_dict"])
+                    else:
+                        model.load_state_dict(checkpoint)
 
-            except Exception as inner_e:
-                print(f"Error listing repository files or loading weights: {inner_e}")
-                raise inner_e
+                    print(
+                        f"Successfully loaded pretrained weights from HuggingFace Hub ({checkpoint_filename})"
+                    )
 
-        except Exception as e:
-            print(f"Warning: Could not load pretrained weights: {e}")
-            print("Proceeding with randomly initialized model...")
+                except Exception as inner_e:
+                    print(f"Error listing repository files or loading weights: {inner_e}")
+                    raise inner_e
+
+            except Exception as e:
+                print(f"Warning: Could not load pretrained weights: {e}")
+                print("Proceeding with randomly initialized model...")
 
         model = model.to(device)