Memprediksi Suka: Di Dalam Algoritma Mesin Rekomendasi Sederhana

Mesin rekomendasi (kadang-kadang disebut sebagai sistem pemberi rekomendasi) adalah alat yang memungkinkan pengembang algoritma memprediksi apa yang mungkin atau mungkin tidak disukai pengguna di antara daftar item yang diberikan. Mesin rekomendasi adalah alternatif yang cukup menarik untuk bidang pencarian, karena mesin rekomendasi membantu pengguna menemukan produk atau konten yang mungkin tidak mereka temukan sebaliknya. Ini membuat mesin rekomendasi menjadi bagian besar dari situs web dan layanan seperti Facebook, YouTube, Amazon, dan banyak lagi.

Mesin rekomendasi bekerja idealnya dengan salah satu dari dua cara. Itu dapat mengandalkan properti item yang disukai pengguna, yang dianalisis untuk menentukan apa lagi yang mungkin disukai pengguna; atau, itu dapat mengandalkan suka dan tidak suka dari pengguna lain, yang kemudian digunakan oleh mesin rekomendasi untuk menghitung indeks kesamaan antara pengguna dan merekomendasikan item yang sesuai kepada mereka. Dimungkinkan juga untuk menggabungkan kedua metode ini untuk membangun mesin rekomendasi yang jauh lebih kuat. Namun, seperti semua masalah terkait informasi lainnya, penting untuk memilih algoritme yang cocok untuk masalah yang ditangani.

Dalam tutorial ini, kami akan memandu Anda melalui proses membangun mesin rekomendasi yang kolaboratif dan berbasis memori. Mesin rekomendasi ini akan merekomendasikan film kepada pengguna berdasarkan apa yang mereka suka dan tidak suka, dan akan berfungsi seperti contoh kedua yang disebutkan sebelumnya. Untuk proyek ini, kita akan menggunakan operasi himpunan dasar, sedikit matematika, dan Node.js/CoffeeScript. Semua kode sumber yang relevan dengan tutorial ini dapat ditemukan di sini.

Himpunan dan Persamaan

Sebelum menerapkan mesin rekomendasi berbasis memori kolaboratif, pertama-tama kita harus memahami ide inti di balik sistem semacam itu. Untuk mesin ini, setiap item dan setiap pengguna tidak lain adalah pengidentifikasi. Oleh karena itu, kami tidak akan mempertimbangkan atribut film lainnya (misalnya, pemeran, sutradara, genre, dll.) saat membuat rekomendasi. Kesamaan antara dua pengguna direpresentasikan menggunakan angka desimal antara -1.0 dan 1.0. Kami akan menyebut nomor ini sebagai indeks kesamaan. Terakhir, kemungkinan pengguna menyukai film akan direpresentasikan menggunakan angka desimal lain antara -1.0 dan 1.0. Sekarang kita telah memodelkan dunia di sekitar sistem ini menggunakan istilah sederhana, kita dapat melepaskan beberapa persamaan matematika yang elegan untuk menentukan hubungan antara pengidentifikasi dan angka ini.

Dalam algoritme rekomendasi kami, kami akan mempertahankan sejumlah set. Setiap pengguna akan memiliki dua set: satu set film yang disukai pengguna, dan satu set film yang tidak disukai pengguna. Setiap film juga akan memiliki dua set yang terkait dengannya: satu set pengguna yang menyukai film tersebut, dan satu set pengguna yang tidak menyukai film tersebut. Selama tahap di mana rekomendasi dihasilkan, sejumlah set akan diproduksi - sebagian besar serikat pekerja atau persimpangan set lainnya. Kami juga akan memesan daftar saran dan pengguna serupa untuk setiap pengguna.

Untuk menghitung indeks kesamaan, kita akan menggunakan variasi dari rumus indeks Jaccard. Awalnya dikenal sebagai "koefisien de komunaute" (diciptakan oleh Paul Jaccard), rumus membandingkan dua set dan menghasilkan statistik desimal sederhana antara 0 dan 1,0:

Rumusnya melibatkan pembagian jumlah elemen umum di salah satu himpunan dengan jumlah semua elemen (dihitung hanya sekali) di kedua himpunan. Indeks Jaccard dari dua himpunan identik akan selalu menjadi 1, sedangkan indeks Jaccard dari dua himpunan tanpa elemen yang sama akan selalu menghasilkan 0. Sekarang setelah kita mengetahui bagaimana membandingkan dua himpunan, mari kita pikirkan strategi yang dapat kita gunakan untuk membandingkan dua pengguna. Seperti yang dibahas sebelumnya, pengguna, dari sudut pandang sistem, adalah tiga hal: pengenal, satu set film yang disukai, dan satu set film yang tidak disukai. Jika kita ingin menentukan indeks kesamaan pengguna kita hanya berdasarkan kumpulan film yang mereka sukai, kita bisa langsung menggunakan rumus indeks Jaccard:

Di sini, U1 dan U2 adalah dua pengguna yang kami bandingkan, dan L1 dan L2 adalah kumpulan film yang disukai U1 dan U2. Sekarang, jika Anda memikirkannya, dua pengguna yang menyukai film yang sama adalah serupa, maka dua pengguna yang tidak menyukai film yang sama juga harus serupa. Di sinilah kita memodifikasi persamaan sedikit:

Alih-alih hanya mempertimbangkan suka umum di pembilang rumus, kami sekarang menambahkan jumlah tidak suka umum juga. Dalam penyebut, kami mengambil jumlah semua item yang disukai atau tidak disukai pengguna. Sekarang kita telah mempertimbangkan suka dan tidak suka secara independen, kita juga harus memikirkan kasus di mana dua pengguna memiliki preferensi yang berlawanan. Indeks kesamaan dua pengguna yang satu menyukai film dan yang lainnya tidak menyukainya tidak boleh 0:

Itu satu rumus panjang! Tapi itu sederhana, saya janji. Ini mirip dengan rumus kami sebelumnya dengan perbedaan kecil di pembilangnya. Kami sekarang mengurangi jumlah suka dan tidak suka yang bertentangan dari dua pengguna dari jumlah suka dan tidak suka mereka. Hal ini menyebabkan rumus indeks kesamaan memiliki rentang nilai antara -1.0 dan 1.0. Dua pengguna yang memiliki selera yang sama akan memiliki indeks kesamaan 1,0 sementara dua pengguna yang memiliki selera yang sama sekali bertentangan dalam film akan memiliki indeks kesamaan -1.0.

Sekarang setelah kita mengetahui cara membandingkan dua pengguna berdasarkan selera mereka terhadap film, kita harus menjelajahi satu formula lagi sebelum kita dapat mulai menerapkan algoritme mesin rekomendasi buatan sendiri:

Mari kita pecahkan persamaan ini sedikit. Yang kami maksud dengan P(U,M) adalah kemungkinan pengguna U menyukai film M . ZL dan ZD adalah jumlah indeks kesamaan pengguna U dengan semua pengguna yang menyukai atau tidak menyukai film M . |ML|+|MD| mewakili jumlah total pengguna yang menyukai atau tidak menyukai film M . Hasil P(U,M) menghasilkan angka antara -1.0 dan 1.0.

Itu saja. Di bagian berikutnya, kita dapat menggunakan rumus ini untuk mulai mengimplementasikan mesin rekomendasi berbasis memori kolaboratif.

Membangun Mesin Rekomendasi

Kami akan membangun mesin rekomendasi ini sebagai aplikasi Node.js yang sangat sederhana. Juga akan ada sedikit pekerjaan di front-end, sebagian besar beberapa halaman dan formulir HTML (kami akan menggunakan Bootstrap untuk membuat halaman terlihat rapi). Di sisi server, kita akan menggunakan CoffeeScript. Aplikasi akan memiliki beberapa rute GET dan POST. Meskipun kami akan memiliki gagasan pengguna dalam aplikasi, kami tidak akan memiliki mekanisme pendaftaran/login yang rumit. Untuk persistensi, kami akan menggunakan paket Bourne yang tersedia melalui NPM yang memungkinkan aplikasi untuk menyimpan data dalam file JSON biasa, dan melakukan kueri basis data dasar pada file tersebut. Kami akan menggunakan Express.js untuk memudahkan proses pengelolaan rute dan penangan.

