How Recommendation Systems Handle the Cold Start Problem

The cold start problem in recommendation systems arises when there is insufficient historical
interaction data for new users, new items, or even when launching a new system, making it
challenging to provide accurate recommendations [1] [2] [3] .
Key Strategies to Address the Cold Start Problem:
Content-Based Filtering:
For new users or items, recommendation systems rely on content features such as item
descriptions, attributes, or user profiles (e.g., demographics, interests). By matching user
profiles to item characteristics, the system can generate initial recommendations without
needing prior interaction data [4] [2] [1] .
Popularity and Trend-Based Recommendations:
Recommending popular or trending items is a common approach for new users, as these
items are generally well-received and require no personalization [4] .
Demographic and Metadata Utilization:
Systems can use available demographic data (age, gender, location) for users and
metadata (category, tags, description) for items to infer initial preferences and make
baseline recommendations [2] .
Hybrid Approaches:
Combining collaborative filtering with content-based methods (hybrid recommenders) helps
mitigate the disadvantages of relying solely on one technique, especially when interaction
data is sparse [5] .
Transfer Learning and Meta-Learning:
These advanced machine learning techniques leverage knowledge from existing users or
items to inform recommendations for new users or items. Meta-learning, for example, allows
the system to quickly adapt to new scenarios by updating model parameters with minimal
new data [4] [6] .
Active Learning and Preference Elicitation:
Systems may prompt new users to rate a few carefully selected items, maximizing the
information gained from each response to rapidly build a useful user profile [1] .
Social Network and External Data:
Allowing users to sign up with social logins or importing data from other platforms can
provide immediate insights into user preferences, helping to overcome the lack of historical
data [7] .
A/B Testing and Iterative Refinement:
Continuous experimentation with different cold start strategies helps identify the most
effective methods for a given system and user base [4] .
Summary Table: Cold Start Strategies
 Scenario Main Approaches

Content-based filtering, demographics, social login, active learning, popularity-based

New User
recommendations

New Item Metadata enrichment, content similarity, transfer learning, popularity-based recommendations

New Hybrid approaches, initial random/popular recommendations, active learning, transfer from
System similar domains

By combining these strategies, recommendation systems can provide relevant suggestions even
when historical data is limited, gradually improving personalization as more interactions are
collected [4] [1] [2] .
⁂

Bandwagon Attack in Recommendation Systems

Definition:
A bandwagon attack is a type of shilling or profile injection attack against recommendation
systems, where attackers create fake user profiles that rate a set of popular items highly (or at
their maximum value), along with the target item they want to promote (push attack) or demote
(nuke attack). The rest of the items in the profile are rated randomly or not at all [8] [9] .
How It Works:
The attacker identifies items that are widely liked or popular in the system.
In each fake profile, the attacker gives the maximum rating to these popular items and to
the target item (if it is a push attack).
The remaining items (called filler items) are rated randomly.
The goal is to make the fake profiles appear similar to genuine user profiles, increasing the
likelihood that the target item is recommended to more users [8] [9] .
Example:
Suppose an attacker wants to promote a new book (Item X) on an online bookstore. The most
popular books on the platform are Items A, B, and C.
The attacker creates several fake user profiles.
In each profile, Items A, B, and C are rated 5 stars (the maximum).
Item X (the book to promote) is also rated 5 stars.
Other items are rated randomly or left unrated.
Because many genuine users also rate Items A, B, and C highly, the fake profiles appear
similar to real users.
As a result, the recommendation system is more likely to suggest Item X to users who like
Items A, B, and C, thus successfully promoting the attacker’s book [8] [9] .
Purpose and Impact:
The main reason for assigning high ratings to popular items is to increase the similarity between
the fake profiles and those of real users, making the attack more effective. Bandwagon attacks
are particularly effective against user-based collaborative filtering algorithms, as these rely
heavily on user similarity [8] [9] .
Summary Table: Bandwagon Attack Steps

Step Description

Select popular items Identify widely liked items in the system

Create fake profiles Assign maximum ratings to popular items and the target item

Add filler ratings Rate other items randomly or not at all

Inject profiles Add these fake profiles to the recommender system

Influence outcomes Target item appears more often in recommendations to genuine users

Bandwagon attacks exploit the popularity bias in recommendation systems, making them a
significant security concern [8] [9] .
⁂

10 Issues in the Hybridization Method of Recommendation Systems

Hybrid recommendation systems combine multiple recommendation techniques (e.g.,
collaborative filtering, content-based filtering) to leverage their strengths and mitigate individual
weaknesses. However, hybridization introduces its own set of challenges and limitations:
1. Data Integration Complexity
Combining different data sources (user ratings, item attributes, behavioral data) can be
technically complex, requiring careful preprocessing and alignment of heterogeneous data
formats [10] .
2. Algorithm Selection and Combination
Deciding which algorithms to combine and how to integrate them (e.g., weighted, switching,
mixed) is non-trivial and often domain-dependent, impacting both effectiveness and
maintainability [10] [11] .
3. Scalability
As the number of users and items grows, hybrid systems may face increased computational
demands, leading to scalability issues similar to or worse than those in pure collaborative or
content-based systems [12] [13] .
4. Data Sparsity
Even with hybridization, sparse user-item matrices remain a challenge, as insufficient data
can limit the effectiveness of collaborative components and reduce overall recommendation
quality [12] [14] [15] .
5. Cold Start Problem
While hybrid systems can partially address cold start issues, new users or items with little or
no data still pose significant challenges, especially when both content and collaborative
data are limited [12] [13] [10] .
 6. Interpretability and Transparency
The complexity of hybrid models can make it difficult to explain recommendations to users,
reducing trust and user satisfaction [10] .
7. Maintenance and Upgradability
Hybrid systems are often harder to maintain and update, as changes in one component may
require adjustments in others to preserve system balance and performance [10] .
8. Evaluation and Benchmarking
Assessing the effectiveness of hybrid systems is challenging due to the need for
comprehensive metrics and benchmarks that account for the interplay of multiple
algorithms [10] .
9. Privacy and Ethical Concerns
Integrating diverse data sources (including personal or sensitive information) raises privacy
and ethical issues, requiring robust data governance and user consent mechanisms [10] .
10. Increased Development and Operational Costs
Developing, deploying, and operating hybrid systems typically requires more resources,
expertise, and infrastructure compared to single-method recommenders [10] [12] .
These issues highlight the trade-offs involved in hybridizing recommendation methods,
emphasizing the need for careful system design, ongoing evaluation, and adaptation to specific
application domains.
⁂

