User-based vs item-based in ML Python - Model Approaches Compared

Model Pipeline - User-based vs item-based

This pipeline compares two popular recommendation methods: user-based and item-based collaborative filtering. Both use past user-item interactions to suggest new items, but user-based finds similar users, while item-based finds similar items.

Data Flow - 5 Stages

1Data Collection

1000 users x 500 items→Collect user ratings or interactions for items→1000 users x 500 items

User 123 rated Movie 45 as 4 stars

↓

2Preprocessing

1000 users x 500 items→Fill missing ratings with zeros or averages→1000 users x 500 items

Missing rating for User 10 on Item 20 replaced with 0

↓

3Similarity Calculation

1000 users x 500 items→Calculate similarity matrix (user-user or item-item)→1000 x 1000 (user-based) or 500 x 500 (item-based)

User 1 and User 2 similarity = 0.8 or Item 10 and Item 15 similarity = 0.75

↓

4Prediction

Similarity matrix and user-item matrix→Predict missing ratings using weighted average of neighbors→1000 users x 500 items with predicted ratings

Predicted rating for User 5 on Item 100 = 3.7

↓

5Recommendation

Predicted ratings matrix→Select top-N items with highest predicted ratings per user→1000 users x N recommended items

User 7 recommended items: [Item 23, Item 45, Item 78]

Training Trace - Epoch by Epoch

Loss
1.0 |*
0.9 | 
0.8 |*
0.7 | 
0.6 |*
0.5 |*
0.4 |*
0.3 |*
    +----------------
     1 2 3 4 5 Epochs

Epoch	Loss ↓	Accuracy ↑	Observation
1	0.85	0.40	Initial predictions are rough with high error
2	0.65	0.55	Model learns better similarity weights, error decreases
3	0.50	0.68	Predictions improve, accuracy rises steadily
4	0.40	0.75	Model converges with good recommendation quality
5	0.35	0.78	Minor improvements, stable performance

Prediction Trace - 4 Layers

Layer 1: Input user-item ratings

Layer 2: Calculate similarity

Layer 3: Predict missing rating

Layer 4: Generate recommendations

Model Quiz - 3 Questions

What does user-based collaborative filtering use to recommend items?

A Similar users' preferences

B Similar items' features

C Random item selection

D User demographic data

Key Insight

User-based and item-based collaborative filtering both rely on similarity but differ in focus: user-based finds similar users to predict preferences, while item-based finds similar items to recommend. Both improve predictions by learning from neighbors, shown by decreasing loss and increasing accuracy.

Practice

1. Which of the following best describes user-based recommendation?

easy

A. Suggest items liked by users similar to you

B. Suggest items similar to what you liked

C. Suggest random popular items

D. Suggest items based on item price

Solution

1. Step 1: Understand user-based recommendation

   User-based recommendation finds users similar to you and suggests what they liked.

2. Step 2: Compare options

   Suggest items liked by users similar to you matches this definition exactly, while others describe different or unrelated methods.

3. Final Answer:

   Suggest items liked by users similar to you -> Option A

4. Quick Check:

   User-based = Suggest items liked by similar users [OK]

Hint: User-based = find similar users, recommend their items [OK]

Common Mistakes:

• Confusing user-based with item-based
• Thinking user-based recommends similar items
• Choosing popular or random items as user-based

2. Which code snippet correctly represents item-based recommendation logic?

easy

A. recommend_items = find_similar_users(user).liked_items()

B. recommend_items = find_similar_items(user_liked_items)

C. recommend_items = random_popular_items()

D. recommend_items = items_sorted_by_price()

Solution

1. Step 1: Identify item-based recommendation code

   Item-based recommends items similar to those the user liked, so code should find similar items.

2. Step 2: Match code to logic

   recommend_items = find_similar_items(user_liked_items) calls find_similar_items(user_liked_items), which fits item-based logic. Others do not.

3. Final Answer:

   <code>recommend_items = find_similar_items(user_liked_items)</code> -> Option B

4. Quick Check:

   Item-based = find similar items [OK]

Hint: Item-based code finds similar items to user's liked items [OK]

Common Mistakes:

• Choosing user-based code for item-based question
• Confusing random or price sorting with item similarity
• Ignoring the input to similarity function

3. Given this code snippet for user-based recommendation:

user_similarities = {'User1': 0.9, 'User2': 0.8}
user_likes = {'User1': ['ItemA', 'ItemB'], 'User2': ['ItemB', 'ItemC']}
recommend = set()
for user, sim in user_similarities.items():
    if sim > 0.85:
        recommend.update(user_likes[user])
print(sorted(recommend))

What is the output?

medium

A. ['ItemA', 'ItemB', 'ItemC']

B. ['ItemB', 'ItemC']

C. ['ItemA', 'ItemB']

D. []

Solution

1. Step 1: Identify users with similarity > 0.85

   Only 'User1' has similarity 0.9 > 0.85, so only their liked items are added.

2. Step 2: Collect items liked by 'User1'

   'User1' likes ['ItemA', 'ItemB'], so these are added to the recommendation set.

3. Final Answer:

   ['ItemA', 'ItemB'] -> Option C

4. Quick Check:

   Similarity filter picks User1's items [OK]

Hint: Only users with similarity > 0.85 contribute items [OK]

Common Mistakes:

• Including items from User2 who has similarity 0.8
• Not sorting output before printing
• Confusing set update with append

4. Find the error in this item-based recommendation code:

user_liked = ['ItemA', 'ItemB']
def find_similar_items(items):
    return ['ItemC', 'ItemD']
recommend = find_similar_items(user_liked)
print(recommend)

What is the main problem?

medium

A. Syntax error in function definition

B. Print statement missing parentheses

C. Variable user_liked is not defined

D. Function returns unrelated items, ignoring input

Solution

1. Step 1: Check function behavior

   The function find_similar_items ignores its input and returns fixed items.

2. Step 2: Identify why this is a problem

   Item-based recommendation should return items similar to input, but this function does not use input at all.

3. Final Answer:

   Function returns unrelated items, ignoring input -> Option D

4. Quick Check:

   Function must use input to find similar items [OK]

Hint: Check if function uses input parameter correctly [OK]

Common Mistakes:

• Thinking code has syntax errors when it doesn't
• Ignoring that function ignores input
• Confusing variable names or print syntax

5. You want to build a hybrid recommendation system combining user-based and item-based methods. Which approach best fits this goal?

hard

A. Combine scores from similar users and similar items for each candidate

B. Use only user-based recommendations to simplify model

C. Use only item-based recommendations to reduce computation

D. Randomly pick recommendations from either user or item-based

Solution

1. Step 1: Understand hybrid recommendation

   Hybrid systems combine strengths of user-based and item-based methods to improve accuracy.

2. Step 2: Identify best combination method

   Combining scores from both similar users and similar items for each candidate item leverages both perspectives effectively.

3. Final Answer:

   Combine scores from similar users and similar items for each candidate -> Option A

4. Quick Check:

   Hybrid = combine user and item scores [OK]

Hint: Hybrid = combine user and item recommendation scores [OK]

Common Mistakes:

• Choosing only one method loses hybrid benefits
• Random picking reduces recommendation quality
• Ignoring score combination logic