Update app.py

app.py

@@ -10,59 +10,94 @@ print(f"Using device: {device}")
 
 # Load the pickled model and tokenizer
 def load_model():
-    try:
-        # Load from pickle files with CPU mapping
-        print("Loading model from pickle files...")
-        with open('summarization_model.pkl', 'rb') as f:
-            # Use torch.load with map_location to handle CUDA->CPU conversion
-            import io
-            model_bytes = f.read()
-            model = torch.load(io.BytesIO(model_bytes), map_location='cpu')
-
-        with open('tokenizer.pkl', 'rb') as f:
-            tokenizer = pickle.load(f)
+    print("Starting model loading process...")
 
-        print("✓ Model and tokenizer loaded from pickle files")
+    # First try directory-based loading (more reliable)
+    try:
+        print("Attempting directory-based loading...")
+        print("Looking for: ./summarization_model/ directory")
 
-        # Create summarization pipeline
         summarizer = pipeline(
             "summarization",
-            model=model,
-            tokenizer=tokenizer,
+            model="./summarization_model",
             device=-1  # Force CPU usage
         )
-
+        print("✓ Model loaded successfully from directory")
         return summarizer
 
-    except FileNotFoundError:
-        print("Pickle files not found, trying to load from directory...")
-        try:
-            # Fallback: try loading from directory
-            summarizer = pipeline(
-                "summarization",
-                model="./summarization_model",
-                device=-1  # Force CPU usage
-            )
-            print("✓ Model loaded from directory")
-            return summarizer
-        except Exception as e:
-            print(f"Error loading model: {e}")
-            return None
     except Exception as e:
-        print(f"Error loading from pickle: {e}")
-        print("Trying fallback loading...")
+        print(f"Directory loading failed: {e}")
+
+        # Try alternative directory name
         try:
-            # Fallback: try loading from directory
+            print("Trying alternative directory: ./summarization_model_cpu/")
             summarizer = pipeline(
                 "summarization",
-                model="./summarization_model",
+                model="./summarization_model_cpu",
                 device=-1  # Force CPU usage
             )
-            print("✓ Model loaded from directory (fallback)")
+            print("✓ Model loaded successfully from alternative directory")
             return summarizer
+
         except Exception as e2:
-            print(f"Error loading model: {e2}")
-            return None
+            print(f"Alternative directory loading also failed: {e2}")
+
+            # Fallback to pickle loading
+            try:
+                print("Attempting pickle-based loading...")
+                print("Looking for: summarization_model.pkl and tokenizer.pkl")
+
+                # Check if files exist
+                if not os.path.exists('summarization_model.pkl'):
+                    raise FileNotFoundError("summarization_model.pkl not found")
+                if not os.path.exists('tokenizer.pkl'):
+                    raise FileNotFoundError("tokenizer.pkl not found")
+
+                print("Files found, loading...")
+
+                with open('summarization_model.pkl', 'rb') as f:
+                    # Try pickle first
+                    try:
+                        model = pickle.load(f)
+                        print("✓ Model loaded with pickle")
+                    except Exception as pickle_e:
+                        print(f"Pickle loading failed: {pickle_e}")
+                        # Fallback to torch.load for model files
+                        f.seek(0)  # Reset file pointer
+                        model_bytes = f.read()
+                        import io
+                        model = torch.load(io.BytesIO(model_bytes), map_location='cpu')
+                        print("✓ Model loaded with torch.load")
+
+                with open('tokenizer.pkl', 'rb') as f:
+                    tokenizer = pickle.load(f)
+                    print("✓ Tokenizer loaded with pickle")
+
+                print("✓ Model and tokenizer loaded from pickle files")
+
+                # Create summarization pipeline
+                summarizer = pipeline(
+                    "summarization",
+                    model=model,
+                    tokenizer=tokenizer,
+                    device=-1  # Force CPU usage
+                )
+                print("✓ Summarization pipeline created successfully")
+                return summarizer
+
+            except Exception as e3:
+                print(f"❌ All loading methods failed: {e3}")
+                print("Available files in current directory:")
+                try:
+                    files = os.listdir('.')
+                    model_files = [f for f in files if any(keyword in f.lower() for keyword in ['summarization', 'tokenizer', 'model', '.pkl', '.bin'])]
+                    print(f"Model-related files: {model_files}")
+                    for f in model_files:
+                        size = os.path.getsize(f) if os.path.exists(f) else "N/A"
+                        print(f"  {f}: {size} bytes")
+                except Exception as list_e:
+                    print(f"Could not list directory: {list_e}")
+                return None
 
 # Load model at startup
 summarizer = load_model()