Update src/dlrm_inference.py

src/dlrm_inference.py

@@ -1,314 +1,692 @@
-"""
-DLRM Inference Engine for Book Recommendations
-Loads trained DLRM model and provides recommendation functionality
-"""
+# """
+# DLRM Inference Engine for Book Recommendations
+# Loads trained DLRM model and provides recommendation functionality
+# """
 
-import os
-import sys
-import torch
-import numpy as np
-import pandas as pd
-import pickle
-import mlflow
-from mlflow import MlflowClient
-import tempfile
-from typing import List, Dict, Tuple, Optional, Any
-from functools import partial
-import warnings
-warnings.filterwarnings('ignore')
+# import os
+# import sys
+# import torch
+# import numpy as np
+# import pandas as pd
+# import pickle
+# import mlflow
+# from mlflow import MlflowClient
+# import tempfile
+# from typing import List, Dict, Tuple, Optional, Any
+# from functools import partial
+# import warnings
+# warnings.filterwarnings('ignore')
 
-# Check for CPU_ONLY environment variable
-CPU_ONLY = os.environ.get('CPU_ONLY', 'false').lower() == 'true'
+# # Check for CPU_ONLY environment variable
+# CPU_ONLY = os.environ.get('CPU_ONLY', 'false').lower() == 'true'
 
-# Disable CUDA if CPU_ONLY is set
-if CPU_ONLY:
-    os.environ['CUDA_VISIBLE_DEVICES'] = ''
-    print("🔄 Running in CPU-only mode (CUDA disabled)")
+# # Disable CUDA if CPU_ONLY is set
+# if CPU_ONLY:
+#     os.environ['CUDA_VISIBLE_DEVICES'] = ''
+#     print("🔄 Running in CPU-only mode (CUDA disabled)")
 
-# Only import torchrec if not in CPU_ONLY mode
-TORCHREC_AVAILABLE = False
-if not CPU_ONLY:
-    try:
-        from torchrec import EmbeddingBagCollection
-        from torchrec.models.dlrm import DLRM, DLRMTrain
-        from torchrec.modules.embedding_configs import EmbeddingBagConfig
-        from torchrec.sparse.jagged_tensor import KeyedJaggedTensor
-        from torchrec.datasets.utils import Batch
-        TORCHREC_AVAILABLE = True
-    except ImportError as e:
-        print(f"⚠️ Warning: torchrec import error: {e}")
-        print("⚠️ Some functionality will be limited")
-else:
-    print("⚠️ Running in CPU-only mode without torchrec")
+# # Only import torchrec if not in CPU_ONLY mode
+# TORCHREC_AVAILABLE = False
+# if not CPU_ONLY:
+#     try:
+#         from torchrec import EmbeddingBagCollection
+#         from torchrec.models.dlrm import DLRM, DLRMTrain
+#         from torchrec.modules.embedding_configs import EmbeddingBagConfig
+#         from torchrec.sparse.jagged_tensor import KeyedJaggedTensor
+#         from torchrec.datasets.utils import Batch
+#         TORCHREC_AVAILABLE = True
+#     except ImportError as e:
+#         print(f"⚠️ Warning: torchrec import error: {e}")
+#         print("⚠️ Some functionality will be limited")
+# else:
+#     print("⚠️ Running in CPU-only mode without torchrec")
 
-class DLRMBookRecommender:
-    """DLRM-based book recommender for inference"""
+# class DLRMBookRecommender:
+#     """DLRM-based book recommender for inference"""
     
-    def __init__(self, model_path: str = None, run_id: str = None):
-        """
-        Initialize DLRM book recommender
-        
-        Args:
-            model_path: Path to saved model state dict
-            run_id: MLflow run ID to load model from
-        """
-        self.device = torch.device("cpu")
-        self.model = None
-        self.preprocessing_info = None
-        self.torchrec_available = TORCHREC_AVAILABLE
-        self.cpu_only = CPU_ONLY
-        self.dense_cols = []
-        self.cat_cols = []
-        self.emb_counts = []
-        
-        if self.cpu_only:
-            print("⚠️ Running in CPU-only mode with limited functionality")
-            # Load minimal preprocessing info for browsing
-            self._load_minimal_preprocessing()
-            return
-            
-        if not self.torchrec_available:
-            print("⚠️ Running in limited mode without torchrec")
-            return
-            
-        # Load preprocessing info
-        self._load_preprocessing_info()
-        
-        # Load model
-        if model_path and os.path.exists(model_path):
-            self._load_model_from_path(model_path)
-        elif run_id:
-            self._load_model_from_mlflow(run_id)
-        else:
-            print("⚠️ No model loaded. Please provide model_path or run_id")
+#     def __init__(self, model_path: str = None, run_id: str = None):
+#         """
+#         Initialize DLRM book recommender
+        
+#         Args:
+#             model_path: Path to saved model state dict
+#             run_id: MLflow run ID to load model from
+#         """
+#         self.device = torch.device("cpu")
+#         self.model = None
+#         self.preprocessing_info = None
+#         self.torchrec_available = TORCHREC_AVAILABLE
+#         self.cpu_only = CPU_ONLY
+#         self.dense_cols = []
+#         self.cat_cols = []
+#         self.emb_counts = []
+        
+#         if self.cpu_only:
+#             print("⚠️ Running in CPU-only mode with limited functionality")
+#             # Load minimal preprocessing info for browsing
+#             self._load_minimal_preprocessing()
+#             return
+            
+#         if not self.torchrec_available:
+#             print("⚠️ Running in limited mode without torchrec")
+#             return
+            
+#         # Load preprocessing info
+#         self._load_preprocessing_info()
+        
+#         # Load model
+#         if model_path and os.path.exists(model_path):
+#             self._load_model_from_path(model_path)
+#         elif run_id:
+#             self._load_model_from_mlflow(run_id)
+#         else:
+#             print("⚠️ No model loaded. Please provide model_path or run_id")
     
-    def _load_minimal_preprocessing(self):
-        """Load minimal preprocessing info for CPU-only mode"""
-        try:
-            if os.path.exists('book_dlrm_preprocessing.pkl'):
-                with open('book_dlrm_preprocessing.pkl', 'rb') as f:
-                    self.preprocessing_info = pickle.load(f)
+#     def _load_minimal_preprocessing(self):
+#         """Load minimal preprocessing info for CPU-only mode"""
+#         try:
+#             if os.path.exists('book_dlrm_preprocessing.pkl'):
+#                 with open('book_dlrm_preprocessing.pkl', 'rb') as f:
+#                     self.preprocessing_info = pickle.load(f)
                 