Pada titik ini, jika Anda baru dalam pengembangan Node.js, Anda mungkin ingin mengkloning repositori GitHub sehingga lebih mudah untuk mengikuti tutorial ini. Seperti halnya proyek Node.js lainnya, kita akan mulai dengan membuat file package.json dan menginstal satu set paket dependensi yang diperlukan untuk proyek ini. Jika Anda menggunakan repositori kloning, file package.json seharusnya sudah ada di sana, dari mana menginstal dependensi akan mengharuskan Anda untuk menjalankan "$ npm install". Ini akan menginstal semua paket yang terdaftar di dalam file package.json.

Paket Node.js yang kita butuhkan untuk proyek ini adalah:

• tidak sinkron
• maksud
• kopi-skrip
• cepat
• giok
• menggarisbawahi

Kami akan membangun mesin rekomendasi dengan membagi semua metode yang relevan menjadi empat kelas CoffeeScript terpisah, yang masing-masing akan disimpan di bawah “lib/engine”: Engine, Rater, Similars, dan Suggestions. Mesin kelas akan bertanggung jawab untuk menyediakan API sederhana untuk mesin rekomendasi, dan akan mengikat tiga kelas lainnya bersama-sama. Penilai akan bertanggung jawab untuk melacak suka dan tidak suka (sebagai dua contoh terpisah dari kelas Penilai). Kesamaan dan Saran akan bertanggung jawab untuk menentukan dan melacak pengguna serupa dan item yang direkomendasikan untuk pengguna, masing-masing.

Melacak Suka dan Tidak Suka

Mari kita mulai dengan kelas Penilai. Ini adalah yang sederhana:

 class Rater constructor: (@engine, @kind) -> add: (user, item, done) -> remove: (user, item, done) -> itemsByUser: (user, done) -> usersByItem: (item, done) ->

Seperti yang ditunjukkan sebelumnya dalam tutorial ini, kita akan memiliki satu instans Penilai untuk suka, dan satu lagi untuk tidak suka. Untuk mencatat bahwa pengguna menyukai suatu item, kami akan meneruskannya ke “Rater#add()”. Demikian pula, untuk menghapus peringkat, kami akan meneruskannya ke "Penilai#remove()".

Karena kami menggunakan Bourne sebagai solusi database tanpa server, kami akan menyimpan peringkat ini dalam file bernama "./db-#{@kind}.json", di mana jenisnya adalah "suka" atau "tidak suka". Kami akan membuka database di dalam konstruktor instance Rater:

 constructor: (@engine, @kind) -> @db = new Bourne "./db-#{@kind}.json"

Ini akan membuat penambahan catatan peringkat semudah memanggil metode database Bourne di dalam metode “Penilai#add()” kami:

 @db.insert user: user, item: item, (err) =>

Dan itu mirip dengan menghapusnya ("db.delete" alih-alih "db.insert"). Namun, sebelum kita menambahkan atau menghapus sesuatu, kita harus memastikan itu belum ada di database. Idealnya, dengan database yang sebenarnya, kita bisa melakukannya sebagai satu operasi. Dengan Bourne, kita harus melakukan pengecekan manual terlebih dahulu; dan, setelah penyisipan atau penghapusan selesai, kita perlu memastikan bahwa kita menghitung ulang indeks kesamaan untuk pengguna ini, dan kemudian menghasilkan serangkaian saran baru. Metode “Rater#add()” dan “Rater#remove()” akan terlihat seperti ini:

 add: (user, item, done) -> @db.find user: user, item: item, (err, res) => if res.length > 0 return done() @db.insert user: user, item: item, (err) => async.series [ (done) => @engine.similars.update user, done (done) => @engine.suggestions.update user, done ], done remove: (user, item, done) -> @db.delete user: user, item: item, (err) => async.series [ (done) => @engine.similars.update user, done (done) => @engine.suggestions.update user, done ], done