Show a scenario where knowledge based

recommender would be useful rather than
collaborative and content Recommendation
systems.
A knowledge-based recommender system is especially useful in scenarios where items are
expensive, purchased infrequently, or require users to specify complex constraints-situations
where collaborative filtering and content-based methods are less effective due to lack of
historical data or the need for explicit requirements [16] [17] .
Scenario Example: Apartment Search
Suppose a user is searching for an apartment to rent or buy. This is a high-involvement,
infrequent purchase where each user has specific requirements such as location, price range,
number of bedrooms, pet-friendliness, and proximity to public transport.
Why collaborative filtering is not suitable: There are few repeat purchases, so there is not
enough user-item interaction data (ratings or purchases) to identify similar users or
preferences. The cold start problem is significant because most users have never rated or
interacted with apartments before [16] [17] .
Why content-based filtering is not sufficient: While it can match apartments to user
profiles based on features, it may not handle complex constraints or preferences (e.g.,
 "must have a balcony and be within 10 minutes of a metro station") effectively [16] [17] .
How knowledge-based recommendation excels:
The system asks the user to specify explicit requirements (e.g., budget, number of
bedrooms, amenities).
It applies domain knowledge and constraint satisfaction to filter and rank apartments that
match these criteria.
The user receives recommendations tailored to their explicit needs, even if no one else has
searched for similar apartments before [16] [18] [17] .
Other typical domains: Cars, financial services, digital cameras, and tourist destinations-where
purchases are rare, preferences are complex, and historical user data is sparse [16] [17] .
"Knowledge-based recommender systems are well suited to complex domains where
items are not purchased very often, such as apartments and cars... In complex item
domains, customers want to specify their preferences explicitly..." [16]
In summary, a knowledge-based recommender is the preferred choice when recommendations
must be made based on explicit user requirements in domains with little or no historical
interaction data, and where the stakes or complexity of the decision are high [16] [18] [17] .
⁂

Differences Between Knowledge-Based, Collaborative, and Content-Based

Recommender Systems
Knowledge-Based Collaborative Filtering Content-Based
Aspect
Recommender Recommender Recommender

Uses explicit domain Uses user-item interaction Uses item attributes

knowledge and user data (e.g., ratings, and user profiles to
Core Principle
requirements to match purchases) to find similar recommend similar
users with items users/items items

Relies on structured Requires detailed item

Requires large amounts of
Data Requirement knowledge or rules, not features and user
user-item interaction data
historical user behavior preferences

Somewhat affected for

Cold Start Not affected, as it does not Severely affected; struggles new users, less so for
Problem depend on historical data with new users/items new items if attributes
are rich

Explicit user constraints Similarity in item

Recommendation Similarity in user behavior or
and item features (e.g., content to what user
Basis preferences
“must have X, Y, Z”) liked before

Movie/music News, articles,

Use Case Apartment search, car
recommendations, e- products with rich
Example buying, financial products
commerce metadata
 Knowledge-Based Collaborative Filtering Content-Based
Aspect
Recommender Recommender Recommender

Highly explainable- Moderately

Often less transparent-
Explainability recommendations are explainable-based on
based on patterns in data
based on explicit rules item features

Adapts as user profile

Adapts to explicit changes Adapts as more interaction
Adaptability and item features
in user needs data is collected
evolve

Key Distinctions
Knowledge-based recommenders excel where purchases are rare, stakes are high, or
users have specific, complex requirements. They use domain knowledge and explicit user
input rather than learning from past behavior [19] [20] [21] .
Collaborative filtering relies on the wisdom of the crowd, using user-item interaction
patterns to recommend items. It performs best with abundant user data but fails with new
users or items (the cold start problem) [22] [23] [24] .
Content-based recommenders focus on matching item features to user preferences,
making them suitable when item attributes are rich and well-defined, but they may struggle
to suggest novel items outside a user's established interests [22] [23] [24] .
"Knowledge-based, content-based, and collaborative filtering are three main
approaches in recommendation systems, each designed to cater to specific contexts
and data availability" [19] [20] [21] .
In summary, knowledge-based systems are fundamentally different because they do not rely on
user history or item similarity, but instead use explicit knowledge and constraints to generate
recommendations, making them ideal for domains with sparse or no user interaction data.
⁂

11 Popular Tasks Associated with Recommendation Systems

1. Personalized Recommendation
Suggesting items tailored to individual users based on their preferences, behaviors, or
profiles [25] [26] .
2. Group Recommendation
Recommending items to a group of users, considering the preferences and interactions of all
group members [25] .
3. Package Recommendation
Suggesting bundles or sets of items that complement each other, such as travel packages
or product kits [25] .
4. Package-to-Group Recommendation
Recommending packages or bundles specifically designed to meet the collective needs of a
group [25] .
 5. Ranking
Ordering a list of items for a user or group to maximize relevance or satisfaction, often
based on predicted preferences [27] .
6. Rating Prediction
Predicting the score or rating a user would give to an item, which helps in ranking and
recommendation generation [27] .
7. Session-Based Recommendation
Making recommendations based on the current session's actions, especially when long-term
user history is unavailable or less relevant [28] [29] .
8. Sequence-Aware Recommendation
Leveraging the order and sequence of user interactions (e.g., browsing or purchase history)
to make contextually relevant suggestions [29] .
9. Candidate Item Selection
Filtering a large set of possible items down to a manageable shortlist for further ranking and
recommendation [26] .
10. Bias and Fairness Management
Identifying and mitigating biases in recommendations to ensure fairness, diversity, and
inclusivity in the results [28] .
11. Evaluation and Offline Testing
Assessing the effectiveness, accuracy, and impact of recommendation algorithms using
offline datasets and metrics before deployment [28] [26] .
These tasks collectively address the core functions and challenges of modern recommender
systems, ensuring they deliver relevant, fair, and effective suggestions across various user
scenarios and domains.
⁂

User-Based Nearest Neighbor Explained with Example

User-based Nearest Neighbor is a collaborative filtering technique that recommends items to a
user by identifying other users with similar preferences (nearest neighbors) and suggesting
items those similar users have liked or rated highly [30] [31] [32] .