-                self.dense_cols = self.preprocessing_info.get('dense_cols', [])
-                self.cat_cols = self.preprocessing_info.get('cat_cols', [])
-                self.emb_counts = self.preprocessing_info.get('emb_counts', [])
+#                 self.dense_cols = self.preprocessing_info.get('dense_cols', [])
+#                 self.cat_cols = self.preprocessing_info.get('cat_cols', [])
+#                 self.emb_counts = self.preprocessing_info.get('emb_counts', [])
                 
-                print("✅ Minimal preprocessing info loaded for CPU-only mode")
-            else:
-                print("⚠️ No preprocessing info found for CPU-only mode")
-        except Exception as e:
-            print(f"⚠️ Error loading minimal preprocessing: {e}")
-    
-    def _load_preprocessing_info(self):
-        """Load preprocessing information"""
-        if os.path.exists('book_dlrm_preprocessing.pkl'):
-            with open('book_dlrm_preprocessing.pkl', 'rb') as f:
-                self.preprocessing_info = pickle.load(f)
-            
-            self.dense_cols = self.preprocessing_info['dense_cols']
-            self.cat_cols = self.preprocessing_info['cat_cols']
-            self.emb_counts = self.preprocessing_info['emb_counts']
-            self.user_encoder = self.preprocessing_info['user_encoder']
-            self.book_encoder = self.preprocessing_info['book_encoder']
-            self.publisher_encoder = self.preprocessing_info['publisher_encoder']
-            self.location_encoder = self.preprocessing_info['location_encoder']
-            self.scaler = self.preprocessing_info['scaler']
-            
-            print("✅ Preprocessing info loaded")
-        else:
-            raise FileNotFoundError("book_dlrm_preprocessing.pkl not found. Run preprocessing first.")
+#                 print("✅ Minimal preprocessing info loaded for CPU-only mode")
+#             else:
+#                 print("⚠️ No preprocessing info found for CPU-only mode")
+#         except Exception as e:
+#             print(f"⚠️ Error loading minimal preprocessing: {e}")
     
-    def _load_model_from_path(self, model_path: str):
-        """Load model from saved state dict"""
-        try:
-            # Create model architecture
-            eb_configs = [
-                EmbeddingBagConfig(
-                    name=f"t_{feature_name}",
-                    embedding_dim=64,  # Default embedding dim
-                    num_embeddings=self.emb_counts[feature_idx],
-                    feature_names=[feature_name],
-                )
-                for feature_idx, feature_name in enumerate(self.cat_cols)
-            ]
+#     def _load_preprocessing_info(self):
+#         """Load preprocessing information"""
+#         if os.path.exists('book_dlrm_preprocessing.pkl'):
+#             with open('book_dlrm_preprocessing.pkl', 'rb') as f:
+#                 self.preprocessing_info = pickle.load(f)
+            
+#             self.dense_cols = self.preprocessing_info['dense_cols']
+#             self.cat_cols = self.preprocessing_info['cat_cols']
+#             self.emb_counts = self.preprocessing_info['emb_counts']
+#             self.user_encoder = self.preprocessing_info['user_encoder']
+#             self.book_encoder = self.preprocessing_info['book_encoder']
+#             self.publisher_encoder = self.preprocessing_info['publisher_encoder']
+#             self.location_encoder = self.preprocessing_info['location_encoder']
+#             self.scaler = self.preprocessing_info['scaler']
+            
+#             print("✅ Preprocessing info loaded")
+#         else:
+#             raise FileNotFoundError("book_dlrm_preprocessing.pkl not found. Run preprocessing first.")
+    
+#     def _load_model_from_path(self, model_path: str):
+#         """Load model from saved state dict"""
+#         try:
+#             # Create model architecture
+#             eb_configs = [
+#                 EmbeddingBagConfig(
+#                     name=f"t_{feature_name}",
+#                     embedding_dim=64,  # Default embedding dim
+#                     num_embeddings=self.emb_counts[feature_idx],
+#                     feature_names=[feature_name],
+#                 )
+#                 for feature_idx, feature_name in enumerate(self.cat_cols)
+#             ]
 
-            dlrm_model = DLRM(
-                embedding_bag_collection=EmbeddingBagCollection(
-                    tables=eb_configs, device=self.device
-                ),
-                dense_in_features=len(self.dense_cols),
-                dense_arch_layer_sizes=[256, 128, 64],
-                over_arch_layer_sizes=[512, 256, 128, 1],
-                dense_device=self.device,
-            )
+#             dlrm_model = DLRM(
+#                 embedding_bag_collection=EmbeddingBagCollection(
+#                     tables=eb_configs, device=self.device
+#                 ),
+#                 dense_in_features=len(self.dense_cols),
+#                 dense_arch_layer_sizes=[256, 128, 64],
+#                 over_arch_layer_sizes=[512, 256, 128, 1],
+#                 dense_device=self.device,
+#             )
 
-            # Load state dict
-            state_dict = torch.load(model_path, map_location=self.device)
+#             # Load state dict
+#             state_dict = torch.load(model_path, map_location=self.device)
             
-            # Remove 'model.' prefix if present
-            if any(key.startswith('model.') for key in state_dict.keys()):
-                state_dict = {k[6:]: v for k, v in state_dict.items()}
+#             # Remove 'model.' prefix if present
+#             if any(key.startswith('model.') for key in state_dict.keys()):
+#                 state_dict = {k[6:]: v for k, v in state_dict.items()}
             
-            dlrm_model.load_state_dict(state_dict)
-            self.model = dlrm_model
-            self.model.eval()
+#             dlrm_model.load_state_dict(state_dict)
+#             self.model = dlrm_model
+#             self.model.eval()
             
-            print(f"✅ Model loaded from {model_path}")
+#             print(f"✅ Model loaded from {model_path}")
             
-        except Exception as e:
-            print(f"❌ Error loading model: {e}")
+#         except Exception as e:
+#             print(f"❌ Error loading model: {e}")
     
