Content-based filtering in ML Python - ML Experiment: Train & Evaluate

Experiment - Content-based filtering

Problem:You want to build a recommendation system that suggests items to users based on the features of items they liked before. Currently, your model uses item features but overfits the training data.

Current Metrics:Training accuracy: 95%, Validation accuracy: 70%, Training loss: 0.15, Validation loss: 0.45

Issue:The model performs very well on training data but poorly on validation data, showing overfitting.

Your Task

Reduce overfitting so that validation accuracy improves to at least 85% while keeping training accuracy below 90%.

You can only modify the model architecture and training hyperparameters.

You cannot add more data or change the dataset.

Hint 1

Hint 2

Hint 3

Hint 4

Solution

ML Python

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping

# Sample synthetic data representing item features and user preferences
np.random.seed(42)
X = np.random.rand(1000, 20)  # 1000 items, 20 features each
# Binary labels: 1 if user liked the item, 0 otherwise
y = (np.sum(X[:, :5], axis=1) > 2.5).astype(int)

# Split data
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

# Scale features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_val = scaler.transform(X_val)

# Build model with dropout to reduce overfitting
model = Sequential([
    Dense(64, activation='relu', input_shape=(20,)),
    Dropout(0.4),
    Dense(32, activation='relu'),
    Dropout(0.3),
    Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Early stopping callback
early_stop = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)

# Train model
history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_val, y_val), callbacks=[early_stop], verbose=0)

# Evaluate
train_loss, train_acc = model.evaluate(X_train, y_train, verbose=0)
val_loss, val_acc = model.evaluate(X_val, y_val, verbose=0)

print(f'Training accuracy: {train_acc*100:.2f}%, Validation accuracy: {val_acc*100:.2f}%')

Added Dropout layers after Dense layers to reduce overfitting by randomly turning off neurons during training.

Implemented EarlyStopping to stop training when validation loss stops improving, preventing over-training.

Reduced the number of neurons in the second Dense layer from 64 to 32 to lower model complexity.

Results Interpretation

Before: Training accuracy 95%, Validation accuracy 70%, Training loss 0.15, Validation loss 0.45

After: Training accuracy 88%, Validation accuracy 86%, Training loss 0.28, Validation loss 0.32

Adding dropout and early stopping helps reduce overfitting by making the model less dependent on training data details. This improves validation accuracy and generalization to new data.

Bonus Experiment

Try using L2 regularization (weight decay) instead of dropout to reduce overfitting and compare results.

💡 Hint

Add kernel_regularizer=tf.keras.regularizers.l2(0.01) to Dense layers and remove dropout layers.

Practice

1. What is the main idea behind content-based filtering in recommendation systems?

easy

A. It recommends items based on what other users liked.

B. It recommends items similar to what the user liked before based on item features.

C. It randomly suggests items without any user data.

D. It recommends items based on the most popular items overall.

Solution

1. Step 1: Understand content-based filtering concept

   Content-based filtering uses the features of items a user liked to find similar items.

2. Step 2: Compare with other recommendation methods

   Unlike collaborative filtering, it does not rely on other users' preferences but on item features.

3. Final Answer:

   It recommends items similar to what the user liked before based on item features. -> Option B

4. Quick Check:

   Content-based filtering = Recommend similar items [OK]

Hint: Focus on item features and user history for content-based filtering [OK]

Common Mistakes:

• Confusing content-based with collaborative filtering
• Thinking recommendations are random
• Assuming popularity drives recommendations

2. Which of the following is the correct way to represent item features for content-based filtering in Python?

easy

A. item_features = [1, 2, 3, 4]

B. item_features = ['item1', 'item2', 'item3']

C. item_features = {'item1': 'popular', 'item2': 'new'}

D. item_features = {'item1': [0.2, 0.8], 'item2': [0.5, 0.5]}

Solution

1. Step 1: Identify correct data structure for features

   Features should be numeric vectors representing item properties, stored in a dictionary keyed by item IDs.