How It Works
1. User-Item Matrix:
All users’ interactions (ratings, purchases, etc.) with items are stored in a matrix, where each
row is a user and each column is an item [30] [31] .
2. Similarity Calculation:
For a target user, the system computes similarity scores (using measures like cosine
similarity or Pearson correlation) between this user and all other users based on their item
ratings or interactions [31] [32] .
 3. Neighbor Selection:
The system selects the top-k users (nearest neighbors) who are most similar to the target
user [30] [31] .
4. Recommendation Generation:
Items that the nearest neighbors have liked or rated highly-but the target user has not
interacted with-are recommended to the target user. The predicted preference for an item is
often a weighted average of the neighbors’ ratings, weighted by similarity [30] [31] .

Example
Suppose we have the following user-item ratings matrix for four users (U1, U2, U3, U4) and four
movies (M1, M2, M3, M4):

M1 M2 M3 M4

U1 5 3 ? 1

U2 4 2 4 1

U3 5 3 5 2

U4 1 5 1 4

Goal: Predict U1’s rating for M3 (currently unknown).

Step 1: Calculate similarity between U1 and other users (U2, U3, U4) based on their ratings
for movies they have in common.
Step 2: Suppose U3 is most similar to U1 (highest similarity score).
Step 3: U3 rated M3 as 5. U2 rated M3 as 4. U4 rated M3 as 1.
Step 4: Compute a weighted average of these ratings using their similarity to U1 as weights.
Step 5: Recommend M3 to U1 if the predicted rating is high.
"To predict U's rating for a given item I, we calculate the weighted average of the rating
r of k similar users (neighbors) to U, where the weights are determined by the similarity
between U and each of the similar users" [30] [31] .

Summary
User-based Nearest Neighbor recommends items to a user by finding users with similar tastes
and leveraging their preferences to make predictions. This method is widely used in
collaborative filtering for tasks like movie, product, or book recommendations [30] [31] [32] .
⁂
Architecture of Content-Based Recommendation Systems
Content-based recommendation systems suggest items to users by analyzing the features of
items and matching them with the user’s preferences, which are inferred from their previous
interactions or explicitly provided data.

Typical Architecture
The architecture of a content-based recommender system generally consists of the following
components:
1. Data Layer
Item Data: Contains features or attributes of items (e.g., genre, description, keywords
for movies; price, category, description for products) [33] [34] .
User Data: Stores user profiles, preferences, and interaction histories (e.g., items
viewed, liked, or rated) [33] [35] [34] .
2. Feature Extraction and Representation
Extracts meaningful features from item data (e.g., using NLP for text, image analysis for
pictures) [36] [35] .
Represents items and user preferences as feature vectors in a common space [36] [37] .
3. User Profile Construction
Builds a user profile by aggregating features from items the user has interacted with or
explicitly liked [35] [37] .
The user profile is typically a weighted vector reflecting the importance of various
features to the user [35] [37] .
4. Similarity Computation
Calculates similarity between the user profile and item profiles using metrics like cosine
similarity or dot product [38] [35] [37] .
5. Recommendation Engine
Ranks all items based on similarity scores and recommends the most similar items to the
user [38] [35] [39] .
6. Feedback and Update
Updates user profiles and refines recommendations as users interact with more
items [35] .

Example: Movie Recommendation

Suppose a user has watched and rated the following movies highly:
The Dark Knight (Action, Crime, Thriller)
Batman Begins (Action, Crime, Drama)
Step-by-step process:
 1. Feature Representation:
Each movie is described by its genres (e.g., Action, Crime, Thriller, Drama) [40] [37] .
2. User Profile Construction:
The system aggregates the genres of movies the user liked, resulting in a user profile vector
(e.g., high weights for Action and Crime) [35] [37] .
3. Item Profile Representation:
All movies in the database are represented by their genre vectors.
4. Similarity Calculation:
The system computes the similarity between the user profile and each movie's genre vector.
5. Recommendation Generation:
Movies with the highest similarity scores (e.g., other Action/Crime/Thriller movies like
Inception or Heat) are recommended to the user [40] [37] .

Visual Workflow

User Interactions (ratings, clicks)

|
v
User Profile Construction <--------+
| |
v |
Similarity Computation |
| |
v |
Recommendation Engine |
| |
v |
Recommended Items ------------+
^
|
Item Feature Extraction

Summary Table
Component Description

Item Data Attributes/features of items

User Data User profiles and interaction history

Feature Extraction Converts item/user data into feature vectors

Similarity Computation Measures similarity between user and item profiles

Recommendation Engine Ranks and suggests top items based on similarity

Feedback Update Refines user profile with new interactions

Content-based systems are highly personalized and effective when item features are rich and
user preferences are clear, making them ideal for domains like movies, news, and e-commerce
products [35] [40] [37] .
 ⁂

Similarity-Based Retrieval Methods in Content-Based Recommendation

Content-based recommender systems rely on similarity measures to compare items (and
sometimes users) based on their features or content attributes. These similarity-based retrieval
methods are central to identifying and recommending items that closely match a user's
preferences.

Key Similarity-Based Retrieval Methods

1. Cosine Similarity
Measures the cosine of the angle between two non-zero vectors in a multi-dimensional
space, typically representing item or user profiles.
Commonly used for text data (e.g., TF-IDF vectors for documents or product descriptions).
Values range from 0 (no similarity) to 1 (identical direction).
Example: Used to compare movie plots or user interests represented as feature vectors [41]
[42] .

2. Inner Product (Dot Product) Similarity

Calculates the sum of the products of corresponding entries in two vectors.
Widely used in embedding-based systems, where users and items are mapped to a shared
vector space, and similarity is computed as the dot product of their embeddings [43] .
Higher values indicate greater similarity.
3. Pearson Correlation Coefficient
Measures the linear correlation between two sets of values, often used for comparing user
or item profiles based on ratings or feature values.
Values range from -1 (perfect negative correlation) to 1 (perfect positive correlation) [44] .
4. Jaccard Similarity
Used for comparing sets, such as tags or keywords associated with items.
Defined as the size of the intersection divided by the size of the union of two sets.
Useful for binary or categorical feature comparison.
5. Euclidean Distance
Measures the straight-line distance between two points (feature vectors) in multi-
dimensional space.
Lower values indicate higher similarity.
Sometimes inverted or transformed to fit into a similarity framework.
6. Advanced/Composite Similarity Metrics
 Systems may combine multiple similarity metrics (e.g., metadata, visual content, user
reviews) into a composite score for more robust retrieval [41] .
Deep learning models can also learn complex similarity functions tailored to the domain [42]
[45] .