-    def _load_model_from_mlflow(self, run_id: str):
-        """Load model from MLflow"""
-        try:
-            client = MlflowClient()
-            run = client.get_run(run_id)
-            
-            # Get model parameters from MLflow
-            params = run.data.params
-            cat_cols = eval(params.get('cat_cols'))
-            emb_counts = eval(params.get('emb_counts'))
-            dense_cols = eval(params.get('dense_cols'))
-            embedding_dim = int(params.get('embedding_dim', 64))
-            dense_arch_layer_sizes = eval(params.get('dense_arch_layer_sizes'))
-            over_arch_layer_sizes = eval(params.get('over_arch_layer_sizes'))
-            
-            # Download model from MLflow
-            temp_dir = tempfile.mkdtemp()
-            
-            # Try different artifact paths
-            for artifact_path in ['model_state_dict_final', 'model_state_dict_2', 'model_state_dict_1', 'model_state_dict_0']:
-                try:
-                    client.download_artifacts(run_id, f"{artifact_path}/state_dict.pth", temp_dir)
-                    state_dict = mlflow.pytorch.load_state_dict(f"{temp_dir}/{artifact_path}")
-                    break
-                except:
-                    continue
-            else:
-                raise Exception("No model artifacts found")
-            
-            # Create model
-            eb_configs = [
-                EmbeddingBagConfig(
-                    name=f"t_{feature_name}",
-                    embedding_dim=embedding_dim,
-                    num_embeddings=emb_counts[feature_idx],
-                    feature_names=[feature_name],
-                )
-                for feature_idx, feature_name in enumerate(cat_cols)
-            ]
+#     def _load_model_from_mlflow(self, run_id: str):
+#         """Load model from MLflow"""
+#         try:
+#             client = MlflowClient()
+#             run = client.get_run(run_id)
+            
+#             # Get model parameters from MLflow
+#             params = run.data.params
+#             cat_cols = eval(params.get('cat_cols'))
+#             emb_counts = eval(params.get('emb_counts'))
+#             dense_cols = eval(params.get('dense_cols'))
+#             embedding_dim = int(params.get('embedding_dim', 64))
+#             dense_arch_layer_sizes = eval(params.get('dense_arch_layer_sizes'))
+#             over_arch_layer_sizes = eval(params.get('over_arch_layer_sizes'))
+            
+#             # Download model from MLflow
+#             temp_dir = tempfile.mkdtemp()
+            
+#             # Try different artifact paths
+#             for artifact_path in ['model_state_dict_final', 'model_state_dict_2', 'model_state_dict_1', 'model_state_dict_0']:
+#                 try:
+#                     client.download_artifacts(run_id, f"{artifact_path}/state_dict.pth", temp_dir)
+#                     state_dict = mlflow.pytorch.load_state_dict(f"{temp_dir}/{artifact_path}")
+#                     break
+#                 except:
+#                     continue
+#             else:
+#                 raise Exception("No model artifacts found")
+            
+#             # Create model
+#             eb_configs = [
+#                 EmbeddingBagConfig(
+#                     name=f"t_{feature_name}",
+#                     embedding_dim=embedding_dim,
+#                     num_embeddings=emb_counts[feature_idx],
+#                     feature_names=[feature_name],
+#                 )
+#                 for feature_idx, feature_name in enumerate(cat_cols)
+#             ]
 
-            dlrm_model = DLRM(
-                embedding_bag_collection=EmbeddingBagCollection(
-                    tables=eb_configs, device=self.device
-                ),
-                dense_in_features=len(dense_cols),
-                dense_arch_layer_sizes=dense_arch_layer_sizes,
-                over_arch_layer_sizes=over_arch_layer_sizes,
-                dense_device=self.device,
-            )
+#             dlrm_model = DLRM(
+#                 embedding_bag_collection=EmbeddingBagCollection(
+#                     tables=eb_configs, device=self.device
+#                 ),
+#                 dense_in_features=len(dense_cols),
+#                 dense_arch_layer_sizes=dense_arch_layer_sizes,
+#                 over_arch_layer_sizes=over_arch_layer_sizes,
+#                 dense_device=self.device,
+#             )
 
-            # Remove prefix and load state dict
-            if any(key.startswith('model.') for key in state_dict.keys()):
-                state_dict = {k[6:]: v for k, v in state_dict.items()}
+#             # Remove prefix and load state dict
+#             if any(key.startswith('model.') for key in state_dict.keys()):
+#                 state_dict = {k[6:]: v for k, v in state_dict.items()}
             
-            dlrm_model.load_state_dict(state_dict)
-            self.model = dlrm_model
-            self.model.eval()
+#             dlrm_model.load_state_dict(state_dict)
+#             self.model = dlrm_model
+#             self.model.eval()
             
-            print(f"✅ Model loaded from MLflow run: {run_id}")
+#             print(f"✅ Model loaded from MLflow run: {run_id}")
             
-        except Exception as e:
-            print(f"❌ Error loading model from MLflow: {e}")
+#         except Exception as e:
+#             print(f"❌ Error loading model from MLflow: {e}")
     