Untuk singkatnya, kami akan melewatkan bagian di mana kami memeriksa kesalahan. Ini mungkin hal yang wajar untuk dilakukan dalam sebuah artikel, tetapi bukan alasan untuk mengabaikan kesalahan dalam kode sebenarnya.

Dua metode lainnya, “Rater#itemsByUser()” dan “Rater#usersByItem()” dari kelas ini akan melibatkan melakukan apa yang tersirat dari namanya - mencari item yang dinilai oleh pengguna dan pengguna yang telah menilai item, masing-masing. Misalnya, ketika Rater dipakai dengan kind = “likes” , “Rater#itemsByUser()” akan menemukan semua item yang telah dinilai pengguna.

Menemukan Pengguna Serupa

Pindah ke kelas kami berikutnya: Kesamaan. Kelas ini akan membantu kami menghitung dan melacak indeks kesamaan antara pengguna. Seperti yang telah dibahas sebelumnya, menghitung kesamaan antara dua pengguna melibatkan analisis set item yang mereka suka dan tidak suka. Untuk melakukannya, kita akan mengandalkan instance Rater untuk mengambil set item yang relevan, dan kemudian menentukan indeks kesamaan untuk pasangan pengguna tertentu menggunakan rumus indeks kesamaan.

Sama seperti kelas sebelumnya, Rater, kita akan meletakkan semuanya di database Bourne bernama “./db-similars.json”, yang akan kita buka di konstruktor Rater. Kelas akan memiliki metode “Similars#byUser()”, yang memungkinkan kita mencari pengguna yang mirip dengan pengguna tertentu melalui pencarian database sederhana:

 @db.findOne user: user, (err, {others}) =>

Namun, metode yang paling penting dari kelas ini adalah "Similar#update()" yang bekerja dengan mengambil pengguna dan menghitung daftar pengguna lain yang serupa, dan menyimpan daftar dalam database, bersama dengan indeks kesamaan mereka. Ini dimulai dengan menemukan suka dan tidak suka pengguna:

 async.auto userLikes: (done) => @engine.likes.itemsByUser user, done userDislikes: (done) => @engine.dislikes.itemsByUser user, done , (err, {userLikes, userDislikes}) => items = _.flatten([userLikes, userDislikes])

Kami juga menemukan semua pengguna yang telah menilai item ini:

 async.map items, (item, done) => async.map [ @engine.likes @engine.dislikes ], (rater, done) => rater.usersByItem item, done , done , (err, others) =>

Selanjutnya, untuk masing-masing pengguna lain ini, kami menghitung indeks kesamaan dan menyimpan semuanya dalam database:

 async.map others, (other, done) => async.auto otherLikes: (done) => @engine.likes.itemsByUser other, done otherDislikes: (done) => @engine.dislikes.itemsByUser other, done , (err, {otherLikes, otherDislikes}) => done null, user: other similarity: (_.intersection(userLikes, otherLikes).length+_.intersection(userDislikes, otherDislikes).length-_.intersection(userLikes, otherDislikes).length-_.intersection(userDislikes, otherLikes).length) / _.union(userLikes, otherLikes, userDislikes, otherDislikes).length , (err, others) => @db.insert user: user others: others , done

Dalam cuplikan di atas, Anda akan melihat bahwa kami memiliki ekspresi yang identik dengan rumus indeks kesamaan kami, varian dari rumus indeks Jaccard.

Menghasilkan Rekomendasi

Kelas kita berikutnya, Suggestions, adalah tempat di mana semua prediksi terjadi. Seperti class Similars, kami mengandalkan database Bourne lain bernama “./db-suggestions.json”, dibuka di dalam konstruktor.