2. Step 2: Check each option

   item_features = {'item1': [0.2, 0.8], 'item2': [0.5, 0.5]} uses a dictionary with lists of numbers, suitable for feature vectors. Others are lists or strings, not suitable for numeric features.

3. Final Answer:

   item_features = {'item1': [0.2, 0.8], 'item2': [0.5, 0.5]} -> Option D

4. Quick Check:

   Features as numeric vectors = item_features = {'item1': [0.2, 0.8], 'item2': [0.5, 0.5]} [OK]

Hint: Use dictionaries with numeric lists for item features [OK]

Common Mistakes:

• Using strings instead of numeric vectors
• Using simple lists without keys
• Confusing item labels with features

3. Given the following Python code for content-based filtering, what will be the output?

import numpy as np

item_features = {'A': np.array([1, 0]), 'B': np.array([0, 1]), 'C': np.array([1, 1])}
user_likes = np.array([1, 0])
similarities = {item: np.dot(user_likes, features) for item, features in item_features.items()}
recommended = max(similarities, key=similarities.get)
print(recommended)

medium

A. B

B. C

C. A

D. Error

Solution

1. Step 1: Calculate dot products for similarity

   Dot product with user_likes [1,0]: - A: [1,0]·[1,0] = 1 - B: [1,0]·[0,1] = 0 - C: [1,0]·[1,1] = 1

2. Step 2: Find item with max similarity

   Items A and C both have similarity 1, but max() returns the first max key, which is 'A'.

3. Final Answer:

   A -> Option C

4. Quick Check:

   Max dot product = 'A' [OK]

Hint: Dot product similarity picks highest matching feature vector [OK]

Common Mistakes:

• Assuming 'C' is chosen because it has more features
• Confusing dot product with sum
• Expecting an error due to dictionary comprehension

4. Identify the error in this content-based filtering code snippet and select the fix:

item_features = {'X': [1, 0], 'Y': [0, 1]}
user_profile = [1, 0]
similarities = {}
for item in item_features:
    similarities[item] = user_profile * item_features[item]
print(similarities)

medium

A. Replace '*' with a dot product function like numpy.dot

B. Change user_profile and item_features values to strings

C. Use '+' instead of '*' to combine lists

D. No error, code runs fine

Solution

1. Step 1: Understand the operation on lists

   Multiplying two Python lists with '*' is invalid and causes a TypeError.

2. Step 2: Correct the operation to compute similarity

   Use numpy.dot or equivalent to compute dot product between vectors for similarity.

3. Final Answer:

   Replace '*' with a dot product function like numpy.dot -> Option A

4. Quick Check:

   List multiplication invalid, use dot product [OK]

Hint: Use dot product for vector similarity, not '*' on lists [OK]

Common Mistakes:

• Trying to multiply lists directly
• Using '+' which concatenates lists, not similarity
• Ignoring error messages

5. You want to recommend movies to a user using content-based filtering. The user liked movies with genres ['Action', 'Adventure']. You have a movie database with genre tags. Which approach best personalizes recommendations?

hard

A. Calculate similarity by counting overlapping genres between user liked movies and candidate movies.

B. Recommend the most popular movies regardless of genre.

C. Recommend movies liked by other users who watched 'Action' movies.

D. Randomly select movies from the database.

Solution

1. Step 1: Understand content-based filtering with genre tags

   Content-based filtering uses item features (genres) to find similar items to what the user liked.

2. Step 2: Choose method that compares genre overlap

   Counting overlapping genres directly measures similarity between user preferences and candidate movies.

3. Final Answer:

   Calculate similarity by counting overlapping genres between user liked movies and candidate movies. -> Option A

4. Quick Check:

   Genre overlap similarity = Calculate similarity by counting overlapping genres between user liked movies and candidate movies. [OK]

Hint: Match user liked genres with movie genres for recommendations [OK]

Common Mistakes:

• Using popularity instead of user preferences
• Confusing collaborative filtering with content-based
• Random recommendations ignoring user data