7. Semantic and Contextual Similarity

Uses techniques like word embeddings (Word2Vec, BERT) or topic modeling (LDA) to
capture semantic similarity between items based on their textual content [46] .
Particularly useful for document or literature recommendation [47] [46] .

Example Application
In a movie recommendation system:
Metadata similarity: Cosine similarity between genre vectors.
Visual similarity: Feature extraction from posters using deep learning, followed by
clustering or similarity computation.
Review similarity: Text vectorization of user reviews and cosine similarity to compare
sentiment or themes [41] .

Summary Table
Method Typical Use Case Data Type

Cosine Similarity Text, metadata, user/item profiles Vectorized features

Inner Product Embedding-based recommendations Vector embeddings

Pearson Correlation Ratings, continuous features Numeric vectors

Jaccard Similarity Tags, keywords, categorical attributes Sets/binary vectors

Euclidean Distance Numeric features, images Numeric vectors

Composite/Hybrid Metrics Multi-modal content (text, image, etc.) Mixed features

Semantic/Contextual Similarity Documents, literature, reviews Text embeddings

These similarity-based retrieval methods are foundational to content-based recommendation,

enabling systems to match items to users based on explicit content features and complex
learned representations [43] [41] [42] .
⁂

Feature Combination Hybrid Recommendation System

A feature combination hybrid recommendation system merges features from both
collaborative filtering and content-based approaches into a single, unified model. Instead of
running separate algorithms and blending their outputs, this method augments the feature set
for each user-item pair with both content-based attributes (like genre, keywords, or product
descriptions) and collaborative information (like user ratings, average item ratings, or user
similarity scores). The combined feature set is then used by a machine learning model or rule-
based system to generate recommendations.

How It Works
Feature Extraction:
Extract content-based features (e.g., item metadata, user profiles) and collaborative
features (e.g., user-item rating patterns, average ratings, user similarity metrics).
Feature Augmentation:
Merge these features into a single vector for each user-item pair.
Model Training:
Use a machine learning algorithm (such as decision trees, logistic regression, or neural
networks) to learn from this enriched feature set and predict user preferences or ratings.
Recommendation Generation:
The trained model predicts which items each user is likely to prefer, based on the combined
features.

Example
Suppose you are building a movie recommendation system:
Content-based features:
Movie genres (Action, Comedy, Drama, etc.)
Director, actors, release year
Movie description (converted to TF-IDF vector)
Collaborative features:
Average rating of the movie
Number of users who rated the movie
Similarity score between the target user and other users who liked the movie
Feature combination:
For each user-movie pair, create a feature vector that includes both the content-based and
collaborative features.
Model application:
Use a classifier or regression model to predict the likelihood that the user will like or rate the
movie highly, and recommend the top-ranked movies.
"Using feature combination as a Hybrid Recommender engine, you can easily achieve
the content/collaborative merger. This is done by basically treating the collaborative
information as simple additional feature data associated with each example and use
content-based techniques over this augmented data set. For example, in an experiment,
in order to achieve higher precision rate than that achieved by just collaborative method,
inductive rule learner, Ripper, was applied to the task of recommending movies using
both user ratings and content features" [48] [49] [50] .
Advantages
Reduces sensitivity to the number of users who have rated an item.
Leverages strengths of both collaborative and content-based methods.
Can improve recommendation accuracy, especially in sparse data scenarios.

Summary Table
Step Description

Feature Extraction Gather content-based and collaborative features for each user-item pair

Feature Combination Merge all features into a single vector

Model Training Train a machine learning model using the combined feature vectors

Recommendation Predict and recommend items based on model output

This approach is particularly effective in domains where both user behavior and item
characteristics are informative, such as movie, music, or product recommendation platforms.
⁂

Demonstrating a Constraint-Based Recommendation Problem: Representation and

Solution
Constraint-based recommender systems generate recommendations by identifying items that
satisfy a set of explicit constraints derived from user preferences and domain knowledge [51] [52]
[53] [54] . These systems are particularly effective in domains where user requirements are
complex and cannot be easily captured by collaborative or content-based methods.

Representation of the Problem

A constraint-based recommendation problem is typically formulated as a Constraint
Satisfaction Problem (CSP), defined by:
User Variables ( ): Represent user preferences or requirements (e.g., maximum price,
desired color, number of seats).
Item Variables ( ): Represent item properties (e.g., price, color, mileage, number of seats).
Constraints ( ): Define the relationships between user preferences and item properties, as
well as domain-specific rules [51] [54] .

Example: Vehicle Recommendation

Suppose a user wants to buy a used car with the following requirements:
Maximum price: $15,000
Maximum mileage: 60,000 km
 Number of seats: 5
Preferred color: Blue or White
Variables:

Constraints:
: price ≤ max_price
: mileage ≤ max_mileage
: seats = num_seats
: color ∈ {Blue, White}
Domain-specific constraints can also be included, such as:
If the car is older than 4 years, a technical inspection within the last 6 months is
required [54] .

Solving the Problem

1. Constraint Encoding:
All user preferences and domain rules are encoded as constraints.
2. Item Filtering:
The recommender system scans the item database and filters out any items that do not
satisfy all the constraints.
3. Constraint Satisfaction:
The system returns all items (cars) for which the assignment of item variables ( ) satisfies
the constraints with respect to user variables ( ) [51] [54] .
4. Constraint Relaxation (if needed):
If no items satisfy all constraints, the system may relax some constraints (e.g., allow a
slightly higher price or different color) to find the best possible matches [51] .

Example Solution
Given the above user requirements and a database of cars, the system would:
Select only those cars where price ≤ $15,000, mileage ≤ 60,000 km, seats = 5, and color is
Blue or White.
Apply additional domain rules, such as checking for a recent technical inspection if the car is
older than 4 years.
Return the list of cars that meet all these conditions.
Summary Table
Step Description

Define Variables User preferences ( ), item properties ( )

Encode Constraints User and domain rules ( )

Filter Items Select items satisfying all constraints

(Optional) Relax Constraints Gradually relax constraints if no exact match is found

Conclusion
Constraint-based recommendation is represented as a CSP, where the goal is to find item
assignments that satisfy all user and domain constraints. The problem is solved by filtering items
through these constraints, ensuring recommendations are tailored to explicit user requirements
and domain logic [51] [54] [52] .
⁂

Evaluation Design Goals for Recommender Systems

