Update src/dlrm_inference.py

src/dlrm_inference.py

@@ -1,692 +1,314 @@
-# """
-# 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_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)
-#             ]
+    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}")
-    
-#     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
+        except Exception as e:
+            print(f"❌ Error loading model from MLflow: {e}")
     
-#     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 []
+    def _prepare_user_features(self, user_id: int, user_data: Optional[Dict] = None) -> Tuple[torch.Tensor, KeyedJaggedTensor]:
+        """Prepare user features for inference"""
         
-#         recommendations = []
+        if user_data is None:
+            # Create default user features
+            user_data = {
+                'User-ID': user_id,
+                'Age': 30,  # Default age
+                'Location': 'usa',  # Default location
+            }
         
-#         print(f"Generating recommendations for user {user_id} from {len(candidate_books)} candidates...")
+        # Encode categorical features
+        try:
+            user_id_encoded = self.user_encoder.transform([str(user_id)])[0]
+        except:
+            # Handle unknown user
+            user_id_encoded = 0
         
-#         for book_isbn in candidate_books:
-#             score = self.predict_rating(user_id, book_isbn, user_data)
-#             recommendations.append((book_isbn, score))
+        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
         
-#         # Sort by score and return top-k
-#         recommendations.sort(key=lambda x: x[1], reverse=True)
-#         return recommendations[:k]
-    
-#     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 = {}
+        # 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)
         
-#         for user_id in user_ids:
-#             results[user_id] = self.get_user_recommendations(user_id, candidate_books, k)
+        # 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 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...")
+        return dense_features, user_id_encoded, country_encoded, age_group
     
-#     # 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
+    def _prepare_book_features(self, book_isbn: str, book_data: Optional[Dict] = None) -> Tuple[int, int, int, int]:
+        """Prepare book features for inference"""
         
-        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")
+        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 using simulation
+        Predict rating probability for user-book pair
         
         Args:
             user_id: User ID
@@ -697,79 +319,43 @@ 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:
-            # Simulate DLRM prediction using heuristic approach
-            prediction = self._simulate_dlrm_prediction(user_id, book_isbn, user_data, book_data)
+            # 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.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
+            return 0.0
     
     def get_user_recommendations(self, user_id: int, 
                                candidate_books: List[str],
@@ -787,10 +373,14 @@ class DLRMBookRecommender:
         Returns:
             List of (book_isbn, prediction_score) tuples
         """
-        print(f"Generating simulated recommendations for user {user_id} from {len(candidate_books)} candidates...")
+        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 []
         
         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))
@@ -857,108 +447,117 @@ class DLRMBookRecommender:
             if len(scores) > 0:
                 scores_array = np.array(scores)
                 # Calculate correlation as similarity measure
-                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))
+                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]
 
 
-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:
+def load_dlrm_recommender(model_source: str = "latest") -> DLRMBookRecommender:
     """
-    Load DLRM recommender for HF Spaces
+    Load DLRM recommender from various sources
     
     Args:
-        model_source: Always returns demo version in HF Spaces
+        model_source: "latest" for latest MLflow run, "file" for local file, or specific run_id
         
     Returns:
         DLRMBookRecommender instance
     """
-    print("🔄 Loading DLRM recommender in HF Spaces demo mode")
-    
-    # Always return demo version for HF Spaces
+    # 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()
     
-    print("✅ DLRM recommender loaded successfully")
+    # 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 - HF Spaces Version")
+    print("🚀 DLRM Book Recommendation Demo")
     print("=" * 50)
     
-    # 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']
-    }
+    # 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 = pd.DataFrame(sample_books_data)
+    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()
+    recommender = load_dlrm_recommender("file")
+    
+    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 simulated recommendations for User {sample_user_id}")
+    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=3,
-        user_data={'Age': 25, 'Location': 'New York, USA'}
+        k=10
     )
     
-    print(f"\n🎯 Top 3 Simulated DLRM Recommendations:")
+    print(f"\n🎯 Top 10 DLRM Recommendations:")
     print("-" * 50)
     
     for i, (book_isbn, score) in enumerate(recommendations, 1):
@@ -969,13 +568,43 @@ def demo_dlrm_recommendations():
             title = book['Book-Title']
             author = book['Book-Author']
             print(f"{i:2d}. {title} by {author}")
-            print(f"    ISBN: {book_isbn}, Simulated Score: {score:.4f}")
+            print(f"    ISBN: {book_isbn}, Score: {score:.4f}")
         else:
-            print(f"{i:2d}. ISBN: {book_isbn}, Simulated Score: {score:.4f}")
+            print(f"{i:2d}. ISBN: {book_isbn}, Score: {score:.4f}")
         print()
     
-    print("✅ Demo completed successfully!")
-
+    # 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()
+    demo_dlrm_recommendations()
+