Kelas akan memiliki metode "Saran#forUser()" untuk mencari saran yang dihitung untuk pengguna yang diberikan:

 forUser: (user, done) -> @db.findOne user: user, (err, {suggestions}={suggestion: []}) -> done null, suggestions

Metode yang akan menghitung hasil ini adalah “Saran#update()”. Metode ini, seperti “Similars#update()”, akan mengambil pengguna sebagai argumen. Metode ini dimulai dengan mendaftar semua pengguna yang serupa dengan pengguna yang diberikan, dan semua item yang belum diberi peringkat oleh pengguna tertentu:

 @engine.similars.byUser user, (err, others) => async.auto likes: (done) => @engine.likes.itemsByUser user, done dislikes: (done) => @engine.dislikes.itemsByUser user, done items: (done) => async.map others, (other, done) => async.map [ @engine.likes @engine.dislikes ], (rater, done) => rater.itemsByUser other.user, done , done , done , (err, {likes, dislikes, items}) => items = _.difference _.unique(_.flatten items), likes, dislikes

Setelah semua pengguna lain dan item yang belum diberi peringkat terdaftar, kami dapat mulai menghitung kumpulan rekomendasi baru dengan menghapus kumpulan rekomendasi sebelumnya, mengulangi setiap item, dan menghitung kemungkinan pengguna menyukainya berdasarkan informasi yang tersedia:

 @db.delete user: user, (err) => async.map items, (item, done) => async.auto likers: (done) => @engine.likes.usersByItem item, done dislikers: (done) => @engine.dislikes.usersByItem item, done , (err, {likers, dislikers}) => numerator = 0 for other in _.without _.flatten([likers, dislikers]), user other = _.findWhere(others, user: other) if other? numerator += other.similarity done null, item: item weight: numerator / _.union(likers, dislikers).length , (err, suggestions) =>

Setelah selesai, kami menyimpannya kembali ke database:

 @db.insert user: user suggestions: suggestions , done

Mengekspos API Perpustakaan

Di dalam kelas Engine, kami mengikat semuanya dalam struktur seperti API yang rapi untuk akses mudah dari dunia luar:

 class Engine constructor: -> @likes = new Rater @, 'likes' @dislikes = new Rater @, 'dislikes' @similars = new Similars @ @suggestions = new Suggestions @

Setelah kita membuat instance objek Engine:

 e = new Engine

Kami dapat dengan mudah menambah atau menghapus suka dan tidak suka:

 e.likes.add user, item, (err) -> e.dislikes.add user, item, (err) ->

Kami juga dapat mulai memperbarui indeks dan saran kesamaan pengguna:

 e.similars.update user, (err) -> e.suggestions.update user, (err) ->

Terakhir, penting untuk mengekspor kelas Engine ini (dan semua kelas lainnya) dari file “.coffee” masing-masing:

 module.exports = Engine

Kemudian, ekspor Engine dari paket dengan membuat file “index.coffee” dengan satu baris:

 module.exports = require './engine'

Membuat Antarmuka Pengguna

Untuk dapat menggunakan algoritma mesin rekomendasi dalam tutorial ini, kami ingin menyediakan antarmuka pengguna yang sederhana melalui web. Untuk melakukan itu, kami menelurkan aplikasi Express di dalam file "web.iced" kami dan menangani beberapa rute:

 movies = require './data/movies.json' Engine = require './lib/engine' e = new Eengine app = express() app.set 'views', "#{__dirname}/views" app.set 'view engine', 'jade' app.route('/refresh') .post(({query}, res, next) -> async.series [ (done) => e.similars.update query.user, done (done) => e.suggestions.update query.user, done ], (err) => res.redirect "/?user=#{query.user}" ) app.route('/like') .post(({query}, res, next) -> if query.unset is 'yes' e.likes.remove query.user, query.movie, (err) => res.redirect "/?user=#{query.user}" else e.dislikes.remove query.user, query.movie, (err) => e.likes.add query.user, query.movie, (err) => if err? return next err res.redirect "/?user=#{query.user}" ) app.route('/dislike') .post(({query}, res, next) -> if query.unset is 'yes' e.dislikes.remove query.user, query.movie, (err) => res.redirect "/?user=#{query.user}" else e.likes.remove query.user, query.movie, (err) => e.dislikes.add query.user, query.movie, (err) => res.redirect "/?user=#{query.user}" ) app.route('/') .get(({query}, res, next) -> async.auto likes: (done) => e.likes.itemsByUser query.user, done dislikes: (done) => e.dislikes.itemsByUser query.user, done suggestions: (done) => e.suggestions.forUser query.user, (err, suggestions) => done null, _.map _.sortBy(suggestions, (suggestion) -> -suggestion.weight), (suggestion) => _.findWhere movies, id: suggestion.item , (err, {likes, dislikes, suggestions}) => res.render 'index', movies: movies user: query.user likes: likes dislikes: dislikes suggestions: suggestions[...4] )