Recommender systems are evaluated on multiple dimensions to ensure they deliver relevant,
reliable, and engaging suggestions. Below are key evaluation goals and their significance:

Accuracy
Accuracy measures how well the recommender predicts user preferences. It is often quantified
using metrics like Mean Absolute Error (MAE), Root Mean Squared Error (RMSE), Precision, and
Recall. High accuracy means the system effectively recommends items that users actually like or
engage with [55] [56] .

Coverage
Coverage assesses the proportion of items or users for which the system can make
recommendations. Item coverage reflects how many items appear in recommendations, while
user coverage indicates how many users receive meaningful suggestions. High coverage
ensures the system serves a broad range of users and items, not just the most popular ones [55] .

Confidence and Trust

Confidence relates to the system's ability to indicate how certain it is about a recommendation.
Trust is the user's perception of the system's reliability and transparency. Systems that
communicate confidence scores or explain their suggestions help users trust and rely on
recommendations, leading to higher satisfaction and adoption [57] [58] .

Novelty
Novelty measures how new or unexpected the recommended items are to the user. A system
with high novelty introduces users to items they haven’t seen or considered before, preventing
recommendation fatigue and keeping the experience fresh [55] [59] .
Serendipity
Serendipity goes beyond novelty by recommending items that are both unexpected and
pleasantly surprising. It aims to delight users with suggestions they would not have discovered
on their own but end up enjoying, enhancing engagement and satisfaction [55] [59] .

Diversity
Diversity evaluates how varied the recommendations are within a list. High diversity ensures that
recommendations are not too similar to each other, catering to different facets of a user’s
interests and reducing the risk of monotony [55] [59] .

Robustness
Robustness measures the system’s resilience to noise, adversarial attacks, or data manipulation
(e.g., shilling or bandwagon attacks). A robust system maintains performance and
recommendation quality even when faced with imperfect or malicious input [55] .

Stability
Stability refers to the consistency of recommendations over time or across similar user profiles.
Users expect that small changes in their behavior or profile should not lead to radically different
recommendations, which fosters trust and usability [55] .

Scalability
Scalability assesses how well the system performs as the number of users, items, or interactions
grows. A scalable recommender maintains responsiveness and quality even under heavy loads
or with massive datasets, which is critical for real-world deployment [55] .

"Aside from the well known goal of accuracy, other general goals include factors such as
diversity, serendipity, novelty, robustness, and scalability. Some of these goals can be
concretely quantified, whereas others are subjective goals based on user experience."
[55]

In summary, a comprehensive evaluation of recommender systems considers not just accuracy,

but also coverage, trust, novelty, serendipity, diversity, robustness, stability, and scalability to
ensure a balanced, effective, and user-friendly experience.
⁂

Error Metrics and Decision Support Metrics in Recommendation Systems

Error Metrics
Error metrics evaluate how accurately a recommender system predicts user preferences,
typically by comparing predicted ratings or scores to actual user feedback. These are crucial for
quantifying the prediction quality of algorithms, especially in rating-based systems.
Common Error Metrics:
Mean Absolute Error (MAE):
Measures the average absolute difference between predicted and actual ratings. It treats all
 errors equally, providing a straightforward interpretation of overall prediction accuracy [60]
[61] [62] [63] [64] [65] .

Root Mean Squared Error (RMSE):

Calculates the square root of the average squared differences between predicted and
actual ratings. RMSE penalizes larger errors more heavily, making it useful when large
deviations are particularly undesirable [60] [62] [63] [64] [65] .
Mean Squared Error (MSE):
Averages the squares of the prediction errors. Like RMSE, it emphasizes larger errors, but
without taking the square root [63] [64] .
Mean Absolute Percentage Error (MAPE):
Expresses the average absolute error as a percentage of the actual values, making it useful
for comparing errors across different scales [63] [64] .
Coefficient of Determination ( ):
Indicates the proportion of variance in user ratings that is predictable from the model. A
higher means better predictive accuracy [63] [64] .
Purpose:
Error metrics are especially relevant when the system predicts explicit ratings or scores, helping
developers tune models to minimize prediction mistakes and improve user satisfaction.

Decision Support Metrics

Decision support metrics assess how well a recommender system aids users in making choices,
focusing on the relevance, ranking, and usefulness of recommendations rather than just rating
prediction accuracy.
Key Decision Support Metrics:
Precision@K:
The proportion of recommended items in the top K results that are relevant to the user. High
precision means most recommended items are useful [60] [61] [62] [66] [65] .
Recall@K:
The proportion of all relevant items that appear in the top K recommendations. High recall
indicates the system successfully surfaces most items the user would like [60] [62] [66] [65] .
F-measure:
The harmonic mean of precision and recall, balancing the two for a more holistic
evaluation [60] [61] .
Mean Average Precision (MAP) and MAP@K:
Measures the average precision across all users or queries, rewarding systems that rank
relevant items higher in the recommendation list [65] .
Mean Reciprocal Rank (MRR):
Focuses on the position of the first relevant item in the ranked list, rewarding systems that
place relevant recommendations near the top [62] [67] .
 Normalized Discounted Cumulative Gain (NDCG):
Evaluates the ranking quality by considering the position and relevance of items in the
recommendation list. Higher NDCG means more relevant items are ranked higher [62] [67] .
Purpose:
Decision support metrics are crucial for ranking-based and top-N recommendation tasks, where
the goal is to help users efficiently discover relevant items, not just predict scores. They reflect
the practical effectiveness of the system in real-world decision-making scenarios.

Summary Table
Metric Type Examples What It Measures

Error Metrics MAE, RMSE, MSE, MAPE, Accuracy of predicted ratings/scores

Decision Precision@K, Recall@K, F-measure, MAP, Relevance, ranking, and usefulness of

Support MRR, NDCG recommended items

In practice, both error and decision support metrics are used together to comprehensively
evaluate and improve recommender systems, ensuring both accurate predictions and
effective user decision support. [60] [61] [62] [63] [64] [65] [67]
⁂

Write a note on Covariance Matrix

A covariance matrix is a fundamental concept in probability theory and statistics, representing
the pairwise covariances between elements of a random vector. Given a random vector with $ n
$ elements, the covariance matrix is an $ n \times n $ square matrix where each entry at position
gives the covariance between the th and th elements of the vector [68] .

Mathematical Definition
If $ X $ is a random vector with elements $ X_1, X_2, ..., X_n $, the covariance matrix $ \Sigma $
is defined as:

