Scoring Tracks with Confidence

Welcome back! In the previous lessons, you learned how to prepare training data from user session logs and how to train a machine learning model to predict which tracks a user might like. Now, you are ready to use this trained model to score tracks for each user.

In this lesson, you will learn how to use the model to assign a confidence score — called an "affinity score" — to each track for a given user. This score tells us how likely it is that the user will enjoy a particular track. These scores are the foundation for making smarter, more personalized music recommendations.

To score tracks for a user using a machine learning model, we need three things:

• A trained affinity model, which takes combined user-track vectors and returns a score.
• A user profile vector summarizing listening preferences.
• A track embedding for each track we want to score.

We'll use these to construct feature vectors and feed them into the model.

Now, let’s look at how predictive scoring actually works.

For each track you want to score for a user, you need to:

1. Create a feature vector by combining the user’s profile vector with the track’s embedding. This gives the model all the information it needs about both the user and the track.
2. Feed the feature vector into the trained model. The model will output a probability, which we call the affinity score.
3. Interpret the affinity score. This score is a number between 0 and 1. The closer it is to 1, the more confident the model is that the user will like the track.

For example, if the model gives a score of 0.85 for a track, it means there is an 85% chance (according to the model) that the user will enjoy that track.

Let’s walk through the main function that does this: predict_affinity_scores_for_user.

Here is the function from your project:

def predict_affinity_scores_for_user(user_id: str, track_ids_to_score: list, model):
    """Predicts affinity scores for a list of tracks for a given user using the trained model."""
    if model is None:
        print("Model not loaded. Cannot predict scores.")
        return {}

    user_profile_vec = generate_user_profile_vector(user_id)
    if user_profile_vec is None:
        print(f"Could not generate profile for user {user_id}. Cannot predict scores.")
        return {}

    all_track_ids_ordered, all_track_embeddings_matrix = get_track_embeddings()
    track_id_to_embedding = {tid: emb for tid, emb in zip(all_track_ids_ordered, all_track_embeddings_matrix)}

    feature_vectors_to_predict = []
    valid_track_ids_for_prediction = []

    for track_id in track_ids_to_score:
        if track_id in track_id_to_embedding:
            track_emb = track_id_to_embedding[track_id]
            feature_vectors_to_predict.append(np.concatenate([user_profile_vec, track_emb]))
            valid_track_ids_for_prediction.append(track_id)
    
    if not feature_vectors_to_predict:
        return {}
        
    # Predict probabilities (affinity scores)
    # The second column of predict_proba is the probability of the positive class (1)
    affinity_scores = model.predict_proba(pd.DataFrame(feature_vectors_to_predict))[:, 1]
    
    return dict(zip(valid_track_ids_for_prediction, affinity_scores))

Let’s break down what happens here:

• Model Check: The function first checks if the model is loaded. If not, it exits early. This prevents runtime crashes when calling .predict_proba on None.

• User Vector Creation: Calls generate_user_profile_vector(user_id). If the user has no history, it returns None, and scoring is skipped for that user.

• Track Embedding Mapping: Retrieves both ordered track IDs and embeddings in a single call to get_track_embeddings(), then zips them into a track_id → embedding dictionary for efficient lookup.

• Valid Feature Vector Construction: For each track to be scored:

  • If it has a valid embedding, concatenate the user profile and track vector.
  • Add it to the list for scoring.
  • Tracks with missing embeddings are skipped silently.

• Scoring with Model: Converts the list of vectors to a DataFrame and feeds it into model.predict_proba(). The second column [:, 1] gives the score for the positive class (liking the track).

• Return Format: Returns a dict of {track_id: score} for all valid tracks.

Let’s walk through the test file output to understand what’s being checked.

Test 1 — No Model Available

Calling predict_affinity_scores_for_user with model=None  
Model not loaded. Cannot predict scores.  
Returned Scores: {}  
✅ Passed: No model handled gracefully.

This confirms that the function gracefully handles the case where no model is loaded, by checking for model is None and returning an empty dictionary — instead of crashing or throwing an error.

Test 2 — Dummy Model with Known Vectors

Using profile vector [1.0, 2.0] and embeddings [[0.1, 0.2], [0.3, 0.4]]  
Returned Scores: {'t1': 3.3}  
✅ Passed: Correct scores returned for known track.

Here, the dummy model simply sums the feature vector values.

• The profile [1.0, 2.0] combined with embedding [0.1, 0.2] gives [1.0, 2.0, 0.1, 0.2], which sums to 3.3.
• This confirms the feature concatenation and prediction logic work as expected.

Once you have affinity scores, you can use them to recommend the most promising tracks to a user. That’s exactly what the function recommend_tracks_by_prediction() does.

• It first loads the trained model using load_model().
• It gets all available tracks, then filters out those already listened to by the user.
• It calls predict_affinity_scores_for_user() on the remaining tracks.
• Finally, it sorts the scores and returns the top N highest-scoring track IDs.

def recommend_tracks_by_prediction(user_id: str, top_n: int = 5):
    """
    Recommends tracks for a user based on ML model predictions.
    Excludes tracks already listened to by the user.
    """
    model = load_model() # Loads from default MODEL_FILE_PATH
    if model is None:
        print("Affinity model not available. Cannot provide predictive recommendations.")
        return []

    all_tracks_df = get_all_tracks()
    if all_tracks_df.empty:
        return []
    all_track_ids_available = all_tracks_df['id'].tolist()

    user_history_df = get_user_listening_history(user_id)
    listened_track_ids = []
    if not user_history_df.empty:
        listened_track_ids = user_history_df['track_id'].unique().tolist()
        
    unlistened_track_ids = [tid for tid in all_track_ids_available if tid not in listened_track_ids]
    
    if not unlistened_track_ids:
        return [] # No new tracks to recommend

    affinity_scores_map = predict_affinity_scores_for_user(user_id, unlistened_track_ids, model)
    
    if not affinity_scores_map:
        return []

    # Sort tracks by predicted affinity score
    sorted_recommendations = sorted(affinity_scores_map.items(), key=lambda item: item[1], reverse=True)
    
    # Get top N track IDs
    top_n_recommendations = [track_id for track_id, score in sorted_recommendations[:top_n]]
    
    return top_n_recommendations

Tip: Instead of always taking the top-N scores, you can set a minimum score threshold (e.g., 0.5 by default, or tuned via validation) to decide whether a track is “likely liked” or “unlikely.” This is especially useful when you want to filter out low-confidence recommendations, even if they appear in the top-N.

This is how the full recommendation loop is closed — from data → model → scores → top picks.

In this lesson, you learned how to use your trained model to score tracks for a user with predictive confidence. You saw how to combine user and track information, use the model to get affinity scores, and interpret the results.

These affinity scores are the key to making personalized recommendations. In the next practice exercises, you will get hands-on experience using these functions to score tracks and recommend the best ones to users.

Great job making it this far — let’s put these skills into practice!