Updated all files

.gitignore

@@ -1,5 +1,5 @@
-ars/ 
-.env
-Artifacts/
-logs/
+anime/ 
+.env
+Artifacts/
+logs/
 __pycache__/

Dockerfile

@@ -1,17 +1,17 @@
-# Use the official Python image as a base
-FROM python:3.10-slim-buster
-
-# Set the working directory in the container
-WORKDIR /app
-
-# Copy the app files into the container
-COPY . .
-
-# Install required packages
-RUN pip install -r requirements.txt
-
-# Expose the port that Streamlit uses
-EXPOSE 8501
-
-# Run the Streamlit app
+# Use the official Python image as a base
+FROM python:3.10-slim-buster
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the app files into the container
+COPY . .
+
+# Install required packages
+RUN pip install -r requirements.txt
+
+# Expose the port that Streamlit uses
+EXPOSE 8501
+
+# Run the Streamlit app
 CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

anime_recommender/{source → components}/collaborative_recommender.py

@@ -1,73 +1,91 @@
-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_modelling 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:
+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_modelling import CollaborativeAnimeRecommender
+
+class CollaborativeModelTrainer:
+    """
+    Trains and saves collaborative filtering recommendation models.
+
+    This class supports three types of models:
+    - Singular Value Decomposition (SVD)
+    - Item-based K-Nearest Neighbors (KNN)
+    - User-based K-Nearest Neighbors (KNN)
+    """
+    def __init__(self, collaborative_model_trainer_config: CollaborativeModelConfig, data_transformation_artifact: DataTransformationArtifact):
+        """
+        Initializes the CollaborativeModelTrainer with configuration and transformed data.
+
+        Args:
+            collaborative_model_trainer_config (CollaborativeModelConfig): Configuration settings for model training.
+            data_transformation_artifact (DataTransformationArtifact): Data artifact containing the preprocessed dataset path.
+        """
+        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:
+        """
+        Trains and saves the specified collaborative filtering model. 
+        Args:
+            model_type (str): The type of model to train. 
+                              Choices: 'svd', 'item_knn', 'user_knn'. 
+        Returns:
+            CollaborativeModelArtifact: Object containing the file path of the trained model. 
+        """
+        try:
+            logging.info("Loading transformed data...")
+            df = load_csv_data(self.data_transformation_artifact.merged_file_path)
+            recommender = CollaborativeAnimeRecommender(df) 
+            
+            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)

anime_recommender/{source → components}/content_based_recommender.py

@@ -1,43 +1,58 @@
-import sys
-from anime_recommender.loggers.logging import logging
-from anime_recommender.exception.exception import AnimeRecommendorException
-from anime_recommender.entity.config_entity import ContentBasedModelConfig
-from anime_recommender.entity.artifact_entity import ContentBasedModelArtifact, DataIngestionArtifact
-from anime_recommender.utils.main_utils.utils import load_csv_data
-from anime_recommender.model_trainer.content_based_modelling import ContentBasedRecommender
-from anime_recommender.constant import *
- 
-class ContentBasedModelTrainer:
-    """Class to train the model, track metrics, and save the trained model."""
-
-    def __init__(self, content_based_model_trainer_config: ContentBasedModelConfig, data_ingestion_artifact: DataIngestionArtifact):
-        try:
-            self.content_based_model_trainer_config = content_based_model_trainer_config
-            self.data_ingestion_artifact = data_ingestion_artifact
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
-    def initiate_model_trainer(self) -> ContentBasedModelArtifact:
-        try:
-            logging.info("Loading ingested data...")
-            df = load_csv_data(self.data_ingestion_artifact.feature_store_anime_file_path)
-            logging.info("Training ContentBasedRecommender model...")
-            
-            # Initialize and train the model
-            recommender = ContentBasedRecommender(df=df )
-            
-            # Save the model (TF-IDF and cosine similarity matrix)
-            recommender.save_model(self.content_based_model_trainer_config.cosine_similarity_model_file_path)
-            logging.info("Model saved successfully.")
-            
-            logging.info("Loading saved model to get recommendations...")
-            cosine_recommendations = recommender.get_rec_cosine(title="One Piece", model_path=self.content_based_model_trainer_config.cosine_similarity_model_file_path, n_recommendations=10)
-            logging.info(f"Cosine similarity recommendations: {cosine_recommendations}")
-            
-            # Return artifact with saved model path
-            content_model_trainer_artifact = ContentBasedModelArtifact(
-                cosine_similarity_model_file_path=self.content_based_model_trainer_config.cosine_similarity_model_file_path
-            )
-            return content_model_trainer_artifact
-        except Exception as e:
+import sys
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+from anime_recommender.entity.config_entity import ContentBasedModelConfig
+from anime_recommender.entity.artifact_entity import ContentBasedModelArtifact, DataIngestionArtifact
+from anime_recommender.utils.main_utils.utils import load_csv_data
+from anime_recommender.model_trainer.content_based_modelling import ContentBasedRecommender
+from anime_recommender.constant import *
+ 
+class ContentBasedModelTrainer:  
+    """
+    A class responsible for training and saving the content-based recommender model. 
+    """
+    def __init__(self, content_based_model_trainer_config: ContentBasedModelConfig, data_ingestion_artifact: DataIngestionArtifact):
+        """
+        Initializes the ContentBasedModelTrainer with configuration and data ingestion artifacts.
+
+        Args:
+            content_based_model_trainer_config (ContentBasedModelConfig): Configuration settings for model training.
+            data_ingestion_artifact (DataIngestionArtifact): Data ingestion artifact containing the dataset path.
+        """
+        try:
+            self.content_based_model_trainer_config = content_based_model_trainer_config
+            self.data_ingestion_artifact = data_ingestion_artifact
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+    def initiate_model_trainer(self) -> ContentBasedModelArtifact:
+        """
+        Trains the content-based recommender model using TF-IDF and cosine similarity,
+        saves the trained model, and retrieves recommendations.
+
+        Returns:
+            ContentBasedModelArtifact: Object containing the path to the saved content-based model. 
+        """
+        try:
+            logging.info("Loading ingested data...")
+            df = load_csv_data(self.data_ingestion_artifact.feature_store_anime_file_path)
+            logging.info("Training ContentBasedRecommender model...")
+            
+            # Initialize and train the model
+            recommender = ContentBasedRecommender(df=df )
+            
+            # Save the model (TF-IDF and cosine similarity matrix)
+            recommender.save_model(self.content_based_model_trainer_config.cosine_similarity_model_file_path)
+            logging.info("Model saved successfully.")
+            
+            logging.info("Loading saved model to get recommendations...")
+            cosine_recommendations = recommender.get_rec_cosine(title="One Piece", model_path=self.content_based_model_trainer_config.cosine_similarity_model_file_path, n_recommendations=10)
+            logging.info(f"Cosine similarity recommendations: {cosine_recommendations}")
+            
+            # Return artifact with saved model path
+            content_model_trainer_artifact = ContentBasedModelArtifact(
+                cosine_similarity_model_file_path=self.content_based_model_trainer_config.cosine_similarity_model_file_path
+            )
+            return content_model_trainer_artifact
+        except Exception as e:
             raise AnimeRecommendorException(f"Error in ContentBasedModelTrainer: {str(e)}", sys)

anime_recommender/{source → components}/data_ingestion.py

@@ -1,58 +1,82 @@
-import os
-import sys
-import pandas as pd
-from datasets import load_dataset
-from anime_recommender.loggers.logging import logging
-from anime_recommender.exception.exception import AnimeRecommendorException
-from anime_recommender.entity.config_entity import DataIngestionConfig
-from anime_recommender.entity.artifact_entity import DataIngestionArtifact
-from anime_recommender.utils.main_utils.utils import export_data_to_dataframe
-
-class DataIngestion:
-    def __init__(self, data_ingestion_config: DataIngestionConfig):
-        try:
-            self.data_ingestion_config = data_ingestion_config
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
-    def fetch_data_from_huggingface(self, dataset_path: str, split: str = None) -> pd.DataFrame:
-        try:
-            logging.info(f"Fetching data from Hugging Face dataset: {dataset_path}")
-            # Load dataset from Hugging Face
-            dataset = load_dataset(dataset_path, split=split)
-
-            # Convert dataset to pandas DataFrame
-            df = pd.DataFrame(dataset['train'])
-
-            # Log some information about the data
-            logging.info(f"Shape of the dataframe: {df.shape}")
-            logging.info(f"Column names: {df.columns}")
-            logging.info(f"Preview of the DataFrame:\n{df.head()}")
-            logging.info("Data fetched successfully from Hugging Face.")
-            
-            return df
-
-        except Exception as e:
-            logging.error(f"An error occurred while fetching data: {str(e)}")
-            raise AnimeRecommendorException(e, sys)
-
-    def ingest_data(self) -> DataIngestionArtifact:
-        try:
-            # Load anime and rating data from Hugging Face datasets
-            anime_df = self.fetch_data_from_huggingface(self.data_ingestion_config.anime_filepath)
-            rating_df = self.fetch_data_from_huggingface(self.data_ingestion_config.rating_filepath)
-
-            # Export data to DataFrame
-            export_data_to_dataframe(anime_df, file_path=self.data_ingestion_config.feature_store_anime_file_path)
-            export_data_to_dataframe(rating_df, file_path=self.data_ingestion_config.feature_store_userrating_file_path)
-
-            # Create artifact to store data ingestion info
-            dataingestionartifact = DataIngestionArtifact(
-                feature_store_anime_file_path=self.data_ingestion_config.feature_store_anime_file_path,
-                feature_store_userrating_file_path=self.data_ingestion_config.feature_store_userrating_file_path
-            )
-
-            return dataingestionartifact
-
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
+import sys
+import pandas as pd
+from datasets import load_dataset
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+from anime_recommender.entity.config_entity import DataIngestionConfig
+from anime_recommender.entity.artifact_entity import DataIngestionArtifact
+from anime_recommender.utils.main_utils.utils import export_data_to_dataframe
+
+class DataIngestion:
+    """
+    A class responsible for data ingestion in the anime recommender system.
+
+    This class fetches data from Hugging Face datasets, converts it into pandas DataFrame format, 
+    and exports the processed data to storage for further use in the pipeline.
+    """
+    def __init__(self, data_ingestion_config: DataIngestionConfig):
+        """
+        Initializes the DataIngestion class with the provided configuration.
+
+        Args:
+            data_ingestion_config (DataIngestionConfig): Configuration settings for data ingestion. 
+        """
+        try:
+            self.data_ingestion_config = data_ingestion_config
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+    def fetch_data_from_huggingface(self, dataset_path: str, split: str = None) -> pd.DataFrame:
+        """
+        Fetches a dataset from Hugging Face and converts it into a pandas DataFrame. 
+        Args:
+            dataset_path (str): The path to the Hugging Face dataset.
+            split (str, optional): The dataset split to be fetched (e.g., 'train', 'test'). Defaults to None.
+
+        Returns:
+            pd.DataFrame: The dataset converted into a pandas DataFrame. 
+        """
+        try:
+            logging.info(f"Fetching data from Hugging Face dataset: {dataset_path}")
+            # Load dataset from Hugging Face
+            dataset = load_dataset(dataset_path, split=split)
+
+            # Convert dataset to pandas DataFrame
+            df = pd.DataFrame(dataset['train'])
+
+            # Log some information about the data
+            logging.info(f"Shape of the dataframe: {df.shape}")
+            logging.info(f"Column names: {df.columns}")
+            logging.info(f"Preview of the DataFrame:\n{df.head()}")
+            logging.info("Data fetched successfully from Hugging Face.")
+            
+            return df
+
+        except Exception as e:
+            logging.error(f"An error occurred while fetching data: {str(e)}")
+            raise AnimeRecommendorException(e, sys)
+
+    def ingest_data(self) -> DataIngestionArtifact:
+        """
+        Orchestrates the data ingestion process, fetching datasets and saving them to the feature store. 
+        Returns:
+            DataIngestionArtifact: An artifact containing paths to the ingested datasets. 
+        """
+        try:
+            # Load anime and rating data from Hugging Face datasets
+            anime_df = self.fetch_data_from_huggingface(self.data_ingestion_config.anime_filepath)
+            rating_df = self.fetch_data_from_huggingface(self.data_ingestion_config.rating_filepath)
+
+            # Export data to DataFrame
+            export_data_to_dataframe(anime_df, file_path=self.data_ingestion_config.feature_store_anime_file_path)
+            export_data_to_dataframe(rating_df, file_path=self.data_ingestion_config.feature_store_userrating_file_path)
+
+            # Create artifact to store data ingestion info
+            dataingestionartifact = DataIngestionArtifact(
+                feature_store_anime_file_path=self.data_ingestion_config.feature_store_anime_file_path,
+                feature_store_userrating_file_path=self.data_ingestion_config.feature_store_userrating_file_path
+            ) 
+            return dataingestionartifact
+
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)

anime_recommender/{source → components}/data_transformation.py