where $ \mu_i $ is the expected value (mean) of $ X_i $ [68] .

Properties
Symmetry: The covariance matrix is always symmetric, meaning $ \Sigma_{ij} = \Sigma_{ji}
$.
Diagonal Elements: The diagonal entries ($ \Sigma_{ii} $) represent the variances of each
element.
Off-diagonal Elements: The off-diagonal entries ($ \Sigma_{ij} $, $ i \neq j $) represent the
covariances between different elements.
Applications in Recommendation Systems
In recommender systems, covariance matrices are used to capture relationships between users
or items. For example, a user-user covariance matrix can describe how users’ preferences
change together, providing a more nuanced understanding than simple similarity measures. This
approach can help address issues like data sparsity and changing user interests, and can
improve both the diversity and precision of recommendations [69] [70] .
Matrix factorization techniques in collaborative filtering sometimes assume that latent features
are uncorrelated (diagonal covariance), but more advanced methods use full or sparse
covariance matrices to better capture the structure of user or item relationships, which can also
help prevent overfitting and reflect real-world semantics [70] .

Summary Table
Entry Type Meaning

Diagonal ( ) Variance of the th variable

Off-diagonal ( ) Covariance between th and th variables

In summary, the covariance matrix is a key tool for understanding relationships within
multivariate data, with important applications in statistics, machine learning, and recommender
systems [68] [69] [70] .
⁂

Note on Conversational Recommendation

Conversational recommendation refers to a class of recommender systems that interact with
users in a dialogue-based manner, often through natural language or structured questions.
Instead of passively suggesting items, the system actively engages the user, asks clarifying
questions, and iteratively refines its recommendations based on user responses. This approach
is particularly useful when user preferences are complex, ambiguous, or not initially well-defined.

Key Features
Interactive Dialogue: The system asks questions or prompts to gather user preferences.
Dynamic Preference Elicitation: User preferences are updated in real time as the
conversation progresses.
Personalized Recommendations: Suggestions become more accurate as the system learns
more about the user's needs.
Natural Language Understanding: Many modern systems use NLP to interpret user input
and respond conversationally.
Example: Conversational Recommendation for Restaurant Booking
Scenario:
A user wants to find a restaurant for dinner using a chatbot-based recommender.
Sample Conversation:
System: Hi! What type of cuisine are you interested in tonight?
User: I’d like Italian food.
System: Great! Do you have a price range in mind?
User: Something moderate, not too expensive.
System: Do you prefer a casual or formal setting?
User: Casual is fine.
System: Here are a few Italian restaurants nearby that are casual and moderately priced. Would
you like to see more details or make a reservation?
How it works:
The system starts with broad questions and narrows down options based on the user's
responses.
Each user answer helps the system filter the database and refine its recommendations.
The process continues until the user is satisfied or makes a selection.

Advantages
Handles Complex Preferences: Can accommodate multi-faceted or evolving user needs.
Improves User Satisfaction: Users feel more in control and engaged.
Reduces Choice Overload: By narrowing options step-by-step, the system prevents
overwhelming the user.

Applications
E-commerce shopping assistants
Travel and hotel booking bots
Movie or content recommenders in streaming platforms
Personalized healthcare or financial advice tools

In summary:
Conversational recommendation systems use interactive, dialogue-driven processes to elicit user
preferences and provide tailored suggestions. By mimicking a human-like conversation, they
offer a more engaging and effective way to navigate complex decision spaces, leading to higher
user satisfaction and better recommendation outcomes.
Advantages and Disadvantages of Content-Based Recommendation Systems

