0Pricing
Neo4j Graph Database Fundamentals · Leçon

Créer des moteurs de recommandation

Comprenez comment Neo4j alimente des systèmes de recommandation sophistiqués en exploitant les connexions entre les utilisateurs et les éléments.

Créer des moteurs de recommandation est une leçon Neo4j Graph Database Fundamentals gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Neo4j Graph Database Fundamentals, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Neo4j Graph Database Fundamentals comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

What are Recommendations?

Have you ever noticed how streaming services suggest your next show, or online stores recommend products you might like? This magic comes from recommendation engines.

These systems analyze user behavior and item attributes to predict what a user will be interested in. Their goal is to enhance user experience and drive engagement.

Graphs & Recommendations

Graph databases like Neo4j are uniquely suited for building recommendation engines because they excel at modeling and querying connections.

Recommendations are all about relationships: users like items, users are similar to other users, items are related to other items. A graph naturally represents these connections.

Modeling User-Item Data

In Neo4j, we model users and items as nodes, and their interactions as relationships.

  • User Nodes: Represent individuals (e.g., (:User {name: 'Alice'})).
  • Item Nodes: Represent products, movies, articles (e.g., (:Movie {title: 'The Matrix'})).
  • Interaction Relationships: Connect users and items (e.g., -[:LIKES]->, -[:BOUGHT]->, -[:RATED {score: 5}]->).

Initial Recs Data

Let's create a small graph to demonstrate. We'll have users, movies, and LIKES relationships.

This simple model allows us to easily traverse connections to find recommendations.

CREATE (:User {name: 'Alice'})-[:LIKES]->(:Movie {title: 'Inception'})
CREATE (:User {name: 'Alice'})-[:LIKES]->(:Movie {title: 'The Matrix'})
CREATE (:User {name: 'Bob'})-[:LIKES]->(:Movie {title: 'The Matrix'})
CREATE (:User {name: 'Bob'})-[:LIKES]->(:Movie {title: 'Interstellar'})
CREATE (:User {name: 'Charlie'})-[:LIKES]->(:Movie {title: 'Inception'})
CREATE (:User {name: 'Charlie'})-[:LIKES]->(:Movie {title: 'Interstellar'})

Item-Based Recommendations

An item-based recommendation suggests items that are similar to what a user already likes. The idea is: 'users who liked this item, also liked that item.'

We find items frequently liked together by the same users. This is great for suggesting related products or content.

Cypher: Item-Based Recs

Let's find movies similar to 'The Matrix' based on other users' likes.

We look for users who liked 'The Matrix', and then see what other movies *those same users* liked.

MATCH (m1:Movie {title: 'The Matrix'})<-[:LIKES]-(u:User)-[:LIKES]->(m2:Movie)
WHERE m1 <> m2
RETURN m2.title AS RecommendedMovie, count(DISTINCT u) AS LikedBySameUsers
ORDER BY LikedBySameUsers DESC
LIMIT 3

User-Based Recommendations

User-based recommendation suggests items that similar users have liked. The core idea is: 'people like you liked these items.'

We first identify users with similar tastes, and then recommend items that those similar users liked but the current user hasn't seen yet.

Cypher: User-Based Recs

Let's find movies 'Alice' might like, based on users similar to her.

We find users who liked movies Alice liked, then recommend movies *they* liked but Alice hasn't.

MATCH (alice:User {name: 'Alice'})-[:LIKES]->(m:Movie)<-[:LIKES]-(otherUser:User)
WHERE alice <> otherUser
WITH otherUser, collect(m) AS commonMovies
MATCH (otherUser)-[:LIKES]->(recommendedMovie:Movie)
WHERE NOT (alice)-[:LIKES]->(recommendedMovie)
RETURN recommendedMovie.title AS RecommendedMovie, count(DISTINCT otherUser) AS LikedBySimilarUsers
ORDER BY LikedBySimilarUsers DESC
LIMIT 3

Enhancing Recommendations

Recommendation engines can be made more sophisticated by incorporating more data:

  • Ratings: Use -[:RATED {score: 4}]-> to capture preference intensity.
  • Content Attributes: Link movies by -[:HAS_GENRE]-> or products by -[:IS_CATEGORY]->.
  • Timestamps: Factor in recent interactions for freshness.

These enrich the graph for more relevant suggestions.

Recommendation Query Check

Consider a graph with (:User)-[:WATCHED]->(:Movie) relationships. Which of the following Cypher patterns could be part of a query to find movies watched by users similar to 'Bob', but not yet watched by 'Bob'?

Recap: Recommendation Engines

In this lesson, you learned how Neo4j is ideal for building recommendation engines due to its relationship-first nature.

  • We modeled users, items, and their interactions as nodes and relationships.
  • You explored both item-based and user-based recommendation strategies using practical Cypher queries.
  • You also saw how to enrich your graph model for more sophisticated recommendations.

Graph databases simplify complex recommendation logic, making it intuitive and performant!

Questions Fréquemment Posées

La leçon « Créer des moteurs de recommandation » est-elle gratuite ?

Oui — le texte complet de « Créer des moteurs de recommandation » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Neo4j Graph Database Fundamentals, passe à CoddyKit PRO. Le cours Neo4j Graph Database Fundamentals comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Créer des moteurs de recommandation » ?

Comprenez comment Neo4j alimente des systèmes de recommandation sophistiqués en exploitant les connexions entre les utilisateurs et les éléments. Tu pratiques Neo4j Graph Database Fundamentals avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Neo4j Graph Database Fundamentals ?

Aucune expérience préalable n'est requise. Neo4j Graph Database Fundamentals sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Créer des moteurs de recommandation » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Neo4j Graph Database Fundamentals ?

Oui. Chaque leçon Neo4j Graph Database Fundamentals inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Créer des moteurs de recommandation
  2. Détection et investigation des fraudes
  3. Graphes de connaissances et données de référence
  4. Graphes des réseaux et des opérations informatiques
← Retour à Neo4j Graph Database Fundamentals