@@ -1,115 +1,109 @@
-import sys 
-import numpy as np
-import pandas as pd
-
-from anime_recommender.loggers.logging import logging
-from anime_recommender.exception.exception import AnimeRecommendorException
-from anime_recommender.utils.main_utils.utils import export_data_to_dataframe
-from anime_recommender.constant import *
-from anime_recommender.entity.config_entity import DataTransformationConfig
-from anime_recommender.entity.artifact_entity import DataIngestionArtifact,DataTransformationArtifact
- 
-class DataTransformation:
-    """
-    Class for handling data transformation for energy generation models.
-    """
-    def __init__(self,data_ingestion_artifact:DataIngestionArtifact,data_transformation_config:DataTransformationConfig):
-        """
-        Initializes the DataTransformation class with the given data ingestion and configuration artifacts.
-        
-        Args:
-            data_ingestion_artifact (DataIngestionArtifact): The artifact containing ingested data paths.
-            data_transformation_config (DataTransformationConfig): Configuration object for data transformation.
-        """
-        try:
-            self.data_ingestion_artifact = data_ingestion_artifact
-            self.data_transformation_config = data_transformation_config
-        except Exception as e:
-            raise AnimeRecommendorException(e,sys)
-    
-    @staticmethod
-    def read_data(file_path)->pd.DataFrame:
-        """
-        Reads data from a CSV file.
-
-        Args:
-            file_path (str): Path to the CSV file.
-
-        Returns:
-            pd.DataFrame: The DataFrame containing the data from the CSV file. 
-        """
-        try:
-            return pd.read_csv(file_path)
-        except Exception as e:
-            raise AnimeRecommendorException(e,sys)
-    
-    @staticmethod
-    def merge_data(anime_df: pd.DataFrame, rating_df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Merges the anime and rating DataFrames on 'anime_id'.
-
-        Args:
-            anime_df (pd.DataFrame): DataFrame containing anime information.
-            rating_df (pd.DataFrame): DataFrame containing user rating information.
-
-        Returns:
-            pd.DataFrame: Merged DataFrame on 'anime_id'.
-        """
-        try:
-            merged_df = pd.merge(rating_df, anime_df, on="anime_id", how="inner")
-            logging.info(f"Shape of the Merged dataframe:{merged_df.shape}")
-            logging.info(f"Column names: {merged_df.columns}") 
-            return merged_df
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
-    @staticmethod
-    def clean_filter_data(merged_df: pd.DataFrame) -> pd.DataFrame:
-        """
-        Cleans the merged DataFrame by replacing 'UNKNOWN' with NaN, filling NaN values with median and also filters the data.
-
-        Args:
-            merged_df (pd.DataFrame): Merged DataFrame to clean and filter.
-
-        Returns:
-            pd.DataFrame: Cleaned and Filtered DataFrame with NaN values handled.
-        """
-        try:
-            merged_df['average_rating'].replace('UNKNOWN', np.nan)
-            merged_df['average_rating'] = pd.to_numeric(merged_df['average_rating'], errors='coerce')
-            merged_df['average_rating'].fillna(merged_df['average_rating'].median())
-            merged_df = merged_df[merged_df['average_rating'] > 6]
-            cols_to_drop = [  'username', 'overview', 'type', 'episodes', 'producers',
-                'licensors', 'studios', 'source',   'rank', 'popularity',
-                'favorites', 'scored by', 'members' ]
-            cleaned_df = merged_df.copy()
-            cleaned_df.drop(columns=cols_to_drop, inplace=True)
-            logging.info(f"Shape of the Merged dataframe:{cleaned_df.shape}")
-            logging.info(f"Column names: {cleaned_df.columns}")
-            logging.info(f"Preview of the merged DataFrame:\n{cleaned_df.head()}")
-            return cleaned_df
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-        
-    def initiate_data_transformation(self)->DataTransformationArtifact:
-        """
-        Initiates the data transformation process by reading, transforming, and saving the data.
-
-        Returns:
-            DataTransformationArtifact: The artifact containing paths to the transformed data. 
-        """
-        logging.info("Entering initiate_data_transformation method of DataTransformation class.")
-        try:  
-            anime_df = DataTransformation.read_data(self.data_ingestion_artifact.feature_store_anime_file_path)
-            rating_df = DataTransformation.read_data(self.data_ingestion_artifact.feature_store_userrating_file_path) 
-            merged_df = DataTransformation.merge_data(anime_df, rating_df)
-            transformed_df = DataTransformation.clean_filter_data(merged_df)
-
-            export_data_to_dataframe(transformed_df, self.data_transformation_config.merged_file_path)
-            data_transformation_artifact = DataTransformationArtifact( 
-                merged_file_path=self.data_transformation_config.merged_file_path
-                            )
-            
-            return data_transformation_artifact
-        except Exception as e:
+import sys 
+import numpy as np
+import pandas as pd 
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+from anime_recommender.utils.main_utils.utils import export_data_to_dataframe
+from anime_recommender.constant import *
+from anime_recommender.entity.config_entity import DataTransformationConfig
+from anime_recommender.entity.artifact_entity import DataIngestionArtifact,DataTransformationArtifact
+
+class DataTransformation:
+    """
+    Class for handling data transformation for energy generation models.
+    """
+    def __init__(self,data_ingestion_artifact:DataIngestionArtifact,data_transformation_config:DataTransformationConfig):
+        """
+        Initializes the DataTransformation class with the given data ingestion and configuration artifacts. 
+        Args:
+            data_ingestion_artifact (DataIngestionArtifact): The artifact containing ingested data paths.
+            data_transformation_config (DataTransformationConfig): Configuration object for data transformation.
+        """
+        try:
+            self.data_ingestion_artifact = data_ingestion_artifact
+            self.data_transformation_config = data_transformation_config
+        except Exception as e:
+            raise AnimeRecommendorException(e,sys)
+    
+    @staticmethod
+    def read_data(file_path)->pd.DataFrame:
+        """
+        Reads data from a CSV file. 
+        Args:
+            file_path (str): Path to the CSV file. 
+        Returns:
+            pd.DataFrame: The DataFrame containing the data from the CSV file. 
+        """
+        try:
+            return pd.read_csv(file_path)
+        except Exception as e:
+            raise AnimeRecommendorException(e,sys)
+    
+    @staticmethod
+    def merge_data(anime_df: pd.DataFrame, rating_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Merges the anime and rating DataFrames on 'anime_id'. 
+        Args:
+            anime_df (pd.DataFrame): DataFrame containing anime information.
+            rating_df (pd.DataFrame): DataFrame containing user rating information. 
+        Returns:
+            pd.DataFrame: Merged DataFrame on 'anime_id'.
+        """
+        try:
+            merged_df = pd.merge(rating_df, anime_df, on="anime_id", how="inner")
+            logging.info(f"Shape of the Merged dataframe:{merged_df.shape}")
+            logging.info(f"Column names: {merged_df.columns}") 
+            return merged_df
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+    @staticmethod
+    def clean_filter_data(merged_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Cleans the merged DataFrame by replacing 'UNKNOWN' with NaN, filling NaN values with median and also filters the data.
+
+        Args:
+            merged_df (pd.DataFrame): Merged DataFrame to clean and filter.
+
+        Returns:
+            pd.DataFrame: Cleaned and Filtered DataFrame with NaN values handled.
+        """
+        try:
+            merged_df['average_rating'].replace('UNKNOWN', np.nan)
+            merged_df['average_rating'] = pd.to_numeric(merged_df['average_rating'], errors='coerce')
+            merged_df['average_rating'].fillna(merged_df['average_rating'].median())
+            merged_df = merged_df[merged_df['average_rating'] > 6]
+            cols_to_drop = [  'username', 'overview', 'type', 'episodes', 'producers',
+                'licensors', 'studios', 'source',   'rank', 'popularity',
+                'favorites', 'scored by', 'members' ]
+            cleaned_df = merged_df.copy()
+            cleaned_df.drop(columns=cols_to_drop, inplace=True)
+            logging.info(f"Shape of the Merged dataframe:{cleaned_df.shape}")
+            logging.info(f"Column names: {cleaned_df.columns}")
+            logging.info(f"Preview of the merged DataFrame:\n{cleaned_df.head()}")
+            return cleaned_df
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+        
+    def initiate_data_transformation(self)->DataTransformationArtifact:
+        """
+        Initiates the data transformation process by reading, transforming, and saving the data.
+
+        Returns:
+            DataTransformationArtifact: The artifact containing paths to the transformed data. 
+        """
+        logging.info("Entering initiate_data_transformation method of DataTransformation class.")
+        try:  
+            anime_df = DataTransformation.read_data(self.data_ingestion_artifact.feature_store_anime_file_path)
+            rating_df = DataTransformation.read_data(self.data_ingestion_artifact.feature_store_userrating_file_path) 
+            merged_df = DataTransformation.merge_data(anime_df, rating_df)
+            transformed_df = DataTransformation.clean_filter_data(merged_df)
+
+            export_data_to_dataframe(transformed_df, self.data_transformation_config.merged_file_path)
+            data_transformation_artifact = DataTransformationArtifact( 
+                merged_file_path=self.data_transformation_config.merged_file_path
+                            )
+            
+            return data_transformation_artifact
+        except Exception as e:
             raise AnimeRecommendorException(e,sys)

anime_recommender/{source → components}/top_anime_recommenders.py

@@ -1,53 +1,75 @@
-import sys
-from anime_recommender.exception.exception import AnimeRecommendorException
-from anime_recommender.loggers.logging import logging
-from anime_recommender.utils.main_utils.utils import load_csv_data 
-from anime_recommender.entity.artifact_entity import DataIngestionArtifact
-from anime_recommender.model_trainer.top_anime_filtering import PopularityBasedFiltering 
-
-
-class PopularityBasedRecommendor: 
-
-    def __init__(self,data_ingestion_artifact = DataIngestionArtifact):
-        try:
-            self.data_ingestion_artifact = data_ingestion_artifact
-        except Exception as e:
-            raise AnimeRecommendorException(e,sys)
-        
-    def initiate_model_trainer(self,filter_type:str):
-        try:
-            logging.info("Loading transformed data...")
-            df = load_csv_data(self.data_ingestion_artifact.feature_store_anime_file_path)
-
-            recommender = PopularityBasedFiltering(df)
-
-            if filter_type == 'popular_animes': 
-                popular_animes = recommender.popular_animes(n =10) 
-                logging.info(f"Popular Anime recommendations: {popular_animes}") 
-
-            elif filter_type == 'top_ranked_animes': 
-                top_ranked_animes = recommender.top_ranked_animes(n =10) 
-                logging.info(f"top_ranked_animes recommendations: {top_ranked_animes}")  
-
-            elif filter_type == 'overall_top_rated_animes': 
-                overall_top_rated_animes = recommender.overall_top_rated_animes(n =10) 
-                logging.info(f"overall_top_rated_animes recommendations: {overall_top_rated_animes}") 
-
-            elif filter_type == 'favorite_animes': 
-                favorite_animes = recommender.favorite_animes(n =10) 
-                logging.info(f"favorite_animes recommendations: {favorite_animes}") 
-
-            elif filter_type == 'top_animes_members': 
-                top_animes_members = recommender.top_animes_members(n = 10) 
-                logging.info(f"top_animes_members recommendations: {top_animes_members}") 
-
-            elif filter_type == 'popular_anime_among_members': 
-                popular_anime_among_members = recommender.popular_anime_among_members(n =10) 
-                logging.info(f"popular_anime_among_members recommendations: {popular_anime_among_members}") 
-            
-            elif filter_type == 'top_avg_rated': 
-                top_avg_rated = recommender.top_avg_rated(n =10) 
-                logging.info(f"top_avg_rated recommendations: {top_avg_rated}") 
-
-        except Exception as e:
+import sys
+from anime_recommender.exception.exception import AnimeRecommendorException
+from anime_recommender.loggers.logging import logging
+from anime_recommender.utils.main_utils.utils import load_csv_data 
+from anime_recommender.entity.artifact_entity import DataIngestionArtifact
+from anime_recommender.model_trainer.top_anime_filtering import PopularityBasedFiltering
+ 
+class PopularityBasedRecommendor: 
+    """
+    A class that provides anime recommendations based on different popularity criteria. 
+    """
+    def __init__(self,data_ingestion_artifact = DataIngestionArtifact):
+        """
+        Initializes the PopularityBasedRecommendor with the ingested anime dataset.
+
+        Args:
+            data_ingestion_artifact (DataIngestionArtifact): An artifact containing the feature store file paths. 
+        """
+        try:
+            self.data_ingestion_artifact = data_ingestion_artifact
+        except Exception as e:
+            raise AnimeRecommendorException(e,sys)
+        
+    def initiate_model_trainer(self,filter_type:str):
+        """
+        Trains the popularity-based recommender model and logs the top anime recommendations 
+        based on the specified filter type.
+
+        Args:
+            filter_type (str): The type of filtering to apply. 
+                                Options include:
+                                    - 'popular_animes': Most popular anime based on user engagement.
+                                    - 'top_ranked_animes': Highest ranked anime.
+                                    - 'overall_top_rated_animes': Overall top-rated anime.
+                                    - 'favorite_animes': Most favorited anime.
+                                    - 'top_animes_members': Anime with the highest number of members.
+                                    - 'popular_anime_among_members': Most popular anime among members.
+                                    - 'top_avg_rated': Anime with the highest average ratings.  
+        """
+        try:
+            logging.info("Loading transformed data...")
+            df = load_csv_data(self.data_ingestion_artifact.feature_store_anime_file_path)
+
+            recommender = PopularityBasedFiltering(df)
+
+            if filter_type == 'popular_animes': 
+                popular_animes = recommender.popular_animes(n =10) 
+                logging.info(f"Popular Anime recommendations: {popular_animes}") 
+
+            elif filter_type == 'top_ranked_animes': 
+                top_ranked_animes = recommender.top_ranked_animes(n =10) 
+                logging.info(f"top_ranked_animes recommendations: {top_ranked_animes}")  
+
+            elif filter_type == 'overall_top_rated_animes': 
+                overall_top_rated_animes = recommender.overall_top_rated_animes(n =10) 
+                logging.info(f"overall_top_rated_animes recommendations: {overall_top_rated_animes}") 
+
+            elif filter_type == 'favorite_animes': 
+                favorite_animes = recommender.favorite_animes(n =10) 
+                logging.info(f"favorite_animes recommendations: {favorite_animes}") 
+
+            elif filter_type == 'top_animes_members': 
+                top_animes_members = recommender.top_animes_members(n = 10) 
+                logging.info(f"top_animes_members recommendations: {top_animes_members}") 
+
+            elif filter_type == 'popular_anime_among_members': 
+                popular_anime_among_members = recommender.popular_anime_among_members(n =10) 
+                logging.info(f"popular_anime_among_members recommendations: {popular_anime_among_members}") 
+            
+            elif filter_type == 'top_avg_rated': 
+                top_avg_rated = recommender.top_avg_rated(n =10) 
+                logging.info(f"top_avg_rated recommendations: {top_avg_rated}") 
+
+        except Exception as e:
             raise AnimeRecommendorException(e,sys)

anime_recommender/constant/__init__.py

@@ -1,40 +1,40 @@
-"""
-Defining common constant variables for training pipeline
-"""
-PIPELINE_NAME: str = "AnimeRecommender"
-ARTIFACT_DIR: str = "Artifacts"
-ANIME_FILE_NAME: str = "Animes.csv"
-RATING_FILE_NAME:str = "UserRatings.csv"
-MERGED_FILE_NAME:str = "Anime_UserRatings.csv" 
-
-ANIME_FILE_PATH:str = "krishnaveni76/Animes"
-RATING_FILE_PATH:str = "krishnaveni76/UserRatings"
-ANIMEUSERRATINGS_FILE_PATH:str = "krishnaveni76/Anime_UserRatings"
-MODELS_FILEPATH = "krishnaveni76/anime-recommendation-models"
-
-"""
-Data Ingestion related constant start with DATA_INGESTION VAR NAME
-"""  
-DATA_INGESTION_DIR_NAME: str = "data_ingestion"
-DATA_INGESTION_FEATURE_STORE_DIR: str = "feature_store"
-DATA_INGESTION_INGESTED_DIR: str = "ingested"
-
-"""
-Data Transformation related constant start with DATA_VALIDATION VAR NAME
-"""
-DATA_TRANSFORMATION_DIR:str = "data_transformation"
-DATA_TRANSFORMATION_TRANSFORMED_DATA_DIR:str = "transformed" 
-
-"""
-Model Trainer related constant start with MODEL TRAINER VAR NAME
-""" 
-MODEL_TRAINER_DIR_NAME: str = "trained_models"
-
-MODEL_TRAINER_COL_TRAINED_MODEL_DIR: str = "collaborative_recommenders"
-MODEL_TRAINER_SVD_TRAINED_MODEL_NAME: str = "svd.pkl"
-MODEL_TRAINER_ITEM_KNN_TRAINED_MODEL_NAME: str = "itembasedknn.pkl"
-MODEL_TRAINER_USER_KNN_TRAINED_MODEL_NAME: str = "userbasedknn.pkl"
-
-MODEL_TRAINER_CON_TRAINED_MODEL_DIR:str = "content_based_recommenders"
-MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME:str = "cosine_similarity.pkl" 
+"""
+Defining common constant variables for training pipeline
+"""
+PIPELINE_NAME: str = "AnimeRecommender"
+ARTIFACT_DIR: str = "Artifacts"
+ANIME_FILE_NAME: str = "Animes.csv"
+RATING_FILE_NAME:str = "UserRatings.csv"
+MERGED_FILE_NAME:str = "Anime_UserRatings.csv" 
+
+ANIME_FILE_PATH:str = "krishnaveni76/Animes"
+RATING_FILE_PATH:str = "krishnaveni76/UserRatings"
+ANIMEUSERRATINGS_FILE_PATH:str = "krishnaveni76/Anime_UserRatings"
+MODELS_FILEPATH = "krishnaveni76/anime-recommendation-models"
+
+"""
+Data Ingestion related constant start with DATA_INGESTION VAR NAME
+"""  
+DATA_INGESTION_DIR_NAME: str = "data_ingestion"
+DATA_INGESTION_FEATURE_STORE_DIR: str = "feature_store"
+DATA_INGESTION_INGESTED_DIR: str = "ingested"
+
+"""
+Data Transformation related constant start with DATA_VALIDATION VAR NAME
+"""
+DATA_TRANSFORMATION_DIR:str = "data_transformation"
+DATA_TRANSFORMATION_TRANSFORMED_DATA_DIR:str = "transformed" 
+
+"""
+Model Trainer related constant start with MODEL TRAINER VAR NAME
+""" 
+MODEL_TRAINER_DIR_NAME: str = "trained_models"
+
+MODEL_TRAINER_COL_TRAINED_MODEL_DIR: str = "collaborative_recommenders"
+MODEL_TRAINER_SVD_TRAINED_MODEL_NAME: str = "svd.pkl"
+MODEL_TRAINER_ITEM_KNN_TRAINED_MODEL_NAME: str = "itembasedknn.pkl"
+MODEL_TRAINER_USER_KNN_TRAINED_MODEL_NAME: str = "userbasedknn.pkl"
+
+MODEL_TRAINER_CON_TRAINED_MODEL_DIR:str = "content_based_recommenders"
+MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME:str = "cosine_similarity.pkl" 
  

anime_recommender/entity/artifact_entity.py

@@ -1,21 +1,21 @@
-from dataclasses import dataclass
-from typing import Optional
-
-@dataclass
-class DataIngestionArtifact: 
-    feature_store_anime_file_path:str
-    feature_store_userrating_file_path:str
-
-@dataclass
-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:
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class DataIngestionArtifact: 
+    feature_store_anime_file_path:str
+    feature_store_userrating_file_path:str
+
+@dataclass
+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

@@ -1,66 +1,66 @@
-import os
-from datetime import datetime
-from anime_recommender.constant import *
-
-class TrainingPipelineConfig:
-    """
-    Configuration for the training pipeline, including artifact directory and timestamp.
-    """
-    def __init__(self, timestamp=datetime.now()):
-        """
-        Initialize the configuration with a unique timestamp.
-        """
-        timestamp = timestamp.strftime("%m_%d_%Y_%H_%M_%S")
-        self.pipeline_name = PIPELINE_NAME
-        self.artifact_dir = os.path.join(ARTIFACT_DIR, timestamp)
-        self.model_dir=os.path.join("final_model")
-        self.timestamp: str = timestamp
-
-class DataIngestionConfig:
-    """
-    Configuration for data ingestion, including paths for feature store, train, test, and validation files.
-    """
-    def __init__(self, training_pipeline_config: TrainingPipelineConfig):
-        """
-        Initialize data ingestion paths and parameters.
-        """
-        self.data_ingestion_dir: str = os.path.join(training_pipeline_config.artifact_dir, DATA_INGESTION_DIR_NAME)
-        self.feature_store_anime_file_path: str = os.path.join(self.data_ingestion_dir, DATA_INGESTION_FEATURE_STORE_DIR, ANIME_FILE_NAME) 
-        self.feature_store_userrating_file_path: str = os.path.join(self.data_ingestion_dir, DATA_INGESTION_FEATURE_STORE_DIR, RATING_FILE_NAME)
-        self.anime_filepath: str = ANIME_FILE_PATH
-        self.rating_filepath: str = RATING_FILE_PATH 
-
-class DataTransformationConfig:
-    """
-    Configuration for data transformation, including paths for transformed data and preprocessing objects.
-    """
-    def __init__(self,training_pipeline_config:TrainingPipelineConfig):
-        """
-        Initialize data transformation paths.
-        """
-        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:
-    """
-    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)
+import os
+from datetime import datetime
+from anime_recommender.constant import *
+
+class TrainingPipelineConfig:
+    """
+    Configuration for the training pipeline, including artifact directory and timestamp.
+    """
+    def __init__(self, timestamp=datetime.now()):
+        """
+        Initialize the configuration with a unique timestamp.
+        """
+        timestamp = timestamp.strftime("%m_%d_%Y_%H_%M_%S")
+        self.pipeline_name = PIPELINE_NAME
+        self.artifact_dir = os.path.join(ARTIFACT_DIR, timestamp)
+        self.model_dir=os.path.join("final_model")
+        self.timestamp: str = timestamp
+
+class DataIngestionConfig:
+    """
+    Configuration for data ingestion, including paths for feature store, train, test, and validation files.
+    """
+    def __init__(self, training_pipeline_config: TrainingPipelineConfig):
+        """
+        Initialize data ingestion paths and parameters.
+        """
+        self.data_ingestion_dir: str = os.path.join(training_pipeline_config.artifact_dir, DATA_INGESTION_DIR_NAME)
+        self.feature_store_anime_file_path: str = os.path.join(self.data_ingestion_dir, DATA_INGESTION_FEATURE_STORE_DIR, ANIME_FILE_NAME) 
+        self.feature_store_userrating_file_path: str = os.path.join(self.data_ingestion_dir, DATA_INGESTION_FEATURE_STORE_DIR, RATING_FILE_NAME)
+        self.anime_filepath: str = ANIME_FILE_PATH
+        self.rating_filepath: str = RATING_FILE_PATH 
+
+class DataTransformationConfig:
+    """
+    Configuration for data transformation, including paths for transformed data and preprocessing objects.
+    """
+    def __init__(self,training_pipeline_config:TrainingPipelineConfig):
+        """
+        Initialize data transformation paths.
+        """
+        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:
+    """
+    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.cosine_similarity_model_file_path:str = os.path.join(self.model_trainer_dir,MODEL_TRAINER_CON_TRAINED_MODEL_DIR,MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME)

anime_recommender/exception/exception.py

@@ -1,44 +1,44 @@
-import sys
-
-class AnimeRecommendorException(Exception):
-    """
-    Custom exception class for handling errors in the Energy Generation Prediction project.
-
-    This class captures the error message, file name, and line number where an exception occurred.
-    It is useful for debugging and identifying the source of the error in a structured way.
-    """
-    def __init__(self,error_message, error_details:sys):
-        """
-        Initialize the EnergyGenerationException instance.
-
-        Args:
-            error_message (str): The error message describing the exception.
-            error_details (sys): The sys module, used to extract exception details.
-
-        Attributes:
-            error_message (str): Stores the original error message.
-            lineno (int): The line number where the exception occurred.
-            file_name (str): The file name where the exception occurred.
-        """
-        self.error_message = error_message
-        _,_,exc_tb = error_details.exc_info()
-
-        self.lineno = exc_tb.tb_lineno
-        self.file_name = exc_tb.tb_frame.f_code.co_filename
-
-    def __str__(self):
-        """
-        Return the formatted error message.
-
-        Returns:
-            str: A string containing the file name, line number, and error message.
-        """
-        return "Error occured in python script name [{0}] line number [{1}] error message [{2}]".format(
-            self.file_name,self.lineno, str(self.error_message))
-    
-if __name__=="__main__":
-    try: 
-        a = 1/0  # This example will raise a ZeroDivisionError
-        print("This will not be printed",a)
-    except Exception as e:
+import sys
+
+class AnimeRecommendorException(Exception):
+    """
+    Custom exception class for handling errors in the Energy Generation Prediction project.
+
+    This class captures the error message, file name, and line number where an exception occurred.
+    It is useful for debugging and identifying the source of the error in a structured way.
+    """
+    def __init__(self,error_message, error_details:sys):
+        """
+        Initialize the EnergyGenerationException instance.
+
+        Args:
+            error_message (str): The error message describing the exception.
+            error_details (sys): The sys module, used to extract exception details.
+
+        Attributes:
+            error_message (str): Stores the original error message.
+            lineno (int): The line number where the exception occurred.
+            file_name (str): The file name where the exception occurred.
+        """
+        self.error_message = error_message
+        _,_,exc_tb = error_details.exc_info()
+
+        self.lineno = exc_tb.tb_lineno
+        self.file_name = exc_tb.tb_frame.f_code.co_filename
+
+    def __str__(self):
+        """
+        Return the formatted error message.
+
+        Returns:
+            str: A string containing the file name, line number, and error message.
+        """
+        return "Error occured in python script name [{0}] line number [{1}] error message [{2}]".format(
+            self.file_name,self.lineno, str(self.error_message))
+    
+if __name__=="__main__":
+    try: 
+        a = 1/0  # This example will raise a ZeroDivisionError
+        print("This will not be printed",a)
+    except Exception as e:
         raise AnimeRecommendorException(e,sys) 

anime_recommender/loggers/logging.py

@@ -1,16 +1,16 @@
-import os
-import logging
-from datetime import datetime
-
-LOGS_FILE = f"{datetime.now().strftime('%m_%d_%Y_%H_%M_%S')}.log"
- 
-logs_dir = os.path.join(os.getcwd(), "logs")
-os.makedirs(logs_dir, exist_ok=True)
-  
-LOGS_FILE_PATH = os.path.join(logs_dir,LOGS_FILE)
-
-logging.basicConfig(
-    filename= LOGS_FILE_PATH,
-    format="[ %(asctime)s ] %(lineno)d %(name)s - %(levelname)s - %(message)s",
-    level= logging.INFO,
+import os
+import logging
+from datetime import datetime
+
+LOGS_FILE = f"{datetime.now().strftime('%m_%d_%Y_%H_%M_%S')}.log"
+ 
+logs_dir = os.path.join(os.getcwd(), "logs")
+os.makedirs(logs_dir, exist_ok=True)
+  
+LOGS_FILE_PATH = os.path.join(logs_dir,LOGS_FILE)
+
+logging.basicConfig(
+    filename= LOGS_FILE_PATH,
+    format="[ %(asctime)s ] %(lineno)d %(name)s - %(levelname)s - %(message)s",
+    level= logging.INFO,
 )

anime_recommender/model_trainer/collaborative_modelling.py

@@ -1,183 +1,263 @@
-import sys  
-import pandas as pd
-from anime_recommender.loggers.logging import logging
-from anime_recommender.exception.exception import AnimeRecommendorException
- 
-from surprise import Reader, Dataset, SVD
-from surprise.model_selection import cross_validate
-from scipy.sparse import csr_matrix
-from sklearn.neighbors import NearestNeighbors
-from collections import Counter
-
-class CollaborativeAnimeRecommender:
-    def __init__(self, df):
-        self.df = df
-        self.svd = None
-        self.knn_item_based = None
-        self.knn_user_based = None
-        self.prepare_data()
- 
-
-    def prepare_data(self): 
-        self.df = self.df.drop_duplicates()
-        reader = Reader(rating_scale=(1, 10))
-        self.data = Dataset.load_from_df(self.df[['user_id', 'anime_id', 'rating']], reader)
-        self.anime_pivot = self.df.pivot_table(index='name', columns='user_id', values='rating').fillna(0)
-        self.user_pivot = self.df.pivot_table(index='user_id', columns='name', values='rating').fillna(0)
-
-    def train_svd(self):
-        self.svd = SVD()
-        cross_validate(self.svd, self.data, cv=5)
-        trainset = self.data.build_full_trainset()
-        self.svd.fit(trainset)  
-
-    def train_knn_item_based(self):
-        item_user_matrix = csr_matrix(self.anime_pivot.values)
-        self.knn_item_based = NearestNeighbors(metric='cosine', algorithm='brute')
-        self.knn_item_based.fit(item_user_matrix) 
-
-    def train_knn_user_based(self):
-        """Train the KNN model for user-based recommendations."""
-        user_item_matrix = csr_matrix(self.user_pivot.values)
-        self.knn_user_based = NearestNeighbors(metric='cosine', algorithm='brute')
-        self.knn_user_based.fit(user_item_matrix)  
- 
-    def print_unique_user_ids(self):
-        """Print unique user IDs from the dataset."""
-        unique_user_ids = self.df['user_id'].unique()
-        logging.info(f"Unique User IDs: {unique_user_ids}")
-        return unique_user_ids
-    
-    def get_svd_recommendations(self, user_id, n=10, svd_model=None): 
-        # Use the provided SVD model or the trained self.svd model
-        svd_model = svd_model or self.svd
-        if svd_model is None:
-            raise ValueError("SVD model is not provided or trained.")
-
-        # Ensure user exists in the dataset
-        if user_id not in self.df['user_id'].unique():
-            return f"User ID '{user_id}' not found in the dataset."
-
-        # Get unique anime IDs
-        anime_ids = self.df['anime_id'].unique()
-
-        # Predict ratings for all anime for the given user
-        predictions = [(anime_id, svd_model.predict(user_id, anime_id).est) for anime_id in anime_ids]
-        predictions.sort(key=lambda x: x[1], reverse=True)
-
-        # Extract top N anime IDs
-        recommended_anime_ids = [pred[0] for pred in predictions[:n]]
-
-        # Get details of recommended anime
-        recommended_anime = self.df[self.df['anime_id'].isin(recommended_anime_ids)].drop_duplicates(subset='anime_id')
-        logging.info(f"Shape of recommended_anime: {recommended_anime.shape}")
-        # Limit to N recommendations
-        recommended_anime = recommended_anime.head(n)
-
-        return pd.DataFrame({
-            'Anime Name': recommended_anime['name'].values,
-            'Genres': recommended_anime['genres'].values,
-            'Image URL': recommended_anime['image url'].values,
-            'Rating': recommended_anime['average_rating'].values
-        })
- 
-    def get_item_based_recommendations(self, anime_name, n_recommendations=10, knn_item_model=None):
-        # Use the provided model or fall back to self.knn_item_based
-        knn_item_based = knn_item_model or self.knn_item_based
-        if knn_item_based is None:
-            raise ValueError("Item-based KNN model is not provided or trained.")
-
-        # Ensure the anime name exists in the pivot table
-        if anime_name not in self.anime_pivot.index:
-            return f"Anime title '{anime_name}' not found in the dataset."
-
-        # Get the index of the anime in the pivot table
-        query_index = self.anime_pivot.index.get_loc(anime_name)
-
-        # Use the KNN model to find similar animes (n_neighbors + 1 to exclude the query itself)
-        distances, indices = knn_item_based.kneighbors(
-            self.anime_pivot.iloc[query_index, :].values.reshape(1, -1),
-            n_neighbors=n_recommendations + 1  # +1 because the query anime itself is included
-        ) 
-        recommendations = []
-        for i in range(1, len(distances.flatten())):  # Start from 1 to exclude the query anime
-            anime_title = self.anime_pivot.index[indices.flatten()[i]]
-            distance = distances.flatten()[i]
-            recommendations.append((anime_title, distance))
-
-        # Fetch the recommended anime names (top n_recommendations)
-        recommended_anime_titles = [rec[0] for rec in recommendations]
-        logging.info(f"Top {n_recommendations} recommendations: {recommended_anime_titles}")
-        filtered_df = self.df[self.df['name'].isin(recommended_anime_titles)].drop_duplicates(subset='name')
-        logging.info(f"Shape of filtered df: {filtered_df.shape}")
-        # Limit the results to `n_recommendations`
-        filtered_df = filtered_df.head(n_recommendations)
-
-        return pd.DataFrame({
-            'Anime Name': filtered_df['name'].values,
-            'Image URL': filtered_df['image url'].values,
-            'Genres': filtered_df['genres'].values,
-            'Rating': filtered_df['average_rating'].values
-        }) 
-
-    def get_user_based_recommendations(self, user_id, n_recommendations=10, knn_user_model=None):
-        """
-        Recommend anime for a given user based on similar users' preferences using the provided or trained KNN model.
-
-        Args:
-            user_id (int): The ID of the user.
-            n_recommendations (int): Number of recommendations to return.
-            knn_user_model (NearestNeighbors, optional): Pre-trained KNN model. Defaults to None.
-
-        Returns:
-            pd.DataFrame: A DataFrame containing recommended anime titles and related information.
-        """
-        # Use the provided model or fall back to self.knn_user_based
-        knn_user_based = knn_user_model or self.knn_user_based
-        if knn_user_based is None:
-            raise ValueError("User-based KNN model is not provided or trained.")
-
-        # Ensure the user exists in the pivot table
-        user_id = float(user_id)  # Convert to match pivot table index type
-        if user_id not in self.user_pivot.index:
-            return f"User ID '{user_id}' not found in the dataset."
-
-        # Find the user's index in the pivot table
-        user_idx = self.user_pivot.index.get_loc(user_id)
-
-        # Use the KNN model to find the nearest neighbors
-        distances, indices = knn_user_based.kneighbors(
-            self.user_pivot.iloc[user_idx, :].values.reshape(1, -1),
-            n_neighbors=n_recommendations + 1  # Include the user itself
-        )
-
-        # Get the list of anime the user has already rated
-        user_rated_anime = set(self.user_pivot.columns[self.user_pivot.iloc[user_idx, :] > 0])
-
-        # Collect all anime rated by the nearest neighbors
-        all_neighbor_ratings = []
-        for i in range(1, len(distances.flatten())):  # Start from 1 to exclude the user itself
-            neighbor_idx = indices.flatten()[i]
-            neighbor_rated_anime = self.user_pivot.iloc[neighbor_idx, :]
-            neighbor_ratings = neighbor_rated_anime[neighbor_rated_anime > 0]
-            all_neighbor_ratings.extend(neighbor_ratings.index)
-
-        # Count how frequently each anime is rated by neighbors
-        anime_counter = Counter(all_neighbor_ratings)
-
-        # Recommend anime not already rated by the user
-        recommendations = [(anime, count) for anime, count in anime_counter.items() if anime not in user_rated_anime]
-        recommendations.sort(key=lambda x: x[1], reverse=True)  # Sort by frequency
-
-        # Extract recommended anime names and their details
-        recommended_anime_titles = [rec[0] for rec in recommendations[:n_recommendations]]
-        filtered_df = self.df[self.df['name'].isin(recommended_anime_titles)].drop_duplicates(subset='name')
-        logging.info(f"Shape of filtered df: {filtered_df.shape}") 
-        filtered_df = filtered_df.head(n_recommendations)
-
-        return pd.DataFrame({
-            'Anime Name': filtered_df['name'].values,
-            'Image URL': filtered_df['image url'].values,
-            'Genres': filtered_df['genres'].values,
-            'Rating': filtered_df['average_rating'].values
-        })
+import pandas as pd
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+
+from surprise import Reader, Dataset, SVD
+from surprise.model_selection import cross_validate
+from scipy.sparse import csr_matrix
+from sklearn.neighbors import NearestNeighbors
+from collections import Counter
+
+class CollaborativeAnimeRecommender:
+    """
+    A collaborative filtering-based anime recommender system that supports:
+    - Singular Value Decomposition (SVD)
+    - Item-based KNN
+    - User-based KNN
+    """
+    def __init__(self, df):
+        """
+        Initializes the recommender system with a given dataset.
+        
+        Args:
+            df (pd.DataFrame): DataFrame containing anime ratings with 'user_id', 'anime_id', 'rating', etc.
+        """
+        try:
+            logging.info("Initializing CollaborativeAnimeRecommender")
+            self.df = df
+            self.svd = None
+            self.knn_item_based = None
+            self.knn_user_based = None
+            self.prepare_data()
+        except Exception as e:
+            raise AnimeRecommendorException(e)
+  
+    def prepare_data(self):
+        """
+        Prepares data for training.
+        """
+        try:
+            self.df = self.df.drop_duplicates()
+            reader = Reader(rating_scale=(1, 10))
+            self.data = Dataset.load_from_df(self.df[['user_id', 'anime_id', 'rating']], reader)
+            self.anime_pivot = self.df.pivot_table(index='name', columns='user_id', values='rating').fillna(0)
+            self.user_pivot = self.df.pivot_table(index='user_id', columns='name', values='rating').fillna(0)
+            logging.info("Data preparation completed...")
+        except Exception as e:
+            raise AnimeRecommendorException(e) 
+
+    def train_svd(self):
+        """
+        Trains the Singular Value Decomposition (SVD) model using Surprise.
+        """
+        try:
+            logging.info("Training SVD model")
+            self.svd = SVD()
+            cross_validate(self.svd, self.data, cv=5)
+            trainset = self.data.build_full_trainset()
+            self.svd.fit(trainset)
+            logging.info("SVD model training completed")
+        except Exception as e:
+            raise AnimeRecommendorException(e)
+ 
+    def train_knn_item_based(self):
+        """
+        Trains an item-based KNN model using cosine similarity.
+        """
+        try:
+            logging.info("Training KNN model")
+            item_user_matrix = csr_matrix(self.anime_pivot.values)
+            self.knn_item_based = NearestNeighbors(metric='cosine', algorithm='brute')
+            self.knn_item_based.fit(item_user_matrix)
+        except Exception as e:
+            raise AnimeRecommendorException(e) 
+        
+    def train_knn_user_based(self):
+        """Train the KNN model for user-based recommendations."""
+        try:
+            logging.info("Training KNN model")
+            user_item_matrix = csr_matrix(self.user_pivot.values)
+            self.knn_user_based = NearestNeighbors(metric='cosine', algorithm='brute')
+            self.knn_user_based.fit(user_item_matrix)
+            logging.info("KNN model training completed")
+        except Exception as e:
+            raise AnimeRecommendorException(e) 
+ 
+    def print_unique_user_ids(self):
+        """
+        Logs and returns unique user IDs in the dataset.
+
+        Returns:
+            np.ndarray: Array of unique user IDs.
+        """
+        try:
+            unique_user_ids = self.df['user_id'].unique()
+            logging.info(f"Unique User IDs: {unique_user_ids}")
+            return unique_user_ids
+        except Exception as e:
+            raise AnimeRecommendorException(e) 
+    
+    def get_svd_recommendations(self, user_id, n=10, svd_model=None)-> pd.DataFrame: 
+        """
+        Generates anime recommendations using the trained SVD model.
+        
+        Args:
+            user_id (int): The user ID for which recommendations are generated.
+            n (int): Number of recommendations to return. Default is 10.
+            svd_model (SVD, optional): Pretrained SVD model. Uses self.svd if not provided.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing recommended anime details.
+        """
+        try:
+            # Use the provided SVD model or the trained self.svd model
+            svd_model = svd_model or self.svd
+            if svd_model is None:
+                raise ValueError("SVD model is not provided or trained.")
+
+            # Ensure user exists in the dataset
+            if user_id not in self.df['user_id'].unique():
+                return f"User ID '{user_id}' not found in the dataset."
+
+            # Get unique anime IDs
+            anime_ids = self.df['anime_id'].unique()
+
+            # Predict ratings for all anime for the given user
+            predictions = [(anime_id, svd_model.predict(user_id, anime_id).est) for anime_id in anime_ids]
+            predictions.sort(key=lambda x: x[1], reverse=True)
+
+            # Extract top N anime IDs
+            recommended_anime_ids = [pred[0] for pred in predictions[:n]]
+
+            # Get details of recommended anime
+            recommended_anime = self.df[self.df['anime_id'].isin(recommended_anime_ids)].drop_duplicates(subset='anime_id')
+            logging.info(f"Shape of recommended_anime: {recommended_anime.shape}")
+            # Limit to N recommendations
+            recommended_anime = recommended_anime.head(n)
+
+            return pd.DataFrame({
+                'Anime Name': recommended_anime['name'].values,
+                'Genres': recommended_anime['genres'].values,
+                'Image URL': recommended_anime['image url'].values,
+                'Rating': recommended_anime['average_rating'].values
+            })
+        except Exception as e:
+            raise AnimeRecommendorException(e)
+           
+    def get_item_based_recommendations(self, anime_name, n_recommendations=10, knn_item_model=None):
+        """
+        Get item-based recommendations for a given anime using a KNN model.
+
+        Args:
+            anime_name (str): The title of the anime for which recommendations are needed.
+            n_recommendations (int): The number of recommendations to return. Defaults to 10.
+            knn_item_model (NearestNeighbors): A trained KNN model. Defaults to None, in which case self.knn_item_based is used.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing recommended anime names, genres, image URLs, and ratings. 
+        """     
+        try:
+            # Use the provided model or fall back to self.knn_item_based
+            knn_item_based = knn_item_model or self.knn_item_based
+            if knn_item_based is None:
+                raise ValueError("Item-based KNN model is not provided or trained.")
+
+            # Ensure the anime name exists in the pivot table
+            if anime_name not in self.anime_pivot.index:
+                return f"Anime title '{anime_name}' not found in the dataset."
+
+            # Get the index of the anime in the pivot table
+            query_index = self.anime_pivot.index.get_loc(anime_name)
+
+            # Use the KNN model to find similar animes (n_neighbors + 1 to exclude the query itself)
+            distances, indices = knn_item_based.kneighbors(
+                self.anime_pivot.iloc[query_index, :].values.reshape(1, -1),
+                n_neighbors=n_recommendations + 1  # +1 because the query anime itself is included
+            ) 
+            recommendations = []
+            for i in range(1, len(distances.flatten())):  # Start from 1 to exclude the query anime
+                anime_title = self.anime_pivot.index[indices.flatten()[i]]
+                distance = distances.flatten()[i]
+                recommendations.append((anime_title, distance))
+
+            # Fetch the recommended anime names (top n_recommendations)
+            recommended_anime_titles = [rec[0] for rec in recommendations]
+            logging.info(f"Top {n_recommendations} recommendations: {recommended_anime_titles}")
+            filtered_df = self.df[self.df['name'].isin(recommended_anime_titles)].drop_duplicates(subset='name')
+            logging.info(f"Shape of filtered df: {filtered_df.shape}")
+            
+            # Limit the results to `n_recommendations`
+            filtered_df = filtered_df.head(n_recommendations)
+
+            return pd.DataFrame({
+                'Anime Name': filtered_df['name'].values,
+                'Image URL': filtered_df['image url'].values,
+                'Genres': filtered_df['genres'].values,
+                'Rating': filtered_df['average_rating'].values
+            })
+        except Exception as e:
+            raise AnimeRecommendorException(e)
+
+    def get_user_based_recommendations(self, user_id, n_recommendations=10, knn_user_model=None)-> pd.DataFrame:
+        """
+        Recommend anime for a given user based on similar users' preferences using the provided or trained KNN model.
+
+        Args:
+            user_id (int): The ID of the user.
+            n_recommendations (int): Number of recommendations to return.
+            knn_user_model (NearestNeighbors): Pre-trained KNN model. Defaults to None.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing recommended anime titles and related information.
+        """
+        try:
+            # Use the provided model or fall back to self.knn_user_based
+            knn_user_based = knn_user_model or self.knn_user_based
+            if knn_user_based is None:
+                raise ValueError("User-based KNN model is not provided or trained.")
+
+            # Ensure the user exists in the pivot table
+            user_id = float(user_id) 
+            if user_id not in self.user_pivot.index:
+                return f"User ID '{user_id}' not found in the dataset."
+
+            # Find the user's index in the pivot table
+            user_idx = self.user_pivot.index.get_loc(user_id)
+
+            # Use the KNN model to find the nearest neighbors
+            distances, indices = knn_user_based.kneighbors(
+                self.user_pivot.iloc[user_idx, :].values.reshape(1, -1),
+                n_neighbors=n_recommendations + 1  # Include the user itself
+            )
+
+            # Get the list of anime the user has already rated
+            user_rated_anime = set(self.user_pivot.columns[self.user_pivot.iloc[user_idx, :] > 0])
+
+            # Collect all anime rated by the nearest neighbors
+            all_neighbor_ratings = []
+            for i in range(1, len(distances.flatten())):  # Start from 1 to exclude the user itself
+                neighbor_idx = indices.flatten()[i]
+                neighbor_rated_anime = self.user_pivot.iloc[neighbor_idx, :]
+                neighbor_ratings = neighbor_rated_anime[neighbor_rated_anime > 0]
+                all_neighbor_ratings.extend(neighbor_ratings.index)
+
+            # Count how frequently each anime is rated by neighbors
+            anime_counter = Counter(all_neighbor_ratings)
+
+            # Recommend anime not already rated by the user
+            recommendations = [(anime, count) for anime, count in anime_counter.items() if anime not in user_rated_anime]
+            recommendations.sort(key=lambda x: x[1], reverse=True)   
+            # Extract recommended anime names and their details
+            recommended_anime_titles = [rec[0] for rec in recommendations[:n_recommendations]]
+            filtered_df = self.df[self.df['name'].isin(recommended_anime_titles)].drop_duplicates(subset='name')
+            logging.info(f"Shape of filtered df: {filtered_df.shape}") 
+            filtered_df = filtered_df.head(n_recommendations)
+
+            return pd.DataFrame({
+                'Anime Name': filtered_df['name'].values,
+                'Image URL': filtered_df['image url'].values,
+                'Genres': filtered_df['genres'].values,
+                'Rating': filtered_df['average_rating'].values
+            })
+        except Exception as e:
+            raise AnimeRecommendorException(e)

anime_recommender/model_trainer/content_based_modelling.py

@@ -1,71 +1,73 @@
-import os
-import pandas as pd 
-from sklearn.feature_extraction.text import TfidfVectorizer 
-from sklearn.metrics.pairwise import  cosine_similarity
-import joblib
-
-
-class ContentBasedRecommender:
-    """
-    A content-based recommender system using TF-IDF Vectorizer and Cosine Similarity.
-    """
-    def __init__(self, df): 
-        try:
-            # Drop missing values from the DataFrame
-            self.df = df.dropna()
-            
-            # Create a Series mapping anime names to their indices
-            self.indices = pd.Series(self.df.index, index=self.df['name']).drop_duplicates()
-            
-            # Initialize and fit the TF-IDF Vectorizer on the 'genres' column
-            self.tfv = TfidfVectorizer(
-                min_df=3,
-                strip_accents='unicode',
-                analyzer='word',
-                token_pattern=r'\w{1,}',
-                ngram_range=(1, 3),
-                stop_words='english'
-            )
-            self.tfv_matrix = self.tfv.fit_transform(self.df['genres'])
-             
-            self.cosine_sim = cosine_similarity(self.tfv_matrix, self.tfv_matrix) 
-
-        except Exception as e:
-            raise e
-    def save_model(self, model_path):
-        """Save the trained model (TF-IDF and Cosine Similarity Matrix) to a file."""
-        try:
-            os.makedirs(os.path.dirname(model_path), exist_ok=True)
-            with open(model_path, 'wb') as f:
-                joblib.dump((self.tfv, self.cosine_sim), f)
-             
-        except Exception as e:
-            raise e
-    def get_rec_cosine(self, title, model_path, n_recommendations=5):
-        """Get recommendations based on cosine similarity for a given anime title."""
-        try:
-            # Load the model (TF-IDF and cosine similarity matrix)
-            with open(model_path, 'rb') as f:
-                self.tfv, self.cosine_sim = joblib.load(f)
-
-            # Check if the DataFrame is loaded
-            if self.df is None:
-                raise ValueError("The DataFrame is not loaded, cannot make recommendations.")
-            
-            if title not in self.indices.index:
-                return f"Anime title '{title}' not found in the dataset."
-            
-            idx = self.indices[title]
-            cosinesim_scores = list(enumerate(self.cosine_sim[idx]))
-            cosinesim_scores = sorted(cosinesim_scores, key=lambda x: x[1], reverse=True)[1:n_recommendations + 1]
-            anime_indices = [i[0] for i in cosinesim_scores]
-            
-            return pd.DataFrame({
-                'Anime name': self.df['name'].iloc[anime_indices].values,
-                'Image URL': self.df['image url'].iloc[anime_indices].values,
-                'Genres': self.df['genres'].iloc[anime_indices].values,
-                'Rating': self.df['average_rating'].iloc[anime_indices].values
-            })
-        except Exception as e: 
-            raise e
+import os
+import pandas as pd 
+from sklearn.feature_extraction.text import TfidfVectorizer 
+from sklearn.metrics.pairwise import  cosine_similarity
+import joblib
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+
+class ContentBasedRecommender:
+    """
+    A content-based recommender system using TF-IDF Vectorizer and Cosine Similarity.
+    """
+    def __init__(self, df): 
+        try: 
+            self.df = df.dropna() 
+            # Create a Series mapping anime names to their indices
+            self.indices = pd.Series(self.df.index, index=self.df['name']).drop_duplicates() 
+            # Initialize and fit the TF-IDF Vectorizer on the 'genres' column
+            self.tfv = TfidfVectorizer(
+                min_df=3,
+                strip_accents='unicode',
+                analyzer='word',
+                token_pattern=r'\w{1,}',
+                ngram_range=(1, 3),
+                stop_words='english'
+            )
+            self.tfv_matrix = self.tfv.fit_transform(self.df['genres']) 
+            self.cosine_sim = cosine_similarity(self.tfv_matrix, self.tfv_matrix)  
+        except Exception as e:
+            raise AnimeRecommendorException(e)
+        
+    def save_model(self, model_path):
+        """Save the trained model (TF-IDF and Cosine Similarity Matrix) to a file."""
+        try:
+            logging.info(f"Saving model to {model_path}")
+            os.makedirs(os.path.dirname(model_path), exist_ok=True)
+            with open(model_path, 'wb') as f:
+                joblib.dump((self.tfv, self.cosine_sim), f)
+            logging.info("Content recommender Model saved successfully")
+        except Exception as e:
+            raise AnimeRecommendorException(e)
+        
+    def get_rec_cosine(self, title, model_path, n_recommendations=5):
+        """Get recommendations based on cosine similarity for a given anime title."""
+        try:
+            logging.info(f"Loading model from {model_path}")
+            # Load the model (TF-IDF and cosine similarity matrix)
+            with open(model_path, 'rb') as f:
+                self.tfv, self.cosine_sim = joblib.load(f)
+            logging.info("Model loaded successfully")
+            # Check if the DataFrame is loaded
+            if self.df is None:
+                logging.error("The DataFrame is not loaded, cannot make recommendations.")
+                raise ValueError("The DataFrame is not loaded, cannot make recommendations.")
+            
+            if title not in self.indices.index:
+                logging.warning(f"Anime title '{title}' not found in dataset")
+                return f"Anime title '{title}' not found in the dataset."
+            
+            idx = self.indices[title]
+            cosinesim_scores = list(enumerate(self.cosine_sim[idx]))
+            cosinesim_scores = sorted(cosinesim_scores, key=lambda x: x[1], reverse=True)[1:n_recommendations + 1]
+            anime_indices = [i[0] for i in cosinesim_scores]
+            logging.info("Recommendations generated successfully")
+            return pd.DataFrame({
+                'Anime name': self.df['name'].iloc[anime_indices].values,
+                'Image URL': self.df['image url'].iloc[anime_indices].values,
+                'Genres': self.df['genres'].iloc[anime_indices].values,
+                'Rating': self.df['average_rating'].iloc[anime_indices].values
+            })
+        except Exception as e:
+            raise AnimeRecommendorException(e)
         

anime_recommender/model_trainer/top_anime_filtering.py

@@ -1,93 +1,104 @@
-import sys
-import numpy as np
-import pandas as pd  
-from anime_recommender.exception.exception import AnimeRecommendorException
-
-class PopularityBasedFiltering:
-    def __init__(self, df):
-        try:
-            self.df = df
-            self.df['average_rating'] = pd.to_numeric(self.df['average_rating'], errors='coerce')
-            self.df['average_rating'].fillna(self.df['average_rating'].median())
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-         
-    def popular_animes(self, n=10):
-        sorted_df = self.df.sort_values(by=['popularity'], ascending=True)
-        top_n_anime = sorted_df.head(n)
-        return pd.DataFrame({
-            'Anime name': top_n_anime['name'].values,
-            'Image URL': top_n_anime['image url'].values,
-            'Genres': top_n_anime['genres'].values,
-            'Rating': top_n_anime['average_rating'].values
-        })
-      
-    def top_ranked_animes(self, n=10):
-        self.df['rank'] = self.df['rank'].replace('UNKNOWN', np.nan).astype(float)
-        df_filtered = self.df[self.df['rank'] > 1]
-        sorted_df = df_filtered.sort_values(by=['rank'], ascending=True)
-        top_n_anime = sorted_df.head(n)
-        return pd.DataFrame({
-            'Anime name': top_n_anime['name'].values,
-            'Image URL': top_n_anime['image url'].values,
-            'Genres': top_n_anime['genres'].values,
-            'Rating': top_n_anime['average_rating'].values
-        }) 
-    
-    def overall_top_rated_animes(self, n=10):
-        sorted_df = self.df.sort_values(by=['average_rating'], ascending=False)
-        top_n_anime = sorted_df.head(n)
-        return pd.DataFrame({
-            'Anime name': top_n_anime['name'].values,
-            'Image URL': top_n_anime['image url'].values,
-            'Genres': top_n_anime['genres'].values,
-            'Rating': top_n_anime['average_rating'].values
-        }) 
-    
-    def favorite_animes(self, n=10):
-        sorted_df = self.df.sort_values(by=['favorites'], ascending=False)
-        top_n_anime = sorted_df.head(n)
-        return pd.DataFrame({
-            'Anime name': top_n_anime['name'].values,
-            'Image URL': top_n_anime['image url'].values,
-            'Genres': top_n_anime['genres'].values,
-            'Rating': top_n_anime['average_rating'].values
-        }) 
-    
-    def top_animes_members(self, n=10):
-        sorted_df = self.df.sort_values(by=['members'], ascending=False)
-        top_n_anime = sorted_df.head(n)
-        return pd.DataFrame({
-            'Anime name': top_n_anime['name'].values,
-            'Image URL': top_n_anime['image url'].values,
-            'Genres': top_n_anime['genres'].values,
-            'Rating': top_n_anime['average_rating'].values
-        })
-    
-    def popular_anime_among_members(self, n=10):
-        sorted_df = self.df.sort_values(by=['members', 'average_rating'], ascending=[False, False]).drop_duplicates(subset='name') 
-        popular_animes = sorted_df.head(n)
-        return pd.DataFrame({
-            'Anime name': popular_animes['name'].values,
-            'Image URL': popular_animes['image url'].values,
-            'Genres': popular_animes['genres'].values,
-            'Rating': popular_animes['average_rating'].values
-        })
-    
-    def top_avg_rated(self, n=10): 
-        self.df['average_rating'] = pd.to_numeric(self.df['average_rating'], errors='coerce')
-        
-        # Replace NaN values with the median
-        median_rating = self.df['average_rating'].median()
-        self.df['average_rating'].fillna(median_rating)
-        # Select top N animes by average rating
-        top_animes = (
-            self.df.drop_duplicates(subset='name')
-                    .nlargest(n, 'average_rating')[['name', 'average_rating', 'image url', 'genres']]
-        )
-        return pd.DataFrame({
-            'Anime name': top_animes['name'].values,
-            'Image URL': top_animes['image url'].values,
-            'Genres': top_animes['genres'].values,
-            'Rating': top_animes['average_rating'].values
+import sys
+import numpy as np
+import pandas as pd 
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+
+class PopularityBasedFiltering:
+    """
+    A recommender system that filters popular animes based on different criteria such as popularity, rank,
+    average rating, number of members, and favorites.
+    """
+    def __init__(self, df):
+        """
+        Initialize the PopularityBasedFiltering class with a DataFrame.
+        """
+        try:
+            logging.info("Initializing PopularityBasedFiltering class")
+            self.df = df
+            self.df['average_rating'] = pd.to_numeric(self.df['average_rating'], errors='coerce')
+            self.df['average_rating'].fillna(self.df['average_rating'].median())
+        except Exception as e:
+            logging.error("Error initializing PopularityBasedFiltering: %s", str(e))
+            raise AnimeRecommendorException(e, sys)
+         
+    def popular_animes(self, n=10):
+        """
+        Get the top N most popular animes.
+        """
+        logging.info("Fetching top %d most popular animes", n)
+        sorted_df = self.df.sort_values(by=['popularity'], ascending=True)
+        top_n_anime = sorted_df.head(n)
+        return self._format_output(top_n_anime)
+    
+    def top_ranked_animes(self, n=10):
+        """
+        Get the top N ranked animes.
+        """
+        logging.info("Fetching top %d ranked animes", n)
+        self.df['rank'] = self.df['rank'].replace('UNKNOWN', np.nan).astype(float)
+        df_filtered = self.df[self.df['rank'] > 1]
+        sorted_df = df_filtered.sort_values(by=['rank'], ascending=True)
+        top_n_anime = sorted_df.head(n)
+        return self._format_output(top_n_anime)
+    
+    def overall_top_rated_animes(self, n=10):
+        """
+        Get the top N highest-rated animes.
+        """
+        logging.info("Fetching top %d highest-rated animes", n)
+        sorted_df = self.df.sort_values(by=['average_rating'], ascending=False)
+        top_n_anime = sorted_df.head(n)
+        return self._format_output(top_n_anime)
+    
+    def favorite_animes(self, n=10):
+        """
+        Get the top N most favorited animes.
+        """
+        logging.info("Fetching top %d most favorited animes", n)
+        sorted_df = self.df.sort_values(by=['favorites'], ascending=False)
+        top_n_anime = sorted_df.head(n)
+        return self._format_output(top_n_anime)
+    
+    def top_animes_members(self, n=10):
+        """
+        Get the top N animes based on the number of members.
+        """
+        logging.info("Fetching top %d animes based on number of members", n)
+        sorted_df = self.df.sort_values(by=['members'], ascending=False)
+        top_n_anime = sorted_df.head(n)
+        return self._format_output(top_n_anime)
+    
+    def popular_anime_among_members(self, n=10):
+        """
+        Get the top N animes popular among members based on the highest number of members and ratings.
+        """
+        logging.info("Fetching top %d popular animes among members", n)
+        sorted_df = self.df.sort_values(by=['members', 'average_rating'], ascending=[False, False]).drop_duplicates(subset='name') 
+        popular_animes = sorted_df.head(n)
+        return self._format_output(popular_animes)
+    
+    def top_avg_rated(self, n=10): 
+        """
+        Get the top N highest-rated animes after handling missing values.
+        """
+        logging.info("Fetching top %d highest average-rated animes", n)
+        self.df['average_rating'] = pd.to_numeric(self.df['average_rating'], errors='coerce')
+        median_rating = self.df['average_rating'].median()
+        self.df['average_rating'].fillna(median_rating)
+        top_animes = (
+            self.df.drop_duplicates(subset='name')
+                    .nlargest(n, 'average_rating')[['name', 'average_rating', 'image url', 'genres']]
+        )
+        return self._format_output(top_animes)
+    
+    def _format_output(self, anime_df):
+        """
+        Format the output as a DataFrame with selected anime attributes.
+        """
+        return pd.DataFrame({
+            'Anime name': anime_df['name'].values,
+            'Image URL': anime_df['image url'].values,
+            'Genres': anime_df['genres'].values,
+            'Rating': anime_df['average_rating'].values
         })

anime_recommender/pipelines/training_pipeline.py

@@ -1,152 +1,152 @@
-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.source.data_transformation import DataTransformation
-from anime_recommender.source.collaborative_recommender import CollaborativeModelTrainer
-from anime_recommender.source.content_based_recommender import ContentBasedModelTrainer
-from anime_recommender.source.top_anime_recommenders import PopularityBasedRecommendor
-from anime_recommender.entity.config_entity import (
-    TrainingPipelineConfig,
-    DataIngestionConfig,
-    DataTransformationConfig,
-    CollaborativeModelConfig,
-    ContentBasedModelConfig,
-)
-from anime_recommender.entity.artifact_entity import (
-    DataIngestionArtifact,
-    DataTransformationArtifact,
-    CollaborativeModelArtifact,
-    ContentBasedModelArtifact,
-)
-
-class TrainingPipeline:
-    """
-    Orchestrates the entire anime recommender training pipeline, including
-    data ingestion, transformation, model training, and popularity-based recommendations.
-    """
-    def __init__(self):
-        """
-        Initialize the TrainingPipeline with required configurations.
-        """
-        self.training_pipeline_config = TrainingPipelineConfig()
-
-    def start_data_ingestion(self) -> DataIngestionArtifact:
-        """
-        Starts the data ingestion process.
-        Returns:
-            DataIngestionArtifact: Contains information about ingested data.
-        """
-        try:
-            logging.info("Initiating Data Ingestion...")
-            data_ingestion_config = DataIngestionConfig(self.training_pipeline_config)
-            data_ingestion = DataIngestion(data_ingestion_config=data_ingestion_config)
-            data_ingestion_artifact = data_ingestion.ingest_data()
-            logging.info(f"Data Ingestion completed: {data_ingestion_artifact}")
-            return data_ingestion_artifact
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
-    def start_data_transformation(self, data_ingestion_artifact: DataIngestionArtifact) -> DataTransformationArtifact:
-        """
-        Starts the data transformation process.
-        Returns:
-            DataTransformationArtifact: Contains transformed data.
-        """
-        try:
-            logging.info("Initiating Data Transformation...")
-            data_transformation_config = DataTransformationConfig(self.training_pipeline_config)
-            data_transformation = DataTransformation(
-                data_ingestion_artifact=data_ingestion_artifact,
-                data_transformation_config=data_transformation_config
-            )
-            data_transformation_artifact = data_transformation.initiate_data_transformation()
-            logging.info(f"Data Transformation completed: {data_transformation_artifact}")
-            return data_transformation_artifact
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
-    def start_collaborative_model_training(self, data_transformation_artifact: DataTransformationArtifact) -> CollaborativeModelArtifact:
-        """
-        Starts collaborative filtering model training.
-        Returns:
-            CollaborativeModelTrainerArtifact: Trained collaborative model artifact.
-        """
-        try:
-            logging.info("Initiating Collaborative Model Training...")
-            collaborative_model_config = CollaborativeModelConfig(self.training_pipeline_config)
-            collaborative_model_trainer = CollaborativeModelTrainer(
-                collaborative_model_trainer_config=collaborative_model_config,
-                data_transformation_artifact=data_transformation_artifact
-            )
-            collaborative_model_trainer_artifact = collaborative_model_trainer.initiate_model_trainer(model_type='user_knn')
-            logging.info(f"Collaborative Model Training completed: {collaborative_model_trainer_artifact}")
-            return collaborative_model_trainer_artifact
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
-    def start_content_based_model_training(self, data_ingestion_artifact: DataIngestionArtifact) -> ContentBasedModelArtifact:
-        """
-        Starts content-based filtering model training.
-        Returns:
-            ContentBasedModelTrainerArtifact: Trained content-based model artifact.
-        """
-        try:
-            logging.info("Initiating Content-Based Model Training...")
-            content_based_model_config = ContentBasedModelConfig(self.training_pipeline_config)
-            content_based_model_trainer = ContentBasedModelTrainer(
-                content_based_model_trainer_config=content_based_model_config,
-                data_ingestion_artifact=data_ingestion_artifact
-            )
-            content_based_model_trainer_artifact = content_based_model_trainer.initiate_model_trainer()
-            logging.info(f"Content-Based Model Training completed: {content_based_model_trainer_artifact}")
-            return content_based_model_trainer_artifact
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
-    def start_popularity_based_filtering(self, data_ingestion_artifact: DataIngestionArtifact):
-        """
-        Generates popularity-based recommendations.
-        """
-        try:
-            logging.info("Initiating Popularity-Based Filtering...")
-            filtering = PopularityBasedRecommendor(data_ingestion_artifact=data_ingestion_artifact)
-            recommendations = filtering.initiate_model_trainer(filter_type='popular_animes')
-            logging.info("Popularity-Based Filtering completed.")
-            return recommendations
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
-    def run_pipeline(self):
-        """
-        Executes the entire training pipeline.
-        """
-        try:
-            # Data Ingestion
-            data_ingestion_artifact = self.start_data_ingestion()
-
-            # Data Transformation
-            data_transformation_artifact = self.start_data_transformation(data_ingestion_artifact)
-
-            # Collaborative Model Training
-            collaborative_model_trainer_artifact = self.start_collaborative_model_training(data_transformation_artifact)
-
-            # Content-Based Model Training
-            content_based_model_trainer_artifact = self.start_content_based_model_training(data_ingestion_artifact)
-
-            # Popularity-Based Filtering
-            popularity_recommendations = self.start_popularity_based_filtering(data_ingestion_artifact)
-
-            logging.info("Training Pipeline executed successfully.")
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
- 
-if __name__ == "__main__":
-    try:
-        pipeline = TrainingPipeline()
-        pipeline.run_pipeline()
-    except Exception as e:
-        logging.error(f"Pipeline execution failed: {str(e)}")
+import sys
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+
+from anime_recommender.components.data_ingestion import DataIngestion
+from anime_recommender.components.data_transformation import DataTransformation
+from anime_recommender.components.collaborative_recommender import CollaborativeModelTrainer
+from anime_recommender.components.content_based_recommender import ContentBasedModelTrainer
+from anime_recommender.components.top_anime_recommenders import PopularityBasedRecommendor
+from anime_recommender.entity.config_entity import (
+    TrainingPipelineConfig,
+    DataIngestionConfig,
+    DataTransformationConfig,
+    CollaborativeModelConfig,
+    ContentBasedModelConfig,
+)
+from anime_recommender.entity.artifact_entity import (
+    DataIngestionArtifact,
+    DataTransformationArtifact,
+    CollaborativeModelArtifact,
+    ContentBasedModelArtifact,
+)
+
+class TrainingPipeline:
+    """
+    Orchestrates the entire anime recommender training pipeline, including
+    data ingestion, transformation, model training, and popularity-based recommendations.
+    """
+    def __init__(self):
+        """
+        Initialize the TrainingPipeline with required configurations.
+        """
+        self.training_pipeline_config = TrainingPipelineConfig()
+
+    def start_data_ingestion(self) -> DataIngestionArtifact:
+        """
+        Starts the data ingestion process.
+        Returns:
+            DataIngestionArtifact: Contains information about ingested data.
+        """
+        try:
+            logging.info("Initiating Data Ingestion...")
+            data_ingestion_config = DataIngestionConfig(self.training_pipeline_config)
+            data_ingestion = DataIngestion(data_ingestion_config=data_ingestion_config)
+            data_ingestion_artifact = data_ingestion.ingest_data()
+            logging.info(f"Data Ingestion completed: {data_ingestion_artifact}")
+            return data_ingestion_artifact
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+    def start_data_transformation(self, data_ingestion_artifact: DataIngestionArtifact) -> DataTransformationArtifact:
+        """
+        Starts the data transformation process.
+        Returns:
+            DataTransformationArtifact: Contains transformed data.
+        """
+        try:
+            logging.info("Initiating Data Transformation...")
+            data_transformation_config = DataTransformationConfig(self.training_pipeline_config)
+            data_transformation = DataTransformation(
+                data_ingestion_artifact=data_ingestion_artifact,
+                data_transformation_config=data_transformation_config
+            )
+            data_transformation_artifact = data_transformation.initiate_data_transformation()
+            logging.info(f"Data Transformation completed: {data_transformation_artifact}")
+            return data_transformation_artifact
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+    def start_collaborative_model_training(self, data_transformation_artifact: DataTransformationArtifact) -> CollaborativeModelArtifact:
+        """
+        Starts collaborative filtering model training.
+        Returns:
+            CollaborativeModelTrainerArtifact: Trained collaborative model artifact.
+        """
+        try:
+            logging.info("Initiating Collaborative Model Training...")
+            collaborative_model_config = CollaborativeModelConfig(self.training_pipeline_config)
+            collaborative_model_trainer = CollaborativeModelTrainer(
+                collaborative_model_trainer_config=collaborative_model_config,
+                data_transformation_artifact=data_transformation_artifact
+            )
+            collaborative_model_trainer_artifact = collaborative_model_trainer.initiate_model_trainer(model_type='user_knn')
+            logging.info(f"Collaborative Model Training completed: {collaborative_model_trainer_artifact}")
+            return collaborative_model_trainer_artifact
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+    def start_content_based_model_training(self, data_ingestion_artifact: DataIngestionArtifact) -> ContentBasedModelArtifact:
+        """
+        Starts content-based filtering model training.
+        Returns:
+            ContentBasedModelTrainerArtifact: Trained content-based model artifact.
+        """
+        try:
+            logging.info("Initiating Content-Based Model Training...")
+            content_based_model_config = ContentBasedModelConfig(self.training_pipeline_config)
+            content_based_model_trainer = ContentBasedModelTrainer(
+                content_based_model_trainer_config=content_based_model_config,
+                data_ingestion_artifact=data_ingestion_artifact
+            )
+            content_based_model_trainer_artifact = content_based_model_trainer.initiate_model_trainer()
+            logging.info(f"Content-Based Model Training completed: {content_based_model_trainer_artifact}")
+            return content_based_model_trainer_artifact
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+    def start_popularity_based_filtering(self, data_ingestion_artifact: DataIngestionArtifact):
+        """
+        Generates popularity-based recommendations.
+        """
+        try:
+            logging.info("Initiating Popularity-Based Filtering...")
+            filtering = PopularityBasedRecommendor(data_ingestion_artifact=data_ingestion_artifact)
+            recommendations = filtering.initiate_model_trainer(filter_type='popular_animes')
+            logging.info("Popularity-Based Filtering completed.")
+            return recommendations
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+    def run_pipeline(self):
+        """
+        Executes the entire training pipeline.
+        """
+        try:
+            # Data Ingestion
+            data_ingestion_artifact = self.start_data_ingestion()
+
+            # Data Transformation
+            data_transformation_artifact = self.start_data_transformation(data_ingestion_artifact)
+
+            # Collaborative Model Training
+            collaborative_model_trainer_artifact = self.start_collaborative_model_training(data_transformation_artifact)
+
+            # Content-Based Model Training
+            content_based_model_trainer_artifact = self.start_content_based_model_training(data_ingestion_artifact)
+
+            # Popularity-Based Filtering
+            popularity_recommendations = self.start_popularity_based_filtering(data_ingestion_artifact)
+
+            logging.info("Training Pipeline executed successfully.")
+        except Exception as e:
+            raise AnimeRecommendorException(e, sys)
+
+ 
+if __name__ == "__main__":
+    try:
+        pipeline = TrainingPipeline()
+        pipeline.run_pipeline()
+    except Exception as e:
+        logging.error(f"Pipeline execution failed: {str(e)}")
         raise AnimeRecommendorException(e, sys)

anime_recommender/utils/main_utils/utils.py

@@ -1,47 +1,89 @@
-import os
-import sys
-import time
-import pandas as pd
-import joblib
-from anime_recommender.loggers.logging import logging
-from anime_recommender.exception.exception import AnimeRecommendorException
-from anime_recommender.constant import * 
-
-def export_data_to_dataframe(dataframe: pd.DataFrame, file_path: str) -> pd.DataFrame:
-        try:
-            logging.info(f"Saving DataFrame to file: {file_path}")
-            dir_path = os.path.dirname(file_path)
-            os.makedirs(dir_path, exist_ok=True)
-            dataframe.to_csv(file_path, index=False, header=True)
-            logging.info(f"DataFrame saved successfully to {file_path}.")
-            return dataframe
-        except Exception as e:
-            raise AnimeRecommendorException(e, sys)
-
-def load_csv_data(file_path: str) -> pd.DataFrame: 
-    try:
-        df = pd.read_csv(file_path)
-        return df 
-    except Exception as e:
-        raise AnimeRecommendorException(e, sys) from e
-
-def save_model(model: object,file_path: str ) -> None:
-    try:
-        logging.info("Entered the save_model method of Main utils class")
-        os.makedirs(os.path.dirname(file_path), exist_ok=True)
-        with open(file_path, "wb") as file_obj:
-            joblib.dump(model, file_obj)
-        logging.info("Completed saving the model object.")
-    except Exception as e:
-        raise AnimeRecommendorException(e, sys) from e
-    
-def load_object(file_path:str)-> object: 
-    try:
-        if not os.path.exists(file_path):
-            raise Exception(f"The file: {file_path} is not exists")
-        with open(file_path,"rb") as file_obj:
-            print(file_obj)
-            return joblib.load(file_obj)
-    except Exception as e:
-        raise AnimeRecommendorException(e,sys) from e
-    
+import os
+import sys 
+import pandas as pd
+import joblib
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+from anime_recommender.constant import * 
+
+def export_data_to_dataframe(dataframe: pd.DataFrame, file_path: str) -> pd.DataFrame:
+    """
+    Saves a given Pandas DataFrame to a CSV file.
+    
+    Args:
+        dataframe (pd.DataFrame): The DataFrame to be saved.
+        file_path (str): The file path where the DataFrame should be stored.
+    
+    Returns:
+        pd.DataFrame: The same DataFrame that was saved.
+    """
+    try:
+        logging.info(f"Saving DataFrame to file: {file_path}")
+        dir_path = os.path.dirname(file_path)
+        os.makedirs(dir_path, exist_ok=True)
+        dataframe.to_csv(file_path, index=False, header=True)
+        logging.info(f"DataFrame saved successfully to {file_path}.")
+        return dataframe
+    except Exception as e:
+        logging.error(f"Error saving DataFrame to {file_path}: {e}")
+        raise AnimeRecommendorException(e, sys)
+
+def load_csv_data(file_path: str) -> pd.DataFrame:
+    """
+    Loads a CSV file into a Pandas DataFrame.
+    
+    Args:
+        file_path (str): The file path of the CSV file.
+    
+    Returns:
+        pd.DataFrame: The loaded DataFrame.
+    """
+    try:
+        logging.info(f"Loading CSV data from file: {file_path}")
+        df = pd.read_csv(file_path)
+        logging.info("CSV file loaded successfully.")
+        return df 
+    except Exception as e:
+        logging.error(f"Error loading CSV file {file_path}: {e}")
+        raise AnimeRecommendorException(e, sys) from e
+
+def save_model(model: object, file_path: str) -> None:
+    """
+    Saves a machine learning model to a file using joblib.
+    
+    Args:
+        model (object): The model object to be saved.
+        file_path (str): The file path where the model should be stored.
+    """
+    try:
+        logging.info("Entered the save_model method.")
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        with open(file_path, "wb") as file_obj:
+            joblib.dump(model, file_obj)
+        logging.info(f"Model saved successfully to {file_path}.")
+    except Exception as e:
+        logging.error(f"Error saving model to {file_path}: {e}")
+        raise AnimeRecommendorException(e, sys) from e
+
+def load_object(file_path: str) -> object:
+    """
+    Loads a model or object from a file using joblib.
+    
+    Args:
+        file_path (str): The file path of the saved model.
+    
+    Returns:
+        object: The loaded model.
+    """
+    try:
+        logging.info(f"Attempting to load object from {file_path}")
+        if not os.path.exists(file_path):
+            error_msg = f"The file: {file_path} does not exist."
+            logging.error(error_msg)
+            raise Exception(error_msg)
+        with open(file_path, "rb") as file_obj:
+            logging.info("Object loaded successfully.")
+            return joblib.load(file_obj)
+    except Exception as e:
+        logging.error(f"Error loading object from {file_path}: {e}")
+        raise AnimeRecommendorException(e, sys) from e

app.py

@@ -1,233 +1,233 @@
-import pandas as pd
-import streamlit as st
-from anime_recommender.model_trainer.content_based_modelling import ContentBasedRecommender
-from anime_recommender.model_trainer.collaborative_modelling import CollaborativeAnimeRecommender
-from anime_recommender.model_trainer.top_anime_filtering import PopularityBasedFiltering
-import joblib
-from anime_recommender.constant import *
-from huggingface_hub import hf_hub_download
-from datasets import load_dataset
-
-st.set_page_config(page_title="Anime Recommendation System", layout="wide")
-
-if "anime_data" not in st.session_state or "anime_user_ratings" not in st.session_state:
-    # Load datasets from Hugging Face (assuming no splits)
-    animedataset = load_dataset(ANIME_FILE_PATH, split=None)
-    mergeddataset = load_dataset(ANIMEUSERRATINGS_FILE_PATH, split=None)
-
-    # Convert the dataset to Pandas DataFrame
-    st.session_state.anime_data = pd.DataFrame(animedataset["train"])
-    st.session_state.anime_user_ratings = pd.DataFrame(mergeddataset["train"]) 
-
-# Load models only once
-if "models_loaded" not in st.session_state:
-    st.session_state.models_loaded = {} 
-    # Load models
-    st.session_state.models_loaded["cosine_similarity_model"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME)
-    st.session_state.models_loaded["item_based_knn_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_ITEM_KNN_TRAINED_MODEL_NAME)
-    st.session_state.models_loaded["user_based_knn_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_USER_KNN_TRAINED_MODEL_NAME)
-    st.session_state.models_loaded["svd_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_SVD_TRAINED_MODEL_NAME)
-
-    # Load the models using joblib
-    with open(st.session_state.models_loaded["item_based_knn_model_path"], "rb") as f:
-        st.session_state.models_loaded["item_based_knn_model"] = joblib.load(f)
-
-    with open(st.session_state.models_loaded["user_based_knn_model_path"], "rb") as f:
-        st.session_state.models_loaded["user_based_knn_model"] = joblib.load(f)
-
-    with open(st.session_state.models_loaded["svd_model_path"], "rb") as f:
-        st.session_state.models_loaded["svd_model"] = joblib.load(f)
-
-    print("Models loaded successfully!")
-
-# Access the data from session state
-anime_data = st.session_state.anime_data 
-anime_user_ratings = st.session_state.anime_user_ratings
-
-# # Display dataset info
-# st.write("Anime Data:")
-# st.dataframe(anime_data.head())
- 
-# st.write("Anime User Ratings Data:")
-# st.dataframe(anime_user_ratings.head())
-  
-# Access the models from session state
-cosine_similarity_model_path = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME)
-item_based_knn_model = st.session_state.models_loaded["item_based_knn_model"]
-user_based_knn_model = st.session_state.models_loaded["user_based_knn_model"]
-svd_model = st.session_state.models_loaded["svd_model"] 
-print("Models loaded successfully!")
-    
-# Streamlit UI
-app_selector = st.sidebar.radio(
-    "Select App", ("Content-Based Recommender", "Collaborative Recommender", "Top Anime Recommender")
-)
-
-if app_selector == "Content-Based Recommender":
-    st.title("Content-Based Recommendation System") 
-    try:
-        
-        anime_list = anime_data["name"].tolist()
-        anime_name = st.selectbox("Pick an anime..unlock similar anime recommendations..", anime_list)
-
-        # Set number of recommendations
-        max_recommendations = min(len(anime_data), 100)
-        n_recommendations = st.slider("Number of Recommendations", 1, max_recommendations, 10)
-
-        # Inject custom CSS for anime name font size
-        st.markdown(
-            """
-            <style>
-            .anime-title {
-                font-size: 14px !important;
-                font-weight: bold;
-                text-align: center;
-                margin-top: 5px;
-            }
-            </style>
-            """,
-            unsafe_allow_html=True,
-        ) 
-        # Get Recommendations
-        if st.button("Get Recommendations"):
-            try:
-                recommender = ContentBasedRecommender(anime_data)
-                recommendations = recommender.get_rec_cosine(anime_name, n_recommendations=n_recommendations,model_path=cosine_similarity_model_path)
-
-                if isinstance(recommendations, str):
-                    st.warning(recommendations)
-                elif recommendations.empty:
-                    st.warning("No recommendations found.")
-                else:
-                    st.write(f"Here are the Content-based Recommendations for {anime_name}:") 
-                    cols = st.columns(5)
-                    for i, row in enumerate(recommendations.iterrows()):
-                        col = cols[i % 5]
-                        with col:
-                            st.image(row[1]['Image URL'], use_container_width=True)
-                            st.markdown(
-                                f"<div class='anime-title'>{row[1]['Anime name']}</div>",
-                                unsafe_allow_html=True,
-                            )
-                            st.caption(f"Genres: {row[1]['Genres']} | Rating: {row[1]['Rating']}") 
-            except Exception as e:
-                st.error(f"Unexpected error: {str(e)}")
- 
-    except Exception as e:
-        st.error(f"Unexpected error: {str(e)}")
-
-elif app_selector == "Collaborative Recommender":
-    st.title("Collaborative Recommender System")
-    
-    try:  
-        # Sidebar for choosing the collaborative filtering method
-        collaborative_method = st.sidebar.selectbox(
-            "Choose a collaborative filtering method:", 
-            ["SVD Collaborative Filtering", "User-Based Collaborative Filtering", "Anime-Based KNN Collaborative Filtering"]
-        )
-
-        # User input
-        if collaborative_method == "SVD Collaborative Filtering" or collaborative_method == "User-Based Collaborative Filtering": 
-            user_ids = anime_user_ratings['user_id'].unique()  
-            user_id = st.selectbox("Choose a user, and we'll show you animes they'd recommend", user_ids) 
-            n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=50, value=10)
-        elif collaborative_method == "Anime-Based KNN Collaborative Filtering": 
-            anime_list = anime_user_ratings["name"].dropna().unique().tolist() 
-            anime_name = st.selectbox("Pick an anime, and we'll suggest more titles you'll love", anime_list)
-            n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=50, value=10)
-   
-        # Get recommendations
-        if st.button("Get Recommendations"):
-            # Load the recommender
-            recommender = CollaborativeAnimeRecommender(anime_user_ratings) 
-            if collaborative_method == "SVD Collaborative Filtering": 
-                recommendations = recommender.get_svd_recommendations(user_id, n=n_recommendations, svd_model=svd_model)  
-            elif collaborative_method == "User-Based Collaborative Filtering": 
-                recommendations = recommender.get_user_based_recommendations(user_id, n_recommendations=n_recommendations, knn_user_model=user_based_knn_model)
-            elif collaborative_method == "Anime-Based KNN Collaborative Filtering":
-                if anime_name: 
-                    recommendations = recommender.get_item_based_recommendations(anime_name, n_recommendations=n_recommendations, knn_item_model=item_based_knn_model)
-                else:
-                    st.error("Invalid Anime Name. Please enter a valid anime title.")
-            
-            if isinstance(recommendations, pd.DataFrame) and not recommendations.empty:
-                if len(recommendations) < n_recommendations:
-                    st.warning(f"Oops...Only {len(recommendations)} recommendations available, fewer than the requested {n_recommendations}.")
-                st.write(f"Here are the Collaborative Recommendations:")
-                cols = st.columns(5)
-                for i, row in enumerate(recommendations.iterrows()):
-                    col = cols[i % 5]
-                    with col:
-                        st.image(row[1]['Image URL'], use_container_width=True)
-                        st.markdown(
-                            f"<div class='anime-title'>{row[1]['Anime Name']}</div>",
-                            unsafe_allow_html=True,
-                        ) 
-                        st.caption(f"Genres: {row[1]['Genres']} | Rating: {row[1]['Rating']}")
-            else:
-                st.error("No recommendations found.")
-    except Exception as e:
-        st.error(f"An error occurred: {e}")
-
-
-elif app_selector == "Top Anime Recommender":
-    st.title("Top Anime Recommender System")
-    
-    try:
-        # Sidebar for choosing the popularity-based filtering method
-        popularity_method = st.sidebar.selectbox(
-            "Choose a Popularity-Based Filtering method:",
-            [
-                "Popular Animes",
-                "Top Ranked Animes",
-                "Overall Top Rated Animes",
-                "Favorite Animes",
-                "Top Animes by Members",
-                "Popular Anime Among Members",
-                "Top Average Rated Animes",
-            ]
-        )
-        
-        n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=500, value=10)
-        
-        if st.button("Get Recommendations"):
-            # Load the popularity-based recommender
-            recommender = PopularityBasedFiltering(anime_data)
-            
-            # Get recommendations based on selected method
-            if popularity_method == "Popular Animes":
-                recommendations = recommender.popular_animes(n=n_recommendations)
-            elif popularity_method == "Top Ranked Animes":
-                recommendations = recommender.top_ranked_animes(n=n_recommendations)
-            elif popularity_method == "Overall Top Rated Animes":
-                recommendations = recommender.overall_top_rated_animes(n=n_recommendations)
-            elif popularity_method == "Favorite Animes":
-                recommendations = recommender.favorite_animes(n=n_recommendations)
-            elif popularity_method == "Top Animes by Members":
-                recommendations = recommender.top_animes_members(n=n_recommendations)
-            elif popularity_method == "Popular Anime Among Members":
-                recommendations = recommender.popular_anime_among_members(n=n_recommendations)
-            elif popularity_method == "Top Average Rated Animes":
-                recommendations = recommender.top_avg_rated(n=n_recommendations)
-            else:
-                st.error("Invalid selection. Please choose a valid method.")
-                recommendations = None
-            
-            # Display recommendations
-            if isinstance(recommendations, pd.DataFrame) and not recommendations.empty:
-                st.write(f"Here are the {popularity_method}:")
-                cols = st.columns(5)
-                for i, row in recommendations.iterrows():
-                    col = cols[i % 5]
-                    with col:
-                        st.image(row['Image URL'], use_container_width=True)
-                        st.markdown(
-                            f"<div class='anime-title'>{row['Anime name']}</div>",
-                            unsafe_allow_html=True,
-                        )
-                        st.caption(f"Genres: {row['Genres']} | Rating: {row['Rating']}")
-            else:
-                st.error("No recommendations found.")
-    except Exception as e:
-        st.error(f"An error occurred: {e}")
-
+import pandas as pd
+import streamlit as st
+from anime_recommender.model_trainer.content_based_modelling import ContentBasedRecommender
+from anime_recommender.model_trainer.collaborative_modelling import CollaborativeAnimeRecommender
+from anime_recommender.model_trainer.top_anime_filtering import PopularityBasedFiltering
+import joblib
+from anime_recommender.constant import *
+from huggingface_hub import hf_hub_download
+from datasets import load_dataset
+
+st.set_page_config(page_title="Anime Recommendation System", layout="wide")
+
+if "anime_data" not in st.session_state or "anime_user_ratings" not in st.session_state:
+    # Load datasets from Hugging Face (assuming no splits)
+    animedataset = load_dataset(ANIME_FILE_PATH, split=None)
+    mergeddataset = load_dataset(ANIMEUSERRATINGS_FILE_PATH, split=None)
+
+    # Convert the dataset to Pandas DataFrame
+    st.session_state.anime_data = pd.DataFrame(animedataset["train"])
+    st.session_state.anime_user_ratings = pd.DataFrame(mergeddataset["train"]) 
+
+# Load models only once
+if "models_loaded" not in st.session_state:
+    st.session_state.models_loaded = {} 
+    # Load models
+    st.session_state.models_loaded["cosine_similarity_model"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME)
+    st.session_state.models_loaded["item_based_knn_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_ITEM_KNN_TRAINED_MODEL_NAME)
+    st.session_state.models_loaded["user_based_knn_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_USER_KNN_TRAINED_MODEL_NAME)
+    st.session_state.models_loaded["svd_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_SVD_TRAINED_MODEL_NAME)
+
+    # Load the models using joblib
+    with open(st.session_state.models_loaded["item_based_knn_model_path"], "rb") as f:
+        st.session_state.models_loaded["item_based_knn_model"] = joblib.load(f)
+
+    with open(st.session_state.models_loaded["user_based_knn_model_path"], "rb") as f:
+        st.session_state.models_loaded["user_based_knn_model"] = joblib.load(f)
+
+    with open(st.session_state.models_loaded["svd_model_path"], "rb") as f:
+        st.session_state.models_loaded["svd_model"] = joblib.load(f)
+
+    print("Models loaded successfully!")
+
+# Access the data from session state
+anime_data = st.session_state.anime_data 
+anime_user_ratings = st.session_state.anime_user_ratings
+
+# # Display dataset info
+# st.write("Anime Data:")
+# st.dataframe(anime_data.head())
+ 
+# st.write("Anime User Ratings Data:")
+# st.dataframe(anime_user_ratings.head())
+  
+# Access the models from session state
+cosine_similarity_model_path = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME)
+item_based_knn_model = st.session_state.models_loaded["item_based_knn_model"]
+user_based_knn_model = st.session_state.models_loaded["user_based_knn_model"]
+svd_model = st.session_state.models_loaded["svd_model"] 
+print("Models loaded successfully!")
+    
+# Streamlit UI
+app_selector = st.sidebar.radio(
+    "Select App", ("Content-Based Recommender", "Collaborative Recommender", "Top Anime Recommender")
+)
+
+if app_selector == "Content-Based Recommender":
+    st.title("Content-Based Recommendation System") 
+    try:
+        
+        anime_list = anime_data["name"].tolist()
+        anime_name = st.selectbox("Pick an anime..unlock similar anime recommendations..", anime_list)
+
+        # Set number of recommendations
+        max_recommendations = min(len(anime_data), 100)
+        n_recommendations = st.slider("Number of Recommendations", 1, max_recommendations, 10)
+
+        # Inject custom CSS for anime name font size
+        st.markdown(
+            """
+            <style>
+            .anime-title {
+                font-size: 14px !important;
+                font-weight: bold;
+                text-align: center;
+                margin-top: 5px;
+            }
+            </style>
+            """,
+            unsafe_allow_html=True,
+        ) 
+        # Get Recommendations
+        if st.button("Get Recommendations"):
+            try:
+                recommender = ContentBasedRecommender(anime_data)
+                recommendations = recommender.get_rec_cosine(anime_name, n_recommendations=n_recommendations,model_path=cosine_similarity_model_path)
+
+                if isinstance(recommendations, str):
+                    st.warning(recommendations)
+                elif recommendations.empty:
+                    st.warning("No recommendations found.")
+                else:
+                    st.write(f"Here are the Content-based Recommendations for {anime_name}:") 
+                    cols = st.columns(5)
+                    for i, row in enumerate(recommendations.iterrows()):
+                        col = cols[i % 5]
+                        with col:
+                            st.image(row[1]['Image URL'], use_container_width=True)
+                            st.markdown(
+                                f"<div class='anime-title'>{row[1]['Anime name']}</div>",
+                                unsafe_allow_html=True,
+                            )
+                            st.caption(f"Genres: {row[1]['Genres']} | Rating: {row[1]['Rating']}") 
+            except Exception as e:
+                st.error(f"Unexpected error: {str(e)}")
+ 
+    except Exception as e:
+        st.error(f"Unexpected error: {str(e)}")
+
+elif app_selector == "Collaborative Recommender":
+    st.title("Collaborative Recommender System")
+    
+    try:  
+        # Sidebar for choosing the collaborative filtering method
+        collaborative_method = st.sidebar.selectbox(
+            "Choose a collaborative filtering method:", 
+            ["SVD Collaborative Filtering", "User-Based Collaborative Filtering", "Anime-Based KNN Collaborative Filtering"]
+        )
+
+        # User input
+        if collaborative_method == "SVD Collaborative Filtering" or collaborative_method == "User-Based Collaborative Filtering": 
+            user_ids = anime_user_ratings['user_id'].unique()  
+            user_id = st.selectbox("Choose a user, and we'll show you animes they'd recommend", user_ids) 
+            n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=50, value=10)
+        elif collaborative_method == "Anime-Based KNN Collaborative Filtering": 
+            anime_list = anime_user_ratings["name"].dropna().unique().tolist() 
+            anime_name = st.selectbox("Pick an anime, and we'll suggest more titles you'll love", anime_list)
+            n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=50, value=10)
+   
+        # Get recommendations
+        if st.button("Get Recommendations"):
+            # Load the recommender
+            recommender = CollaborativeAnimeRecommender(anime_user_ratings) 
+            if collaborative_method == "SVD Collaborative Filtering": 
+                recommendations = recommender.get_svd_recommendations(user_id, n=n_recommendations, svd_model=svd_model)  
+            elif collaborative_method == "User-Based Collaborative Filtering": 
+                recommendations = recommender.get_user_based_recommendations(user_id, n_recommendations=n_recommendations, knn_user_model=user_based_knn_model)
+            elif collaborative_method == "Anime-Based KNN Collaborative Filtering":
+                if anime_name: 
+                    recommendations = recommender.get_item_based_recommendations(anime_name, n_recommendations=n_recommendations, knn_item_model=item_based_knn_model)
+                else:
+                    st.error("Invalid Anime Name. Please enter a valid anime title.")
+            
+            if isinstance(recommendations, pd.DataFrame) and not recommendations.empty:
+                if len(recommendations) < n_recommendations:
+                    st.warning(f"Oops...Only {len(recommendations)} recommendations available, fewer than the requested {n_recommendations}.")
+                st.write(f"Here are the Collaborative Recommendations:")
+                cols = st.columns(5)
+                for i, row in enumerate(recommendations.iterrows()):
+                    col = cols[i % 5]
+                    with col:
+                        st.image(row[1]['Image URL'], use_container_width=True)
+                        st.markdown(
+                            f"<div class='anime-title'>{row[1]['Anime Name']}</div>",
+                            unsafe_allow_html=True,
+                        ) 
+                        st.caption(f"Genres: {row[1]['Genres']} | Rating: {row[1]['Rating']}")
+            else:
+                st.error("No recommendations found.")
+    except Exception as e:
+        st.error(f"An error occurred: {e}")
+
+
+elif app_selector == "Top Anime Recommender":
+    st.title("Top Anime Recommender System")
+    
+    try:
+        # Sidebar for choosing the popularity-based filtering method
+        popularity_method = st.sidebar.selectbox(
+            "Choose a Popularity-Based Filtering method:",
+            [
+                "Popular Animes",
+                "Top Ranked Animes",
+                "Overall Top Rated Animes",
+                "Favorite Animes",
+                "Top Animes by Members",
+                "Popular Anime Among Members",
+                "Top Average Rated Animes",
+            ]
+        )
+        
+        n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=500, value=10)
+        
+        if st.button("Get Recommendations"):
+            # Load the popularity-based recommender
+            recommender = PopularityBasedFiltering(anime_data)
+            
+            # Get recommendations based on selected method
+            if popularity_method == "Popular Animes":
+                recommendations = recommender.popular_animes(n=n_recommendations)
+            elif popularity_method == "Top Ranked Animes":
+                recommendations = recommender.top_ranked_animes(n=n_recommendations)
+            elif popularity_method == "Overall Top Rated Animes":
+                recommendations = recommender.overall_top_rated_animes(n=n_recommendations)
+            elif popularity_method == "Favorite Animes":
+                recommendations = recommender.favorite_animes(n=n_recommendations)
+            elif popularity_method == "Top Animes by Members":
+                recommendations = recommender.top_animes_members(n=n_recommendations)
+            elif popularity_method == "Popular Anime Among Members":
+                recommendations = recommender.popular_anime_among_members(n=n_recommendations)
+            elif popularity_method == "Top Average Rated Animes":
+                recommendations = recommender.top_avg_rated(n=n_recommendations)
+            else:
+                st.error("Invalid selection. Please choose a valid method.")
+                recommendations = None
+            
+            # Display recommendations
+            if isinstance(recommendations, pd.DataFrame) and not recommendations.empty:
+                st.write(f"Here are the {popularity_method}:")
+                cols = st.columns(5)
+                for i, row in recommendations.iterrows():
+                    col = cols[i % 5]
+                    with col:
+                        st.image(row['Image URL'], use_container_width=True)
+                        st.markdown(
+                            f"<div class='anime-title'>{row['Anime name']}</div>",
+                            unsafe_allow_html=True,
+                        )
+                        st.caption(f"Genres: {row['Genres']} | Rating: {row['Rating']}")
+            else:
+                st.error("No recommendations found.")
+    except Exception as e:
+        st.error(f"An error occurred: {e}")
+

requirements.txt

@@ -6,4 +6,9 @@ transformers
 huggingface_hub
 datasets
 scikit-surprise
+# wordcloud
+# seaborn
+# matplotlib
+# squarify
+# tensorflow
 # -e .

run_pipeline.py

@@ -1,53 +1,53 @@
-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,CollaborativeModelConfig,ContentBasedModelConfig
-from anime_recommender.source.data_transformation import DataTransformation
-from anime_recommender.source.collaborative_recommender import CollaborativeModelTrainer
-from anime_recommender.source.content_based_recommender import ContentBasedModelTrainer 
-from anime_recommender.source.top_anime_recommenders import PopularityBasedRecommendor
-
-
-if __name__ == "__main__":
-    try:
-        training_pipeline_config = TrainingPipelineConfig()  
-        data_ingestion_config = DataIngestionConfig(training_pipeline_config)
-        data_ingestion = DataIngestion(data_ingestion_config)
-        logging.info("Initiating Data Ingestion.")
-        data_ingestion_artifact = data_ingestion.ingest_data()
-        logging.info(f"Data ingestion completed.")
-        print(data_ingestion_artifact)
-
-        # Data Transformation
-        data_transformation_config = DataTransformationConfig(training_pipeline_config)
-        data_transformation = DataTransformation(data_ingestion_artifact,data_transformation_config)
-        logging.info("Initiating Data Transformation.")
-        data_transformation_artifact = data_transformation.initiate_data_transformation()
-        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='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)
-
-        # Popularity Based Filtering
-        logging.info("Initiating Popularity based filtering.")
-        filtering = PopularityBasedRecommendor(data_ingestion_artifact=data_ingestion_artifact)
-        popularity_recommendations =  filtering.initiate_model_trainer(filter_type='top_avg_rated')
-        logging.info("Popularity based filtering completed.") 
-
-    except Exception as e:
+import sys
+from anime_recommender.loggers.logging import logging
+from anime_recommender.exception.exception import AnimeRecommendorException
+from anime_recommender.components.data_ingestion import DataIngestion
+from anime_recommender.entity.config_entity import TrainingPipelineConfig,DataIngestionConfig,DataTransformationConfig,CollaborativeModelConfig,ContentBasedModelConfig
+from anime_recommender.components.data_transformation import DataTransformation
+from anime_recommender.components.collaborative_recommender import CollaborativeModelTrainer
+from anime_recommender.components.content_based_recommender import ContentBasedModelTrainer 
+from anime_recommender.components.top_anime_recommenders import PopularityBasedRecommendor
+
+
+if __name__ == "__main__":
+    try:
+        training_pipeline_config = TrainingPipelineConfig()  
+        data_ingestion_config = DataIngestionConfig(training_pipeline_config)
+        data_ingestion = DataIngestion(data_ingestion_config)
+        logging.info("Initiating Data Ingestion.")
+        data_ingestion_artifact = data_ingestion.ingest_data()
+        logging.info(f"Data ingestion completed.")
+        print(data_ingestion_artifact)
+
+        # Data Transformation
+        data_transformation_config = DataTransformationConfig(training_pipeline_config)
+        data_transformation = DataTransformation(data_ingestion_artifact,data_transformation_config)
+        logging.info("Initiating Data Transformation.")
+        data_transformation_artifact = data_transformation.initiate_data_transformation()
+        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='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)
+
+        # Popularity Based Filtering
+        logging.info("Initiating Popularity based filtering.")
+        filtering = PopularityBasedRecommendor(data_ingestion_artifact=data_ingestion_artifact)
+        popularity_recommendations =  filtering.initiate_model_trainer(filter_type='top_avg_rated')
+        logging.info("Popularity based filtering completed.") 
+
+    except Exception as e:
             raise AnimeRecommendorException(e, sys)

setup.py

@@ -1,29 +1,29 @@
-from setuptools import find_packages, setup
-from typing import List
-
-def get_requirements() -> List[str] :
-    """
-    This function returns the list of requirements
-    """
-    requirements_lst:List[str] = []
-    try:
-        with open("requirements.txt", "r") as file:
-            lines = file.readlines()
-            for line in lines:
-                requirement = line.strip()
-                if requirement and requirement != "-e .":
-                    requirements_lst.append(requirement)
-    except FileNotFoundError:
-        print("requirements.txt file not found")
-    return requirements_lst
-
-print(get_requirements())
-
-setup(
-    name="AnimeRecommendationSystem",
-    version= "0.0.1",
-    author= "Krishnaveni Ponna",
-    author_email= "[email protected]",
-    packages= find_packages(),
-    install_requires = get_requirements()
+from setuptools import find_packages, setup
+from typing import List
+
+def get_requirements() -> List[str] :
+    """
+    This function returns the list of requirements
+    """
+    requirements_lst:List[str] = []
+    try:
+        with open("requirements.txt", "r") as file:
+            lines = file.readlines()
+            for line in lines:
+                requirement = line.strip()
+                if requirement and requirement != "-e .":
+                    requirements_lst.append(requirement)
+    except FileNotFoundError:
+        print("requirements.txt file not found")
+    return requirements_lst
+
+print(get_requirements())
+
+setup(
+    name="AnimeRecommendationSystem",
+    version= "0.0.1",
+    author= "Krishnaveni Ponna",
+    author_email= "[email protected]",
+    packages= find_packages(),
+    install_requires = get_requirements()
 )