Di dalam aplikasi, kami menangani empat rute. Rute indeks “/” adalah tempat kami menyajikan HTML front-end dengan merender template Jade. Membuat template memerlukan daftar film, nama pengguna pengguna saat ini, suka dan tidak suka pengguna, dan empat saran teratas untuk pengguna. Kode sumber template Jade tidak disertakan dalam artikel, tetapi tersedia di repositori GitHub.

Rute "/ suka" dan "/ tidak suka" adalah tempat kami menerima permintaan POST untuk merekam suka dan tidak suka pengguna. Kedua rute menambahkan peringkat dengan terlebih dahulu menghapus peringkat yang bertentangan, jika perlu. Misalnya, pengguna yang menyukai sesuatu yang sebelumnya tidak disukai akan menyebabkan pawang menghapus peringkat "tidak suka" terlebih dahulu. Rute ini juga memungkinkan pengguna untuk "tidak suka" atau "tidak menyukai" item, jika diinginkan.

Terakhir, rute “/refresh” memungkinkan pengguna membuat ulang kumpulan rekomendasi sesuai permintaan. Meskipun, tindakan ini secara otomatis dilakukan setiap kali pengguna membuat peringkat apa pun untuk suatu item.

Uji jalan

Jika Anda telah mencoba menerapkan aplikasi ini dari awal dengan mengikuti artikel ini, Anda perlu melakukan satu langkah terakhir sebelum dapat mengujinya. Anda perlu membuat file “.json” di “data/movies.json”, dan mengisinya dengan beberapa data film seperti:

 [ { "id": "1", "name": "Transformers: Age of Extinction", "thumb": { "url": "//upload.wikimedia.org/wikipedia/en/7/7f/Inception_ver3.jpg" } }, // … ]

Anda mungkin ingin menyalin yang tersedia di repositori GitHub, yang telah diisi sebelumnya dengan beberapa nama film dan URL thumbnail.

Setelah semua kode sumber siap dan dihubungkan bersama, memulai proses server memerlukan perintah berikut untuk dipanggil:

 $ npm start

Dengan asumsi semuanya berjalan lancar, Anda akan melihat teks berikut muncul di terminal:

 Listening on 5000

Karena kami belum menerapkan sistem otentikasi pengguna yang sebenarnya, aplikasi prototipe hanya mengandalkan nama pengguna yang dipilih setelah mengunjungi “http://localhost:5000”. Setelah nama pengguna dimasukkan, dan formulir dikirimkan, Anda akan dibawa ke halaman lain dengan dua bagian: "Film yang Direkomendasikan" dan "Semua Film". Karena kami kekurangan elemen terpenting dari mesin rekomendasi (data) berbasis memori kolaboratif, kami tidak akan dapat merekomendasikan film apa pun kepada pengguna baru ini.

Pada titik ini, Anda harus membuka jendela browser lain ke “http://localhost:5000” dan login sebagai pengguna lain di sana. Suka dan tidak suka beberapa film sebagai pengguna kedua ini. Kembali ke jendela browser pengguna pertama dan beri peringkat beberapa film juga. Pastikan Anda menilai setidaknya beberapa film umum untuk kedua pengguna. Anda harus segera mulai melihat rekomendasi.

Perbaikan

Dalam tutorial algoritma ini, yang kami buat adalah mesin rekomendasi prototipe. Pasti ada cara untuk meningkatkan mesin ini. Bagian ini akan secara singkat menyentuh beberapa area di mana perbaikan sangat penting untuk digunakan dalam skala besar. Namun, dalam kasus di mana skalabilitas, stabilitas, dan properti semacam itu diperlukan, Anda harus selalu menggunakan solusi teruji waktu yang baik. Seperti artikel lainnya, idenya di sini adalah untuk memberikan beberapa wawasan tentang cara kerja mesin rekomendasi. Alih-alih membahas kelemahan yang jelas dari metode saat ini (seperti kondisi balapan di beberapa metode yang telah kami terapkan), perbaikan akan dibahas di tingkat yang lebih tinggi.

Salah satu peningkatan yang sangat jelas di sini adalah menggunakan database nyata, alih-alih solusi berbasis file kami. Solusi berbasis file mungkin berfungsi dengan baik dalam prototipe dalam skala kecil, tetapi itu sama sekali bukan pilihan yang masuk akal untuk penggunaan nyata. Salah satu pilihan di antara banyak adalah Redis. Redis cepat, dan memiliki kemampuan khusus yang berguna ketika berhadapan dengan struktur data seperti kumpulan.

Masalah lain yang dapat kami atasi dengan mudah adalah fakta bahwa kami menghitung rekomendasi baru setiap kali pengguna membuat atau mengubah peringkat mereka untuk film. Alih-alih melakukan penghitungan ulang saat itu juga secara real time, kita harus mengantrekan permintaan pembaruan rekomendasi ini untuk pengguna dan melakukannya di belakang layar - mungkin menyetel interval penyegaran berjangka waktu.

Selain pilihan “teknis” tersebut, ada juga beberapa pilihan strategis yang dapat dilakukan untuk menyempurnakan rekomendasi. Seiring bertambahnya jumlah item dan pengguna, akan menjadi semakin mahal (dalam hal waktu dan sumber daya sistem) untuk menghasilkan rekomendasi. Hal ini dimungkinkan untuk membuat ini lebih cepat dengan memilih hanya sebagian pengguna untuk menghasilkan rekomendasi, daripada memproses seluruh database setiap saat. Misalnya, jika ini adalah mesin rekomendasi untuk restoran, Anda dapat membatasi set pengguna serupa agar hanya berisi pengguna yang tinggal di kota atau negara bagian yang sama.

Perbaikan lainnya mungkin melibatkan mengambil pendekatan hibrida, di mana rekomendasi dihasilkan berdasarkan penyaringan kolaboratif dan penyaringan berbasis konten. Ini akan sangat baik dengan konten seperti film, di mana properti konten didefinisikan dengan baik. Netflix, misalnya, mengambil rute ini, merekomendasikan film berdasarkan aktivitas pengguna lain dan atribut film.

Kesimpulan

Algoritma mesin rekomendasi kolaboratif berbasis memori bisa menjadi hal yang cukup kuat. Eksperimen yang kami lakukan dalam artikel ini mungkin primitif, tetapi juga sederhana: mudah dipahami, dan mudah dibuat. Ini mungkin jauh dari sempurna, tetapi implementasi yang kuat dari mesin rekomendasi, seperti Direkomendasikan, dibangun di atas ide-ide mendasar yang serupa.

Seperti kebanyakan masalah ilmu komputer lainnya yang melibatkan banyak data, mendapatkan rekomendasi yang benar adalah banyak tentang memilih algoritme yang tepat dan atribut konten yang sesuai untuk dikerjakan. Saya harap artikel ini memberi Anda gambaran sekilas tentang apa yang terjadi di dalam mesin rekomendasi berbasis memori kolaboratif saat Anda menggunakannya.