Collaborative filtering completed

anime_recommender/entity/artifact_entity.py

@@ -10,9 +10,12 @@ class DataIngestionArtifact:
 class DataTransformationArtifact:
     merged_file_path:str
 
-
-    
-
+@dataclass
+class CollaborativeModelArtifact:
+    svd_file_path: Optional[str] = None
+    item_based_knn_file_path: Optional[str] = None
+    user_based_knn_file_path: Optional[str] = None
+ 
 @dataclass
 class ContentBasedModelArtifact:
     cosine_similarity_model_file_path:str

anime_recommender/entity/config_entity.py

@@ -41,6 +41,18 @@ class DataTransformationConfig:
         self.data_transformation_dir:str = os.path.join(training_pipeline_config.artifact_dir,DATA_TRANSFORMATION_DIR)
         self.merged_file_path:str = os.path.join(self.data_transformation_dir,DATA_TRANSFORMATION_TRANSFORMED_DATA_DIR,MERGED_FILE_NAME)
 
+class CollaborativeModelConfig:
+    """
+    Configuration for model training, including paths for trained models.
+    """
+    def __init__(self,training_pipeline_config:TrainingPipelineConfig):
+        """
+        Initialize model trainer paths.
+        """
+        self.model_trainer_dir:str = os.path.join(training_pipeline_config.artifact_dir,MODEL_TRAINER_DIR_NAME)
+        self.svd_trained_model_file_path:str = os.path.join(self.model_trainer_dir,MODEL_TRAINER_COL_TRAINED_MODEL_DIR,MODEL_TRAINER_SVD_TRAINED_MODEL_NAME)
+        self.user_knn_trained_model_file_path:str = os.path.join(self.model_trainer_dir,MODEL_TRAINER_COL_TRAINED_MODEL_DIR,MODEL_TRAINER_USER_KNN_TRAINED_MODEL_NAME)
+        self.item_knn_trained_model_file_path:str = os.path.join(self.model_trainer_dir,MODEL_TRAINER_COL_TRAINED_MODEL_DIR,MODEL_TRAINER_ITEM_KNN_TRAINED_MODEL_NAME)
 
 class ContentBasedModelConfig:
     """

anime_recommender/source/collaborative_recommenders.py

@@ -0,0 +1,73 @@
+import sys
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+from anime_recommender.entity.config_entity import CollaborativeModelConfig
+from anime_recommender.entity.artifact_entity import DataTransformationArtifact, CollaborativeModelArtifact
+from anime_recommender.utils.main_utils.utils import load_csv_data, save_model, load_object
+from anime_recommender.model_trainer.collaborative_filtering import CollaborativeAnimeRecommender
+
+class CollaborativeModelTrainer:
+    """
+    Class to train the model, track metrics, and save the trained model.
+    """
+    def __init__(self, collaborative_model_trainer_config: CollaborativeModelConfig, data_transformation_artifact: DataTransformationArtifact):
+        try:
+            self.collaborative_model_trainer_config = collaborative_model_trainer_config
+            self.data_transformation_artifact = data_transformation_artifact
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+    def initiate_model_trainer(self, model_type: str) -> CollaborativeModelArtifact:
+        try:
+            logging.info("Loading transformed data...")
+            df = load_csv_data(self.data_transformation_artifact.merged_file_path)
+            recommender = CollaborativeAnimeRecommender(df)
+            # recommender.print_unique_user_ids()
+            if model_type == 'svd':
+                logging.info("Training and saving SVD model...")
+                recommender.train_svd()
+                save_model(recommender.svd, self.collaborative_model_trainer_config.svd_trained_model_file_path)
+
+                logging.info("Loading pre-trained SVD model...")
+                svd_model = load_object(self.collaborative_model_trainer_config.svd_trained_model_file_path)
+                svd_recommendations = recommender.get_svd_recommendations(user_id=436, n=10, svd_model=svd_model)
+                logging.info(f"SVD recommendations: {svd_recommendations}")
+                return CollaborativeModelArtifact(
+                    svd_file_path=self.collaborative_model_trainer_config.svd_trained_model_file_path
+                )
+
+            elif model_type == 'item_knn':
+                logging.info("Training and saving KNN item-based model...")
+                recommender.train_knn_item_based()
+                save_model(recommender.knn_item_based, self.collaborative_model_trainer_config.item_knn_trained_model_file_path)
+
+                logging.info("Loading pre-trained item-based KNN model...")
+                item_knn_model = load_object(self.collaborative_model_trainer_config.item_knn_trained_model_file_path)
+                item_based_recommendations = recommender.get_item_based_recommendations(
+                    anime_name='One Piece', n_recommendations=10, knn_item_model=item_knn_model
+                )
+                logging.info(f"Item Based recommendations: {item_based_recommendations}")
+                return CollaborativeModelArtifact(
+                    item_based_knn_file_path=self.collaborative_model_trainer_config.item_knn_trained_model_file_path
+                )
+
+            elif model_type == 'user_knn':
+                logging.info("Training and saving KNN user-based model...")
+                recommender.train_knn_user_based()
+                save_model(recommender.knn_user_based, self.collaborative_model_trainer_config.user_knn_trained_model_file_path)
+
+                logging.info("Loading pre-trained user-based KNN model...")
+                user_knn_model = load_object(self.collaborative_model_trainer_config.user_knn_trained_model_file_path)
+                user_based_recommendations = recommender.get_user_based_recommendations(
+                    user_id=817, n_recommendations=10, knn_user_model=user_knn_model
+                )
+                logging.info(f"User Based recommendations: {user_based_recommendations}")
+                return CollaborativeModelArtifact(
+                    user_based_knn_file_path=self.collaborative_model_trainer_config.user_knn_trained_model_file_path
+                )
+
+            else:
+                raise ValueError("Invalid model_type. Choose from 'svd', 'item_knn', or 'user_knn'.")
+
+        except Exception as e:
+            raise AnimeRecommendorException(f"Error in CollaborativeModelTrainer: {str(e)}", sys)

app.py

@@ -40,10 +40,6 @@ item_based_knn_model_path = hf_hub_download(repo_name, "itembasedknn.pkl")
 user_based_knn_model_path = hf_hub_download(repo_name, "userbasedknn.pkl")
 svd_model_path = hf_hub_download(repo_name, "svd.pkl")
 
-# # Load the models into memory
-# with open(cosine_similarity_model_path, "rb") as f:
-#     cosine_similarity_model = joblib.load(f)
-
 with open(item_based_knn_model_path, "rb") as f:
     item_based_knn_model = joblib.load(f)
 

run_pipeline.py

@@ -2,10 +2,10 @@ import sys
 from anime_recommender.loggers.logging import logging
 from anime_recommender.exception.exception import AnimeRecommendorException
 from anime_recommender.source.data_ingestion import DataIngestion
-from anime_recommender.entity.config_entity import TrainingPipelineConfig,DataIngestionConfig,DataTransformationConfig,ContentBasedModelConfig
-# ,DataTransformationConfig,CollaborativeModelConfig
+from anime_recommender.entity.config_entity import TrainingPipelineConfig,DataIngestionConfig,DataTransformationConfig,CollaborativeModelConfig,ContentBasedModelConfig
+# ,DataTransformationConfig
 from anime_recommender.source.data_transformation import DataTransformation
-# from anime_recommender.source.collaborative_recommenders import CollaborativeModelTrainer
+from anime_recommender.source.collaborative_recommenders import CollaborativeModelTrainer
 from anime_recommender.source.content_based_recommender import ContentBasedModelTrainer 
 # from anime_recommender.source.popularity_based_recommenders import PopularityBasedRecommendor
 
@@ -27,21 +27,21 @@ if __name__ == "__main__":
         logging.info("Data Transformation Completed.")
         print(data_transformation_artifact)
 
-        # # Collaborative Model Training
-        # collaborative_model_trainer_config = CollaborativeModelConfig(training_pipeline_config)
-        # collaborative_model_trainer = CollaborativeModelTrainer(collaborative_model_trainer_config= collaborative_model_trainer_config,data_transformation_artifact=data_transformation_artifact)
-        # logging.info("Initiating Collaborative Model training.")
-        # collaborative_model_trainer_artifact = collaborative_model_trainer.initiate_model_trainer(model_type='svd')
-        # logging.info("Collaborative Model training completed.")
-        # print(collaborative_model_trainer_artifact)
+        # Collaborative Model Training
+        collaborative_model_trainer_config = CollaborativeModelConfig(training_pipeline_config)
+        collaborative_model_trainer = CollaborativeModelTrainer(collaborative_model_trainer_config= collaborative_model_trainer_config,data_transformation_artifact=data_transformation_artifact)
+        logging.info("Initiating Collaborative Model training.")
+        collaborative_model_trainer_artifact = collaborative_model_trainer.initiate_model_trainer(model_type='user_knn')
+        logging.info("Collaborative Model training completed.")
+        print(collaborative_model_trainer_artifact)
 
         # Content Based Model Training
-        content_based_model_trainer_config = ContentBasedModelConfig(training_pipeline_config)
-        content_based_model_trainer = ContentBasedModelTrainer(content_based_model_trainer_config=content_based_model_trainer_config,data_ingestion_artifact=data_ingestion_artifact)
-        logging.info("Initiating Content Based Model training.")
-        content_based_model_trainer_artifact = content_based_model_trainer.initiate_model_trainer()
-        logging.info("Content Based Model training completed.")
-        print(content_based_model_trainer_artifact)
+        # content_based_model_trainer_config = ContentBasedModelConfig(training_pipeline_config)
+        # content_based_model_trainer = ContentBasedModelTrainer(content_based_model_trainer_config=content_based_model_trainer_config,data_ingestion_artifact=data_ingestion_artifact)
+        # logging.info("Initiating Content Based Model training.")
+        # content_based_model_trainer_artifact = content_based_model_trainer.initiate_model_trainer()
+        # logging.info("Content Based Model training completed.")
+        # print(content_based_model_trainer_artifact)
 
         # # Popularity Based Filtering
         # logging.info("Initiating Popularity based filtering.")