-    def _prepare_user_features(self, user_id: int, user_data: Optional[Dict] = None) -> Tuple[torch.Tensor, KeyedJaggedTensor]:
-        """Prepare user features for inference"""
-        
-        if user_data is None:
-            # Create default user features
-            user_data = {
-                'User-ID': user_id,
-                'Age': 30,  # Default age
-                'Location': 'usa',  # Default location
-            }
-        
-        # Encode categorical features
-        try:
-            user_id_encoded = self.user_encoder.transform([str(user_id)])[0]
-        except:
-            # Handle unknown user
-            user_id_encoded = 0
+#     def _prepare_user_features(self, user_id: int, user_data: Optional[Dict] = None) -> Tuple[torch.Tensor, KeyedJaggedTensor]:
+#         """Prepare user features for inference"""
+        
+#         if user_data is None:
+#             # Create default user features
+#             user_data = {
+#                 'User-ID': user_id,
+#                 'Age': 30,  # Default age
+#                 'Location': 'usa',  # Default location
+#             }
+        
+#         # Encode categorical features
+#         try:
+#             user_id_encoded = self.user_encoder.transform([str(user_id)])[0]
+#         except:
+#             # Handle unknown user
+#             user_id_encoded = 0
+        
+#         try:
+#             location = str(user_data.get('Location', 'usa')).split(',')[-1].strip().lower()
+#             country_encoded = self.location_encoder.transform([location])[0]
+#         except:
+#             country_encoded = 0
+        
+#         # Age group
+#         age = user_data.get('Age', 30)
+#         if age < 18:
+#             age_group = 0
+#         elif age < 25:
+#             age_group = 1
+#         elif age < 35:
+#             age_group = 2
+#         elif age < 50:
+#             age_group = 3
+#         elif age < 65:
+#             age_group = 4
+#         else:
+#             age_group = 5
+        
+#         # Get user statistics (if available)
+#         user_activity = user_data.get('user_activity', 10)  # Default
+#         user_avg_rating = user_data.get('user_avg_rating', 6.0)  # Default
+#         age_normalized = user_data.get('Age', 30)
+        
+#         # Normalize dense features
+#         dense_features = np.array([[age_normalized, 2000, user_activity, 10, user_avg_rating, 6.0]])  # Default values
+#         dense_features = self.scaler.transform(dense_features)
+#         dense_features = torch.tensor(dense_features, dtype=torch.float32)
+        
+#         return dense_features, user_id_encoded, country_encoded, age_group
+    
+#     def _prepare_book_features(self, book_isbn: str, book_data: Optional[Dict] = None) -> Tuple[int, int, int, int]:
+#         """Prepare book features for inference"""
+        
+#         if book_data is None:
+#             book_data = {}
+        
+#         # Encode book ID
+#         try:
+#             book_id_encoded = self.book_encoder.transform([str(book_isbn)])[0]
+#         except:
+#             book_id_encoded = 0
+        
+#         # Encode publisher
+#         try:
+#             publisher = str(book_data.get('Publisher', 'Unknown'))
+#             publisher_encoded = self.publisher_encoder.transform([publisher])[0]
+#         except:
+#             publisher_encoded = 0
+        
+#         # Publication decade
+#         year = book_data.get('Year-Of-Publication', 2000)
+#         decade = ((int(year) // 10) * 10)
+#         try:
+#             decade_encoded = preprocessing_info.get('decade_encoder', LabelEncoder()).transform([str(decade)])[0]
+#         except:
+#             decade_encoded = 6  # Default to 2000s
+        
+#         # Rating level (default to medium)
+#         rating_level = 1
+        
+#         return book_id_encoded, publisher_encoded, decade_encoded, rating_level
+    
+#     def predict_rating(self, user_id: int, book_isbn: str, 
+#                       user_data: Optional[Dict] = None, 
+#                       book_data: Optional[Dict] = None) -> float:
+#         """
+#         Predict rating probability for user-book pair
+        
+#         Args:
+#             user_id: User ID
+#             book_isbn: Book ISBN
+#             user_data: Additional user data (optional)
+#             book_data: Additional book data (optional)
+            
+#         Returns:
+#             Prediction probability (0-1)
+#         """
+#         if self.cpu_only:
+#             print("⚠️ Cannot make predictions in CPU-only mode")
+#             return 0.5  # Return default neutral prediction
+            
+#         if self.model is None:
+#             print("❌ Model not loaded")
+#             return 0.0
+        
+#         if not self.torchrec_available:
+#             print("❌ Cannot make predictions without torchrec")
+#             return 0.5  # Return default neutral prediction
+        
+#         try:
+#             # Prepare features
+#             dense_features, user_id_encoded, country_encoded, age_group = self._prepare_user_features(user_id, user_data)
+#             book_id_encoded, publisher_encoded, decade_encoded, rating_level = self._prepare_book_features(book_isbn, book_data)
+            
+#             # Create sparse features
+#             kjt_values = [user_id_encoded, book_id_encoded, publisher_encoded, country_encoded, age_group, decade_encoded, rating_level]
+#             kjt_lengths = [1] * len(kjt_values)
+            
+#             sparse_features = KeyedJaggedTensor.from_lengths_sync(
+#                 self.cat_cols,
+#                 torch.tensor(kjt_values),
+#                 torch.tensor(kjt_lengths, dtype=torch.int32),
+#             )
+            
+#             # Make prediction
+#             with torch.no_grad():
+#                 logits = self.model(dense_features=dense_features, sparse_features=sparse_features)
+#                 prediction = torch.sigmoid(logits).item()
+            
+#             return prediction
+            
+#         except Exception as e:
+#             print(f"Error in prediction: {e}")
+#             return 0.0
+    
+#     def get_user_recommendations(self, user_id: int, 
+#                                candidate_books: List[str],
+#                                k: int = 10,
+#                                user_data: Optional[Dict] = None) -> List[Tuple[str, float]]:
+#         """
+#         Get top-k book recommendations for a user
+        
+#         Args:
+#             user_id: User ID
+#             candidate_books: List of candidate book ISBNs
+#             k: Number of recommendations
+#             user_data: Additional user data
+            
+#         Returns:
+#             List of (book_isbn, prediction_score) tuples
+#         """
+#         if self.cpu_only or self.model is None or not self.torchrec_available:
+#             print("❌ Model not loaded, CPU-only mode, or torchrec not available")
+#             return []
         
-        try:
-            location = str(user_data.get('Location', 'usa')).split(',')[-1].strip().lower()
-            country_encoded = self.location_encoder.transform([location])[0]
-        except:
-            country_encoded = 0
-        
-        # Age group
-        age = user_data.get('Age', 30)
-        if age < 18:
-            age_group = 0
-        elif age < 25:
-            age_group = 1
-        elif age < 35:
-            age_group = 2
-        elif age < 50:
-            age_group = 3
-        elif age < 65:
-            age_group = 4
-        else:
-            age_group = 5
+#         recommendations = []
         
-        # Get user statistics (if available)
-        user_activity = user_data.get('user_activity', 10)  # Default
-        user_avg_rating = user_data.get('user_avg_rating', 6.0)  # Default
-        age_normalized = user_data.get('Age', 30)
+#         print(f"Generating recommendations for user {user_id} from {len(candidate_books)} candidates...")
         
-        # Normalize dense features
-        dense_features = np.array([[age_normalized, 2000, user_activity, 10, user_avg_rating, 6.0]])  # Default values
-        dense_features = self.scaler.transform(dense_features)
-        dense_features = torch.tensor(dense_features, dtype=torch.float32)
+#         for book_isbn in candidate_books:
+#             score = self.predict_rating(user_id, book_isbn, user_data)
+#             recommendations.append((book_isbn, score))
         
-        return dense_features, user_id_encoded, country_encoded, age_group
+#         # Sort by score and return top-k
+#         recommendations.sort(key=lambda x: x[1], reverse=True)
+#         return recommendations[:k]
     
-    def _prepare_book_features(self, book_isbn: str, book_data: Optional[Dict] = None) -> Tuple[int, int, int, int]:
-        """Prepare book features for inference"""
-        
-        if book_data is None:
-            book_data = {}
-        
-        # Encode book ID
-        try:
-            book_id_encoded = self.book_encoder.transform([str(book_isbn)])[0]
-        except:
-            book_id_encoded = 0
+#     def batch_recommend(self, user_ids: List[int], 
+#                        candidate_books: List[str],
+#                        k: int = 10) -> Dict[int, List[Tuple[str, float]]]:
+#         """
+#         Generate recommendations for multiple users
+        
+#         Args:
+#             user_ids: List of user IDs
+#             candidate_books: List of candidate book ISBNs
+#             k: Number of recommendations per user
+            
+#         Returns:
+#             Dictionary mapping user_id to recommendations
+#         """
+#         results = {}
         
