0Pricing
Neo4j Graph Database Fundamentals · Pelajaran

Membangun Mesin Rekomendasi

Pahami cara Neo4j mendukung sistem rekomendasi canggih dengan memanfaatkan koneksi antara pengguna dan item.

Membangun Mesin Rekomendasi adalah pelajaran Neo4j Graph Database Fundamentals gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Neo4j Graph Database Fundamentals, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Neo4j Graph Database Fundamentals mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun Mesin Rekomendasi” gratis?

Ya — teks lengkap “Membangun Mesin Rekomendasi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Neo4j Graph Database Fundamentals, upgrade ke CoddyKit PRO. Kursus Neo4j Graph Database Fundamentals mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membangun Mesin Rekomendasi”?

Pahami cara Neo4j mendukung sistem rekomendasi canggih dengan memanfaatkan koneksi antara pengguna dan item. Kamu berlatih Neo4j Graph Database Fundamentals dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Neo4j Graph Database Fundamentals?

Tidak diperlukan pengalaman sebelumnya. Neo4j Graph Database Fundamentals di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Membangun Mesin Rekomendasi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Neo4j Graph Database Fundamentals ini?

Ya. Setiap pelajaran Neo4j Graph Database Fundamentals menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Membangun Mesin Rekomendasi
  2. Deteksi dan Investigasi Penipuan
  3. Graf Pengetahuan dan Data Induk
  4. Graf Jaringan dan Operasi IT
← Kembali ke Neo4j Graph Database Fundamentals