Advantages
Personalized Recommendations
Content-based systems tailor suggestions to each individual user by analyzing their explicit
preferences and past behavior, resulting in highly relevant recommendations [71] [72] [73] .
No Need for Other Users’ Data
These systems operate independently of other users’ interactions or ratings, making them
well-suited for environments with limited user data or when privacy is a concern [71] [72] [74] .
Effective for Niche Interests
Content-based filtering can recommend niche or unique items that may not be popular
among the general user base but align closely with a specific user’s interests [75] [71] [72] .
Handles New Items Well
Since recommendations are based on item features rather than user ratings, new items can
be recommended immediately without waiting for user feedback, addressing the "cold
start" problem for items [71] [76] [72] [77] .
Transparency and Explainability
The system can explain recommendations based on item attributes (e.g., "recommended
because it shares the same genre or author"), which increases user trust and
understanding [72] [78] .
Scalability
Content-based systems can scale to large numbers of users because each user’s
recommendations are computed independently, without the need to compare across all
users [71] [74] .
Simplicity in Implementation
These systems are generally simpler to implement and maintain than collaborative filtering,
as they primarily require accurate item attribute assignment [72] .

Disadvantages
Limited Novelty and Diversity (Overspecialization)
Recommendations tend to be very similar to what the user has already seen or liked, which
can lead to a lack of diversity and surprise in suggestions (the "filter bubble" effect) [71] [76]
[72] [73] .

Feature Engineering Dependency

The quality of recommendations heavily depends on the quality and completeness of item
features. Hand-engineering features requires significant domain knowledge and can be
labor-intensive [71] [76] [72] .
Scalability of Attribute Assignment
As the number of items grows, assigning and maintaining accurate attributes for all items
becomes challenging and resource-intensive [72] .
 Limited to Observable Features
Content-based systems can only recommend items based on the features they can observe
and encode. If user preferences depend on hidden or unrepresented aspects, the system
may miss important recommendations [76] [72] .
User Profile Limitation
The system’s understanding of user interests is limited to what the user has previously
interacted with, making it less capable of suggesting items outside the user’s established
profile [71] [76] [73] .
Cold Start for New Users
While content-based systems handle new items well, they still struggle with new users who
have not provided enough data to build a meaningful profile [76] [72] .

In summary:
Content-based recommendation systems excel at delivering personalized, transparent, and
niche recommendations without relying on other users’ data, and they handle new items
efficiently. However, they may suffer from overspecialization, depend heavily on high-quality
feature engineering, and struggle with novelty, diversity, and new user scenarios [75] [71] [76] [72]
[73] .

Note on Matrix Factorization and Latent Factors

Matrix factorization is a foundational technique in modern recommender systems, especially for
collaborative filtering. Its core idea is to decompose the user-item interaction matrix (such as a
ratings matrix) into the product of two lower-dimensional matrices: one representing users and
the other representing items [79] [80] [81] .

How Matrix Factorization Works

Given a user-item matrix $ R $ (where each entry $ r_{ui} $ is the rating of user $ u $ for
item $ i $), matrix factorization seeks to find two matrices:
$ U $: a user-feature matrix (users × latent factors)
$ V $: an item-feature matrix (items × latent factors)
The product $ U \times V^T $ approximates the original matrix $ R $.
Each user and each item is represented as a vector in a shared "latent factor" space [79]
[80] .

Latent Factors
Latent factors are hidden features inferred from the data, not explicitly labeled or observed.
In the context of movies, for example, latent factors might capture dimensions such as
genre preference, action vs. romance, or affinity for certain actors, even if these are not
directly specified in the data.
 The model learns these factors by minimizing the difference between the actual ratings and
the predicted ratings (often using techniques like Singular Value Decomposition, SVD) [80]
[81] .

Why Matrix Factorization is Effective

Captures complex user-item interactions: By learning latent factors, matrix factorization
can model subtle and complex relationships between users and items that are not captured
by simple similarity metrics [79] [82] .
Handles sparse data: It is efficient and effective even when the user-item matrix is large
and sparse, which is common in real-world recommendation scenarios [83] [82] [81] .
Scalable and flexible: Matrix factorization methods can be extended to include side
information (such as content features or context) and adapted for various recommendation
tasks [84] [85] [86] .

Example
Suppose a movie recommender system has thousands of users and movies, but only a small
fraction of possible ratings are filled in. Matrix factorization will:
Assign each user a vector (e.g., [0.2, -0.5, 1.3]) and each movie a vector (e.g., [0.7, 0.1,
-1.2]) in a latent space.
The predicted rating for a user-movie pair is the dot product of their vectors.
The latent factors might correspond to abstract concepts like "preference for action
movies" or "liking for comedies," even if these aren't explicitly labeled.

Summary Table
Term Description

Matrix Factorization Decomposes user-item interaction matrix into user and item latent factor matrices

Latent Factors Hidden features inferred from data, capturing underlying patterns in preferences

Application Widely used in collaborative filtering for recommendation systems

In summary:
Matrix factorization is a powerful technique that uncovers latent factors representing users and
items, enabling accurate and scalable recommendations by modeling complex, hidden
relationships in the data [79] [80] [81] .
⁂
Note on Pipelined Hybridization Design
Pipelined hybridization design is a strategy in hybrid recommender systems where multiple
recommendation algorithms are organized in a sequential pipeline. In this approach, the output
of one recommender serves as the input (or part of the input) for the next recommender in the
sequence. This design enables each stage to refine, filter, or enrich the recommendations
produced by the previous stage, often leading to more precise and contextually relevant
results [87] [88] .

Key Characteristics
Sequential Processing: Each component in the pipeline processes the data or
recommendations from the previous component, rather than operating independently or in
parallel.
Specialization: Different recommenders in the pipeline can focus on specific aspects of the
recommendation task (e.g., filtering by content first, then ranking by collaborative filtering).
Refinement: Later stages can refine, re-rank, or further restrict the candidate items
identified by earlier stages, resulting in higher precision.

Common Pipelined Designs

1. Cascade Approach
The first recommender generates an initial set of candidate items (e.g., using content-based
filtering).
The next recommender (e.g., collaborative filtering) refines this set, perhaps by re-ranking
or filtering further.
Successive recommenders can continue to narrow down or reorder the list.
Each stage may only consider items passed from its predecessor, producing highly focused
results [87] [89] [88] .
2. Meta-level Approach
The first recommender builds a model (such as a user profile or latent factor representation).
The subsequent recommender uses this model as input for its own recommendation
process.
For example, a content-based system might first construct a user profile, which is then used
by a collaborative filtering algorithm to find similar users or items [87] [88] .

Example
Online Course Recommendation (Cascade Approach):
Stage 1: A content-based recommender filters courses based on user-specified topics and
prerequisites.
 Stage 2: Collaborative filtering takes this filtered list and re-ranks courses based on ratings
from similar users.
The user receives a highly relevant, personalized shortlist of courses [89] .

Advantages
Precision: By sequentially narrowing down options, pipelined designs can produce highly
relevant recommendations.
Modularity: Each stage can be optimized or replaced independently, allowing flexible
system evolution.
Complex Task Handling: Suitable for complex recommendation scenarios where different
algorithms excel at different subtasks.

Disadvantages
Complexity: Requires careful design to ensure compatibility and efficiency between stages.
Potential Information Loss: Each stage may discard potentially relevant items if not
carefully tuned.
Higher Latency: Sequential processing can increase response time compared to parallel
approaches [88] .

Summary Table
Stage Description

Stage 1 Initial filtering or modeling (e.g., content-based filtering)

Stage 2 Further refinement or ranking (e.g., collaborative filtering)

Stage 3+ Additional enrichment or personalization (optional)

In summary:
Pipelined hybridization design leverages the strengths of multiple recommender algorithms in a
sequential manner, enabling each to contribute its unique capabilities to the final
recommendation. This approach is especially valuable for tasks requiring multi-stage filtering,
refinement, or modeling, but demands thoughtful integration and system design for optimal
results [87] [88] .
⁂

1. https://en.wikipedia.org/wiki/Cold_start_(recommender_systems)
2. https://www.linkedin.com/pulse/cold-start-problem-recommender-systems-strategies-iain-brown-ph-
d--4lsce
3. https://www.tredence.com/blog/solving-the-cold-start-problem-in-collaborative-recommender-system
s
4. https://thingsolver.com/blog/the-cold-start-problem/
5. https://vinija.ai/recsys/cold-start/
 6. https://www.expressanalytics.com/blog/cold-start-problem/
7. https://www.freecodecamp.org/news/cold-start-problem-in-recommender-systems/
8. https://www.studocu.com/in/document/anna-university/recommender-system/unit-iv-unit-4/89273415
9. https://grouplens.org/beyond2005/full/burke.pdf
10. https://papers.ssrn.com/sol3/Delivery.cfm/SSRN_ID4712941_code6471361.pdf?abstractid=4712941
11. https://www.ijircst.org/DOC/3-major-challenges-of-recommender-system-and-related-solutions.pdf
12. https://www.ijltet.org/wp-content/uploads/2014/10/21.pdf
13. https://ijiet.com/wp-content/uploads/2013/03/1.pdf
14. https://www.sciencedirect.com/topics/computer-science/hybrid-recommendation
15. https://www.semanticscholar.org/paper/a24cf27c8183f0fa0dcffc9ac5643382d20e2dbd
16. https://en.wikipedia.org/wiki/Knowledge-based_recommender_system
17. https://www.fi.muni.cz/~xpelanek/PV254/slides/other-techniques.pdf
18. https://www.frontiersin.org/journals/big-data/articles/10.3389/fdata.2024.1304439/full
19. https://arxiv.org/pdf/2206.02631.pdf
20. https://www.semanticscholar.org/paper/a6d41840e9c906130e8ab6a1965f9ec359596046
21. https://www.semanticscholar.org/paper/148d4d42447f32d0d80e189c96963174853be1ab
22. https://arxiv.org/vc/arxiv/papers/1402/1402.2145v1.pdf
23. https://arxiv.org/pdf/1912.08932.pdf
24. https://arxiv.org/pdf/1711.04101.pdf
25. http://arxiv.org/pdf/2308.04247.pdf
26. https://arxiv.org/pdf/2503.21188.pdf
27. https://arxiv.org/pdf/1807.11698.pdf
28. https://arxiv.org/pdf/2302.02579.pdf
29. https://arxiv.org/pdf/1802.08452.pdf
30. https://www.encora.com/insights/recommender-system-series-part-2-neighborhood-based-collaborati
ve-filtering
31. https://aurigait.com/blog/recommendation-system-using-knn/
32. https://www.semanticscholar.org/paper/ca2771c4cd41873f54364661fdcc4d7927aed9d4
33. https://www.alibabacloud.com/blog/basic-concepts-and-architecture-of-a-recommender-system_596
642
34. https://www.algolia.com/blog/ai/the-anatomy-of-high-performance-recommender-systems-part-iv
35. https://www.zevi.ai/blogs/what-is-a-content-based-recommendation-system-and-how-do-you-build-o
ne
36. https://spotintelligence.com/2023/11/15/content-based-recommendation-system/
37. https://developers.google.com/machine-learning/recommendation/content-based/basics
38. https://media.neliti.com/media/publications/467888-content-based-recommender-system-archite-15a
dc9ac.pdf
39. https://www.engati.com/glossary/content-based-filtering
40. https://www.stratascratch.com/blog/step-by-step-guide-to-building-content-based-filtering/
41. https://arxiv.org/pdf/2212.00139.pdf
42. https://www.semanticscholar.org/paper/65b4d7e619f3b11074edc6cd708962a5e4535649
43. http://arxiv.org/pdf/2404.11818.pdf
44. https://arxiv.org/pdf/1809.07053.pdf
45. https://www.semanticscholar.org/paper/6bc3c15139b7a919e2461d425ffb83d51599a604
46. https://arxiv.org/abs/2008.07702
47. https://arxiv.org/pdf/2008.00202.pdf
48. https://bluepiit.com/blog/hybrid-recommender-systems
49. https://www.slideshare.net/slideshow/unit-iv-knowledge-and-hybrid-recommendation-systempdf/2670
37336
50. https://marketsy.ai/blog/hybrid-recommender-systems-beginners-guide
51. https://web-ainf.aau.at/pub/jannach/files/BookChapter_Constraint-BasedRS_2015.pdf
52. https://scholarspace.manoa.hawaii.edu/bitstreams/cc2753a1-fa6a-4f6a-8f35-a4275214816d/download
53. https://www.igi-global.com/article/datatourist/276775
54. https://arxiv.org/pdf/2307.10702.pdf
55. https://www.linkedin.com/pulse/recommender-system-evaluation-goals-part-i-sergey-vasilyev
56. https://milvus.io/ai-quick-reference/what-are-the-key-metrics-for-evaluating-recommender-systems
57. http://arxiv.org/pdf/1209.1983.pdf
58. https://arxiv.org/pdf/2402.04457.pdf
59. https://www.evidentlyai.com/ranking-metrics/evaluating-recommender-systems
60. https://www.evidentlyai.com/ranking-metrics/evaluating-recommender-systems
61. https://neptune.ai/blog/recommender-systems-metrics
62. https://milvus.io/ai-quick-reference/what-are-the-key-metrics-for-evaluating-recommender-systems
63. https://towardsdatascience.com/evaluation-metrics-for-recommendation-systems-an-overview-71290
690ecba/
64. https://arxiv.org/html/2312.16015v2
65. https://www.educative.io/answers/what-are-the-evaluation-metrics-for-recommendation-systems
66. https://archive.nyu.edu/bitstream/2451/14303/1/IS-98-17.pdf
67. https://aman.ai/recsys/metrics/
68. https://en.wikipedia.org/wiki/Covariance_matrix
69. https://onlinelibrary.wiley.com/doi/10.1155/2018/9740402
70. http://winsty.net/papers/scmf.pdf
71. https://www.engati.com/glossary/content-based-filtering
72. https://www.upwork.com/resources/what-is-content-based-filtering
73. https://www.linkedin.com/pulse/collaborative-filtering-vs-content-based-recommender-aaz-el-aarab
74. https://www.turing.com/kb/content-based-filtering-in-recommender-systems
75. https://developers.google.com/machine-learning/recommendation/content-based/summary
76. https://www.ibm.com/think/topics/content-based-filtering
77. https://www.ijltet.org/wp-content/uploads/2014/10/21.pdf
78. https://arxiv.org/pdf/2405.05562.pdf
79. https://arxiv.org/pdf/2308.04661.pdf
80. https://arxiv.org/pdf/2203.11026v1.pdf
81. https://www.semanticscholar.org/paper/d78d78cc48604d7b9f69596b6a704459b7d1ef58
82. https://arxiv.org/pdf/1807.05515.pdf
83. http://arxiv.org/pdf/1405.0770.pdf
84. https://arxiv.org/pdf/2112.03089.pdf
85. http://arxiv.org/pdf/1210.5631.pdf
86. https://www.semanticscholar.org/paper/1ddc1105217abed5fab957c06d4efdd8645a7392
87. https://www.ksi.mff.cuni.cz/~peska/vyuka/nswi166/old/nswi166_06_HybridRecsysIntro.pdf
88. https://csse.szu.edu.cn/staff/panwk/recommendation/MISC/HybridRecommendation.pdf
89. https://www.slideshare.net/slideshow/unit-iv-knowledge-and-hybrid-recommendation-systempdf/2670
37336