-        # Encode publisher
-        try:
-            publisher = str(book_data.get('Publisher', 'Unknown'))
-            publisher_encoded = self.publisher_encoder.transform([publisher])[0]
-        except:
-            publisher_encoded = 0
-        
-        # Publication decade
-        year = book_data.get('Year-Of-Publication', 2000)
-        decade = ((int(year) // 10) * 10)
-        try:
-            decade_encoded = preprocessing_info.get('decade_encoder', LabelEncoder()).transform([str(decade)])[0]
-        except:
-            decade_encoded = 6  # Default to 2000s
+#         for user_id in user_ids:
+#             results[user_id] = self.get_user_recommendations(user_id, candidate_books, k)
         
-        # Rating level (default to medium)
-        rating_level = 1
+#         return results
+    
+#     def get_similar_books(self, target_book_isbn: str,
+#                          candidate_books: List[str],
+#                          sample_users: List[int],
+#                          k: int = 10) -> List[Tuple[str, float]]:
+#         """
+#         Find books similar to target book by comparing user preferences
+        
+#         Args:
+#             target_book_isbn: Target book ISBN
+#             candidate_books: List of candidate book ISBNs
+#             sample_users: Sample users to test similarity with
+#             k: Number of similar books
+            
+#         Returns:
+#             List of (book_isbn, similarity_score) tuples
+#         """
+#         target_scores = []
+#         candidate_scores = {book: [] for book in candidate_books}
+        
+#         # Get predictions for target book and candidates across sample users
+#         for user_id in sample_users:
+#             target_score = self.predict_rating(user_id, target_book_isbn)
+#             target_scores.append(target_score)
+            
+#             for book_isbn in candidate_books:
+#                 if book_isbn != target_book_isbn:
+#                     score = self.predict_rating(user_id, book_isbn)
+#                     candidate_scores[book_isbn].append(score)
+        
+#         # Calculate similarity based on correlation of user preferences
+#         similarities = []
+#         target_scores = np.array(target_scores)
+        
+#         for book_isbn, scores in candidate_scores.items():
+#             if len(scores) > 0:
+#                 scores_array = np.array(scores)
+#                 # Calculate correlation as similarity measure
+#                 correlation = np.corrcoef(target_scores, scores_array)[0, 1]
+#                 if not np.isnan(correlation):
+#                     similarities.append((book_isbn, correlation))
+        
+#         # Sort by similarity and return top-k
+#         similarities.sort(key=lambda x: x[1], reverse=True)
+#         return similarities[:k]
+
+
+# def load_dlrm_recommender(model_source: str = "latest") -> DLRMBookRecommender:
+#     """
+#     Load DLRM recommender from various sources
+    
+#     Args:
+#         model_source: "latest" for latest MLflow run, "file" for local file, or specific run_id
+        
+#     Returns:
+#         DLRMBookRecommender instance
+#     """
+#     # Check if we're in CPU-only mode
+#     cpu_only = os.environ.get('CPU_ONLY', 'false').lower() == 'true'
+#     if cpu_only:
+#         print("🔄 Loading recommender in CPU-only mode")
+#         # In CPU-only mode, just return a basic recommender instance
+#         return DLRMBookRecommender()
+    
+#     # Create recommender instance
+#     recommender = DLRMBookRecommender()
+    
+#     # If torchrec is not available, return limited recommender
+#     if not TORCHREC_AVAILABLE:
+#         print("⚠️ torchrec not available, returning limited recommender")
+#         return recommender
+    
+#     if model_source == "latest":
+#         # Try to get latest MLflow run
+#         try:
+#             experiment = mlflow.get_experiment_by_name('dlrm-book-recommendation-book_recommender')
+#             if experiment:
+#                 runs = mlflow.search_runs(experiment_ids=[experiment.experiment_id],
+#                                         order_by=["start_time desc"], max_results=1)
+#                 if len(runs) > 0:
+#                     latest_run_id = runs.iloc[0].run_id
+#                     recommender = DLRMBookRecommender(run_id=latest_run_id)
+#                     return recommender
+#         except Exception as e:
+#             print(f"⚠️ Error loading from MLflow: {e}")
+    
+#     elif model_source == "file":
+#         # Try to load from local file
+#         for filename in [
+# '/home/mr-behdadi/PROJECT/ICE/notebooks/dlrm_book_model_final.pth',
+# '/home/mr-behdadi/PROJECT/ICE/notebooks/dlrm_book_model_epoch_2.pth',
+# '/home/mr-behdadi/PROJECT/ICE/notebooks/dlrm_book_model_epoch_0.pth',
+# '/home/mr-behdadi/PROJECT/ICE/notebooks/dlrm_book_model_epoch_1.pth']:
+#             if os.path.exists(filename):
+#                 try:
+#                     recommender = DLRMBookRecommender(model_path=filename)
+#                     return recommender
+#                 except Exception as e:
+#                     print(f"⚠️ Error loading from {filename}: {e}")
+    
+#     else:
+#         # Treat as run_id
+#         try:
+#             recommender = DLRMBookRecommender(run_id=model_source)
+#             return recommender
+#         except Exception as e:
+#             print(f"⚠️ Error loading from run_id {model_source}: {e}")
+    
+#     print("⚠️ Could not load any trained model")
+#     return recommender
+
+
+# def demo_dlrm_recommendations():
+#     """Demo function to show DLRM recommendations"""
+    
+#     print("🚀 DLRM Book Recommendation Demo")
+#     print("=" * 50)
+    
+#     # Load book data for demo
+#     books_df = pd.read_csv('Books.csv', encoding='latin-1', low_memory=False)
+#     users_df = pd.read_csv('Users.csv', encoding='latin-1', low_memory=False)
+#     ratings_df = pd.read_csv('Ratings.csv', encoding='latin-1', low_memory=False)
+    
+#     books_df.columns = books_df.columns.str.replace('"', '')
+#     users_df.columns = users_df.columns.str.replace('"', '')
+#     ratings_df.columns = ratings_df.columns.str.replace('"', '')
+    
+#     # Load recommender
+#     recommender = load_dlrm_recommender("file")
+    
+#     if recommender.model is None:
+#         print("❌ No trained model found. Please run training first.")
+#         return
+    
+#     # Get sample user and books
+#     sample_user_id = ratings_df['User-ID'].iloc[0]
+#     sample_books = books_df['ISBN'].head(20).tolist()
+    
+#     print(f"\n📚 Getting recommendations for User {sample_user_id}")
+#     print(f"Testing with {len(sample_books)} candidate books...")
+    
+#     # Get recommendations
+#     recommendations = recommender.get_user_recommendations(
+#         user_id=sample_user_id,
+#         candidate_books=sample_books,
+#         k=10
+#     )
+    
+#     print(f"\n🎯 Top 10 DLRM Recommendations:")
+#     print("-" * 50)
+    
+#     for i, (book_isbn, score) in enumerate(recommendations, 1):
+#         # Get book info
+#         book_info = books_df[books_df['ISBN'] == book_isbn]
+#         if len(book_info) > 0:
+#             book = book_info.iloc[0]
+#             title = book['Book-Title']
+#             author = book['Book-Author']
+#             print(f"{i:2d}. {title} by {author}")
+#             print(f"    ISBN: {book_isbn}, Score: {score:.4f}")
+#         else:
+#             print(f"{i:2d}. ISBN: {book_isbn}, Score: {score:.4f}")
+#         print()
+    
+#     # Show user's actual ratings for comparison
+#     user_ratings = ratings_df[ratings_df['User-ID'] == sample_user_id]
+#     if len(user_ratings) > 0:
+#         print(f"\n📖 User {sample_user_id}'s Actual Reading History:")
+#         print("-" * 50)
+        
+#         for _, rating in user_ratings.head(5).iterrows():
+#             book_info = books_df[books_df['ISBN'] == rating['ISBN']]
+#             if len(book_info) > 0:
+#                 book = book_info.iloc[0]
+#                 print(f"• {book['Book-Title']} by {book['Book-Author']} - Rating: {rating['Book-Rating']}/10")
+    
+#     # Test book similarity
+#     if len(recommendations) > 0:
+#         target_book = recommendations[0][0]
+#         print(f"\n🔍 Finding books similar to: {target_book}")
+        
+#         similar_books = recommender.get_similar_books(
+#             target_book_isbn=target_book,
+#             candidate_books=sample_books,
+#             sample_users=ratings_df['User-ID'].head(10).tolist(),
+#             k=5
+#         )
+        
+#         print(f"\n📚 Similar Books:")
+#         print("-" * 30)
+#         for i, (book_isbn, similarity) in enumerate(similar_books, 1):
+#             book_info = books_df[books_df['ISBN'] == book_isbn]
+#             if len(book_info) > 0:
+#                 book = book_info.iloc[0]
+#                 print(f"{i}. {book['Book-Title']} (similarity: {similarity:.3f})")
+
+# if __name__ == "__main__":
+#     demo_dlrm_recommendations()
+
+
+"""
+DLRM Inference Engine for Book Recommendations - Hugging Face Space Compatible
+Lightweight version without PyTorch dependencies
+"""
+
+import os
+import sys
+import numpy as np
+import pandas as pd
+import pickle
+from typing import List, Dict, Tuple, Optional, Any
+import warnings
+warnings.filterwarnings('ignore')
+
+# Force CPU-only mode for HF Spaces
+CPU_ONLY = True
+os.environ['CPU_ONLY'] = 'true'
+os.environ['CUDA_VISIBLE_DEVICES'] = ''
+
+print("🔄 Running in HF Spaces CPU-only mode (no PyTorch dependencies)")
+
+class DLRMBookRecommender:
+    """DLRM-based book recommender for inference - HF Spaces compatible"""
+    
+    def __init__(self, model_path: str = None, run_id: str = None):
+        """
+        Initialize DLRM book recommender
         
-        return book_id_encoded, publisher_encoded, decade_encoded, rating_level
+        Args:
+            model_path: Path to saved model state dict (not used in HF Spaces)
+            run_id: MLflow run ID (not used in HF Spaces)
+        """
+        self.device = "cpu"
+        self.model = None
+        self.preprocessing_info = None
+        self.cpu_only = True
+        self.dense_cols = [
+            'Age_normalized', 'Year-Of-Publication', 'user_activity',
+            'book_popularity', 'user_avg_rating', 'book_avg_rating'
+        ]
+        self.cat_cols = [
+            'User-ID', 'ISBN', 'Publisher', 'Country',
+            'Age_Group', 'Publication_Decade', 'Rating_Level'
+        ]
+        self.emb_counts = [1000, 5000, 500, 50, 6, 8, 3]  # Example counts
+        
+        print("✅ DLRM recommender initialized in HF Spaces mode")
+        
+        # Load minimal preprocessing info for demo
+        self._create_demo_preprocessing_info()
+    
+    def _create_demo_preprocessing_info(self):
+        """Create demo preprocessing info for HF Spaces"""
+        self.preprocessing_info = {
+            'dense_cols': self.dense_cols,
+            'cat_cols': self.cat_cols,
+            'emb_counts': self.emb_counts,
+            'total_samples': 100000,
+            'positive_rate': 0.6,
+            'train_samples': 70000,
+            'val_samples': 15000,
+            'test_samples': 15000
+        }
+        
+        # Create mock encoders (for demo purposes)
+        self.user_encoder = MockEncoder()
+        self.book_encoder = MockEncoder()
+        self.publisher_encoder = MockEncoder()
+        self.location_encoder = MockEncoder()
+        self.scaler = MockScaler()
+        
+        print("✅ Demo preprocessing info created")
     
     def predict_rating(self, user_id: int, book_isbn: str, 
                       user_data: Optional[Dict] = None, 
                       book_data: Optional[Dict] = None) -> float:
         """
-        Predict rating probability for user-book pair
+        Predict rating probability for user-book pair using simulation
         
         Args:
             user_id: User ID
@@ -319,43 +697,79 @@ class DLRMBookRecommender:
         Returns:
             Prediction probability (0-1)
         """
-        if self.cpu_only:
-            print("⚠️ Cannot make predictions in CPU-only mode")
-            return 0.5  # Return default neutral prediction
-            
-        if self.model is None:
-            print("❌ Model not loaded")
-            return 0.0
-        
-        if not self.torchrec_available:
-            print("❌ Cannot make predictions without torchrec")
-            return 0.5  # Return default neutral prediction
-        
         try:
-            # Prepare features
-            dense_features, user_id_encoded, country_encoded, age_group = self._prepare_user_features(user_id, user_data)
-            book_id_encoded, publisher_encoded, decade_encoded, rating_level = self._prepare_book_features(book_isbn, book_data)
-            
-            # Create sparse features
-            kjt_values = [user_id_encoded, book_id_encoded, publisher_encoded, country_encoded, age_group, decade_encoded, rating_level]
-            kjt_lengths = [1] * len(kjt_values)
-            
-            sparse_features = KeyedJaggedTensor.from_lengths_sync(
-                self.cat_cols,
-                torch.tensor(kjt_values),
-                torch.tensor(kjt_lengths, dtype=torch.int32),
-            )
-            
-            # Make prediction
-            with torch.no_grad():
-                logits = self.model(dense_features=dense_features, sparse_features=sparse_features)
-                prediction = torch.sigmoid(logits).item()
-            
+            # Simulate DLRM prediction using heuristic approach
+            prediction = self._simulate_dlrm_prediction(user_id, book_isbn, user_data, book_data)
             return prediction
             
         except Exception as e:
             print(f"Error in prediction: {e}")
-            return 0.0
+            return 0.5  # Return neutral prediction on error
+    
+    def _simulate_dlrm_prediction(self, user_id: int, book_isbn: str,
+                                user_data: Optional[Dict] = None,
+                                book_data: Optional[Dict] = None) -> float:
+        """Simulate DLRM prediction using heuristics"""
+        
+        # Use deterministic random based on inputs
+        np.random.seed(hash(f"{user_id}_{book_isbn}") % 2**32)
+        
+        # Base prediction
+        base_score = 0.5
+        
+        # User factors
+        user_age = user_data.get('Age', 30) if user_data else 30
+        age_factor = 0.0
+        if 18 <= user_age <= 25:
+            age_factor = 0.1  # Young adults like popular books
+        elif 26 <= user_age <= 40:
+            age_factor = 0.05  # Adults have varied tastes
+        else:
+            age_factor = -0.05  # Older users are more selective
+        
+        # Book factors
+        book_year = book_data.get('Year-Of-Publication', 2000) if book_data else 2000
+        book_year = int(book_year) if str(book_year).isdigit() else 2000
+        
+        year_factor = 0.0
+        if book_year >= 2010:
+            year_factor = 0.1  # Recent books get slight boost
+        elif book_year >= 2000:
+            year_factor = 0.05
+        elif book_year >= 1990:
+            year_factor = 0.0
+        else:
+            year_factor = -0.1  # Very old books less likely
+        
+        # Publisher factor (simplified)
+        publisher = book_data.get('Publisher', '') if book_data else ''
+        publisher_factor = 0.0
+        popular_publishers = ['penguin', 'random', 'harper', 'simon', 'macmillan']
+        if any(pub in publisher.lower() for pub in popular_publishers):
+            publisher_factor = 0.08
+        
+        # User-book interaction simulation
+        interaction_factor = np.random.uniform(-0.15, 0.15)
+        
+        # Genre preference simulation (based on book title/publisher)
+        genre_factor = np.random.uniform(-0.1, 0.1)
+        
+        # Combine all factors
+        final_score = (base_score + 
+                      age_factor + 
+                      year_factor + 
+                      publisher_factor + 
+                      interaction_factor + 
+                      genre_factor)
+        
+        # Add some controlled randomness
+        noise = np.random.uniform(-0.05, 0.05)
+        final_score += noise
+        
+        # Clamp to valid range
+        final_score = max(0.0, min(1.0, final_score))
+        
+        return final_score
     
     def get_user_recommendations(self, user_id: int, 
                                candidate_books: List[str],
@@ -373,14 +787,10 @@ class DLRMBookRecommender:
         Returns:
             List of (book_isbn, prediction_score) tuples
         """
-        if self.cpu_only or self.model is None or not self.torchrec_available:
-            print("❌ Model not loaded, CPU-only mode, or torchrec not available")
-            return []
+        print(f"Generating simulated recommendations for user {user_id} from {len(candidate_books)} candidates...")
         
         recommendations = []
         
-        print(f"Generating recommendations for user {user_id} from {len(candidate_books)} candidates...")
-        
         for book_isbn in candidate_books:
             score = self.predict_rating(user_id, book_isbn, user_data)
             recommendations.append((book_isbn, score))
@@ -447,117 +857,108 @@ class DLRMBookRecommender:
             if len(scores) > 0:
                 scores_array = np.array(scores)
                 # Calculate correlation as similarity measure
-                correlation = np.corrcoef(target_scores, scores_array)[0, 1]
-                if not np.isnan(correlation):
-                    similarities.append((book_isbn, correlation))
+                if len(scores_array) > 1:
+                    correlation = np.corrcoef(target_scores, scores_array)[0, 1]
+                    if not np.isnan(correlation):
+                        similarities.append((book_isbn, correlation))
+                else:
+                    # Fallback similarity measure
+                    similarity = 1.0 - abs(target_scores[0] - scores_array[0])
+                    similarities.append((book_isbn, similarity))
         
         # Sort by similarity and return top-k
         similarities.sort(key=lambda x: x[1], reverse=True)
         return similarities[:k]
 
 
-def load_dlrm_recommender(model_source: str = "latest") -> DLRMBookRecommender:
+class MockEncoder:
+    """Mock encoder for demo purposes"""
+    
+    def __init__(self):
+        self.classes_ = []
+    
+    def transform(self, values):
+        """Mock transform that returns hash-based encoding"""
+        return [hash(str(val)) % 1000 for val in values]
+
+
+class MockScaler:
+    """Mock scaler for demo purposes"""
+    
+    def transform(self, X):
+        """Mock transform that returns normalized values"""
+        X = np.array(X)
+        # Simple min-max normalization simulation
+        return (X - X.min()) / (X.max() - X.min() + 1e-8)
+
+
+def load_dlrm_recommender(model_source: str = "demo") -> DLRMBookRecommender:
     """
-    Load DLRM recommender from various sources
+    Load DLRM recommender for HF Spaces
     
     Args:
-        model_source: "latest" for latest MLflow run, "file" for local file, or specific run_id
+        model_source: Always returns demo version in HF Spaces
         
     Returns:
         DLRMBookRecommender instance
     """
-    # Check if we're in CPU-only mode
-    cpu_only = os.environ.get('CPU_ONLY', 'false').lower() == 'true'
-    if cpu_only:
-        print("🔄 Loading recommender in CPU-only mode")
-        # In CPU-only mode, just return a basic recommender instance
-        return DLRMBookRecommender()
-    
-    # Create recommender instance
-    recommender = DLRMBookRecommender()
-    
-    # If torchrec is not available, return limited recommender
-    if not TORCHREC_AVAILABLE:
-        print("⚠️ torchrec not available, returning limited recommender")
-        return recommender
+    print("🔄 Loading DLRM recommender in HF Spaces demo mode")
     
-    if model_source == "latest":
-        # Try to get latest MLflow run
-        try:
-            experiment = mlflow.get_experiment_by_name('dlrm-book-recommendation-book_recommender')
-            if experiment:
-                runs = mlflow.search_runs(experiment_ids=[experiment.experiment_id],
-                                        order_by=["start_time desc"], max_results=1)
-                if len(runs) > 0:
-                    latest_run_id = runs.iloc[0].run_id
-                    recommender = DLRMBookRecommender(run_id=latest_run_id)
-                    return recommender
-        except Exception as e:
-            print(f"⚠️ Error loading from MLflow: {e}")
-    
-    elif model_source == "file":
-        # Try to load from local file
-        for filename in [
-'/home/mr-behdadi/PROJECT/ICE/notebooks/dlrm_book_model_final.pth',
-'/home/mr-behdadi/PROJECT/ICE/notebooks/dlrm_book_model_epoch_2.pth',
-'/home/mr-behdadi/PROJECT/ICE/notebooks/dlrm_book_model_epoch_0.pth',
-'/home/mr-behdadi/PROJECT/ICE/notebooks/dlrm_book_model_epoch_1.pth']:
-            if os.path.exists(filename):
-                try:
-                    recommender = DLRMBookRecommender(model_path=filename)
-                    return recommender
-                except Exception as e:
-                    print(f"⚠️ Error loading from {filename}: {e}")
-    
-    else:
-        # Treat as run_id
-        try:
-            recommender = DLRMBookRecommender(run_id=model_source)
-            return recommender
-        except Exception as e:
-            print(f"⚠️ Error loading from run_id {model_source}: {e}")
+    # Always return demo version for HF Spaces
+    recommender = DLRMBookRecommender()
     
-    print("⚠️ Could not load any trained model")
+    print("✅ DLRM recommender loaded successfully")
     return recommender
 
 
 def demo_dlrm_recommendations():
     """Demo function to show DLRM recommendations"""
     
-    print("🚀 DLRM Book Recommendation Demo")
+    print("🚀 DLRM Book Recommendation Demo - HF Spaces Version")
     print("=" * 50)
     
-    # Load book data for demo
-    books_df = pd.read_csv('Books.csv', encoding='latin-1', low_memory=False)
-    users_df = pd.read_csv('Users.csv', encoding='latin-1', low_memory=False)
-    ratings_df = pd.read_csv('Ratings.csv', encoding='latin-1', low_memory=False)
+    # Create sample data for demo
+    sample_books_data = {
+        'ISBN': ['0439023483', '0439358078', '0316666343', '0452264464', '0061120081'],
+        'Book-Title': [
+            'The Hunger Games',
+            'Harry Potter and the Chamber of Secrets', 
+            'The Catcher in the Rye',
+            '1984',
+            'To Kill a Mockingbird'
+        ],
+        'Book-Author': [
+            'Suzanne Collins',
+            'J.K. Rowling',
+            'J.D. Salinger', 
+            'George Orwell',
+            'Harper Lee'
+        ],
+        'Year-Of-Publication': [2008, 1999, 1951, 1949, 1960],
+        'Publisher': ['Scholastic', 'Scholastic', 'Little, Brown', 'Signet', 'Harper']
+    }
     
-    books_df.columns = books_df.columns.str.replace('"', '')
-    users_df.columns = users_df.columns.str.replace('"', '')
-    ratings_df.columns = ratings_df.columns.str.replace('"', '')
+    books_df = pd.DataFrame(sample_books_data)
     
     # Load recommender
-    recommender = load_dlrm_recommender("file")
+    recommender = load_dlrm_recommender()
     
-    if recommender.model is None:
-        print("❌ No trained model found. Please run training first.")
-        return
+    # Demo user
+    sample_user_id = 1
+    sample_books = books_df['ISBN'].tolist()
     
-    # Get sample user and books
-    sample_user_id = ratings_df['User-ID'].iloc[0]
-    sample_books = books_df['ISBN'].head(20).tolist()
-    
-    print(f"\n📚 Getting recommendations for User {sample_user_id}")
+    print(f"\n📚 Getting simulated recommendations for User {sample_user_id}")
     print(f"Testing with {len(sample_books)} candidate books...")
     
     # Get recommendations
     recommendations = recommender.get_user_recommendations(
         user_id=sample_user_id,
         candidate_books=sample_books,
-        k=10
+        k=3,
+        user_data={'Age': 25, 'Location': 'New York, USA'}
     )
     
-    print(f"\n🎯 Top 10 DLRM Recommendations:")
+    print(f"\n🎯 Top 3 Simulated DLRM Recommendations:")
     print("-" * 50)
     
     for i, (book_isbn, score) in enumerate(recommendations, 1):
@@ -568,42 +969,13 @@ def demo_dlrm_recommendations():
             title = book['Book-Title']
             author = book['Book-Author']
             print(f"{i:2d}. {title} by {author}")
-            print(f"    ISBN: {book_isbn}, Score: {score:.4f}")
+            print(f"    ISBN: {book_isbn}, Simulated Score: {score:.4f}")
         else:
-            print(f"{i:2d}. ISBN: {book_isbn}, Score: {score:.4f}")
+            print(f"{i:2d}. ISBN: {book_isbn}, Simulated Score: {score:.4f}")
         print()
     
-    # Show user's actual ratings for comparison
-    user_ratings = ratings_df[ratings_df['User-ID'] == sample_user_id]
-    if len(user_ratings) > 0:
-        print(f"\n📖 User {sample_user_id}'s Actual Reading History:")
-        print("-" * 50)
-        
-        for _, rating in user_ratings.head(5).iterrows():
-            book_info = books_df[books_df['ISBN'] == rating['ISBN']]
-            if len(book_info) > 0:
-                book = book_info.iloc[0]
-                print(f"• {book['Book-Title']} by {book['Book-Author']} - Rating: {rating['Book-Rating']}/10")
-    
-    # Test book similarity
-    if len(recommendations) > 0:
-        target_book = recommendations[0][0]
-        print(f"\n🔍 Finding books similar to: {target_book}")
-        
-        similar_books = recommender.get_similar_books(
-            target_book_isbn=target_book,
-            candidate_books=sample_books,
-            sample_users=ratings_df['User-ID'].head(10).tolist(),
-            k=5
-        )
-        
-        print(f"\n📚 Similar Books:")
-        print("-" * 30)
-        for i, (book_isbn, similarity) in enumerate(similar_books, 1):
-            book_info = books_df[books_df['ISBN'] == book_isbn]
-            if len(book_info) > 0:
-                book = book_info.iloc[0]
-                print(f"{i}. {book['Book-Title']} (similarity: {similarity:.3f})")
+    print("✅ Demo completed successfully!")
+
 
 if __name__ == "__main__":
     demo_dlrm_recommendations()