This article describes how to use Python's Surprise library to build a basic recommendation system. First, load the scoring data and perform pre-processing; second, select a suitable collaborative filtering algorithm (such as SVD) to train the model and evaluate the effect; then write a function to generate a user-personalized recommendation list; finally, use parameter tuning to improve the accuracy of the model. The steps are clear and suitable for introductory practice.

Recommendation systems are an indispensable part of modern applications, such as the "Guess You Like" for e-commerce platforms and the "Personalized Recommendations" for video platforms. Although relatively lightweight, Python's Surprise library is very suitable for getting started and quickly implementing recommended models for collaborative filtering classes. Let’s start from a few actual needs and talk about how to use Surprise to build a basic recommendation engine.

Data preparation: Load your rating data

Surprise supports loading data from a pandas DataFrame in local files or in memory. The most common one is the user-item rating list (User-ID, Item-ID, Rating). You can test it with built-in datasets or use your own data.

 from surprise import Dataset
from surprise import Reader
import pandas as pd

# Suppose you have a DataFrame like this:
data = pd.DataFrame({
    'userID': [1, 1, 2, 2, 3],
    'itemID': [101, 102, 101, 103, 102],
    'rating': [4, 5, 3, 4, 2]
})

reader = Reader(rating_scale=(1, 5))
dataset = Dataset.load_builtin('ml-100k') # Built-in MovieLens data# Or use custom data:
data = Dataset.load_builtin(data, reader=reader)

Note: If your data is not normalized or the scope is not uniform, remember to process the scoring field in advance.

Algorithm selection: Choose a suitable collaborative filtering method

Surprise provides a variety of collaborative filtering algorithms, commonly used ones include:

• KNNBasic : User-CF or Item-CF
• SVD : Matrix decomposition, suitable for implicit feature modeling
• SVDpp : An improved version of SVD, considering implicit feedback
• NMF : Non-negative matrix decomposition, suitable for sparse scoring data

For example, use SVD:

 from surprise import SVD
from surprise.model_selection import train_test_split

trainset, testset = train_test_split(dataset, test_size=0.25)
model = SVD()
model.fit(trainset)
predictions = model.test(testset)

The model effect can be evaluated based on the RMSE metric:

 from surprise import accuracy

accuracy.rmse(predictions) # Output RMSE value

Beginners are advised to start with SVD, which performs stably in most cases.

Recommendation generation: Recommend items to users

After training the model, the next step is to generate recommendations. Surprise itself does not have a direct recommendation interface. You need to write a small function to predict the user's ratings of all unrated items and sort them by scores.

For example:

 def get_top_n_recommendations(model, user_id, n=10):
    # Get the item that the user has already scored user_ratings = trainset.ur[trainset.to_inner_uid(user_id)]
    items_rated_by_user = set(iid for (iid, _) in user_ratings)

    # Prediction score all_items = trainset.all_items()
    predictions = []
    for iid in all_items:
        if iid not in items_rated_by_user:
            predictions.append((iid, model.predict(uid=user_id, iid=iid).est))

    # Sort Top-N
    predictions.sort(key=lambda x: x[1], reverse=True)
    return predictions[:n]

Call method:

 top_recs = get_top_n_recommendations(model, user_id=196, n=5)
print(top_recs)

This function returns the recommended item ID and predicted score, which is suitable for displaying recommended results.

Adjusting participation in optimization: Make the model more accurate

Surprise supports GridSearchCV for parameter search, and can automatically find the optimal hyperparameter combination. For example:

 from surprise.model_selection import GridSearchCV

param_grid = {
    'n_epochs': [20, 30],
    'lr_all': [0.005, 0.01],
    'reg_all': [0.02, 0.1]
}

gs = GridSearchCV(SVD, param_grid, measures=['rmse'], cv=3)
gs.fit(data)

print(gs.best_params['rmse']) # View the best parameters

In addition, you can also try different scoring normalization methods and use cross-validation to improve stability.

Basically that's it. Using Surprise to recommend is not complicated, but there are several details that are easy to ignore, such as scoring range settings, cold start issues, recommended deduplication, etc. However, it is enough for the introduction or small-scale recommendation system development.

The above is the detailed content of Building Recommendation Engines with Python Surprise Library. For more information, please follow other related articles on the PHP Chinese website!