Upload modeling_conceptframemet.py with huggingface_hub

modeling_conceptframemet.py

@@ -288,39 +288,35 @@ class ConceptFrameMetForMetaphorDetection(nn.Module):
         }
     
     @classmethod
-    def from_pretrained(cls, model_path, load_source_from_checkpoint=True, **kwargs):
+    def from_pretrained(cls, model_path, **kwargs):
         """Load model from pretrained checkpoint"""
-        # Load config
-        config_path = os.path.join(model_path, "config.json")
-        with open(config_path, 'r') as f:
-            config = json.load(f)
-        
         # Load weights first to check what's in checkpoint
         weights_path = os.path.join(model_path, "pytorch_model.bin")
         state_dict = torch.load(weights_path, map_location='cpu')
         
-        # Check if checkpoint has source_qa_model
+        # Check what's in the checkpoint
         has_source_in_checkpoint = any(k.startswith('source_qa_model.') for k in state_dict.keys())
+        has_frame_in_checkpoint = any(k.startswith('frame_qa_model.') for k in state_dict.keys())
+        
+        # Initialize model:
+        # - Download frame_qa_model (nixie1981/sem_frames) - NOT in checkpoint
+        # - Don't download source_qa_model - IS in checkpoint
+        model = cls(
+            frame_qa_model_name="nixie1981/sem_frames",  # Download - needed for frames!
+            source_qa_model_name=None,  # Don't download - in checkpoint
+            **kwargs
+        )
         
-        # Initialize model WITHOUT loading external models if they're in checkpoint
-        if has_source_in_checkpoint and load_source_from_checkpoint:
-            # Don't load source from HF, we'll load from checkpoint
-            model = cls(source_qa_model_name=None, **kwargs)
-            # Manually set has_source_predictor since weights are in checkpoint
+        # Manually set source flag since weights are in checkpoint
+        if has_source_in_checkpoint:
             model.has_source_predictor = True
-        else:
-            model = cls(**kwargs)
-        
-        # Load ALL weights from checkpoint (including source_qa_model if present)
-        # Only filter out frame_qa_model if we don't have it
-        filtered_state_dict = {}
-        for key, value in state_dict.items():
-            # Only skip frame_qa_model weights if we don't have it  
-            if key.startswith('frame_qa_model.') and not model.has_frame_predictor:
-                continue
-            filtered_state_dict[key] = value
-        
-        model.load_state_dict(filtered_state_dict, strict=False)
+        
+        # Load ALL weights from checkpoint (including source_qa_model)
+        missing, unexpected = model.load_state_dict(state_dict, strict=False)
+        
+        print(f"Loaded {len(state_dict)} weights from checkpoint")
+        if missing:
+            print(f"Missing {len(missing)} keys")
         
         return model