Μια μηχανή προτάσεων (μερικές φορές αναφέρεται ως σύστημα σύστασης) είναι ένα εργαλείο που επιτρέπει προγραμματιστές αλγορίθμων προβλέψτε τι μπορεί ή όχι να αρέσει ένας χρήστης σε μια λίστα με συγκεκριμένα στοιχεία. Οι μηχανές προτάσεων είναι μια αρκετά ενδιαφέρουσα εναλλακτική λύση στα πεδία αναζήτησης, καθώς οι μηχανές προτάσεων βοηθούν τους χρήστες να ανακαλύψουν προϊόντα ή περιεχόμενο που ενδέχεται να μην συναντούν διαφορετικά. Αυτό καθιστά τις μηχανές προτάσεων ένα μεγάλο μέρος ιστότοπων και υπηρεσιών όπως το Facebook, το YouTube, το Amazon και άλλα.
Οι μηχανές προτάσεων λειτουργούν ιδανικά με έναν από τους δύο τρόπους. Μπορεί να βασίζεται στις ιδιότητες των στοιχείων που αρέσει ένας χρήστης, τα οποία αναλύονται για να προσδιορίσουν τι άλλο μπορεί να αρέσει ο χρήστης. Ή, μπορεί να βασίζεται στις επισημάνσεις 'μου αρέσει' και 'δεν μου αρέσουν' άλλοι χρήστες, τους οποίους χρησιμοποιεί η μηχανή προτάσεων για να υπολογίσει έναν δείκτη ομοιότητας μεταξύ των χρηστών και να προτείνει αντίστοιχα στοιχεία σε αυτούς. Είναι επίσης δυνατό να συνδυάσετε και τις δύο αυτές μεθόδους για να δημιουργήσετε μια πολύ πιο ισχυρή μηχανή προτάσεων. Ωστόσο, όπως όλα τα άλλα προβλήματα που σχετίζονται με τις πληροφορίες, είναι σημαντικό να επιλέξετε αλγόριθμος που είναι κατάλληλος για το πρόβλημα αντιμετωπίζεται.
Σε αυτό το σεμινάριο, θα σας καθοδηγήσουμε στη διαδικασία δημιουργίας μιας μηχανής προτάσεων που είναι συνεργατική και βασίζεται στη μνήμη. Αυτή η μηχανή προτάσεων θα προτείνει ταινίες σε χρήστες με βάση αυτό που τους αρέσει και δεν τους αρέσει και θα λειτουργεί όπως το δεύτερο παράδειγμα που αναφέρθηκε προηγουμένως. Για αυτό το έργο, θα χρησιμοποιήσουμε βασικές λειτουργίες σετ, λίγα μαθηματικά και Node.js / CoffeeScript. Μπορείτε να βρείτε όλο τον πηγαίο κώδικα που σχετίζεται με αυτό το σεμινάριο εδώ .
άντληση ιδιωτικών κεφαλαίων για ακίνητα
Σύνολα και εξισώσεις
Πριν εφαρμόσουμε μια συνεργατική μηχανή προτάσεων βάσει μνήμης, πρέπει πρώτα να κατανοήσουμε τη βασική ιδέα πίσω από ένα τέτοιο σύστημα. Σε αυτόν τον κινητήρα, κάθε στοιχείο και κάθε χρήστης δεν είναι παρά αναγνωριστικά. Επομένως, δεν θα λάβουμε υπόψη κανένα άλλο χαρακτηριστικό μιας ταινίας (για παράδειγμα, το cast, σκηνοθέτης, είδος κ.λπ.) κατά τη δημιουργία προτάσεων. Η ομοιότητα μεταξύ δύο χρηστών αντιπροσωπεύεται χρησιμοποιώντας έναν δεκαδικό αριθμό μεταξύ -1.0 και 1.0. Θα ονομάσουμε αυτόν τον αριθμό το δείκτη ομοιότητας. Τέλος, η πιθανότητα ενός χρήστη να αρέσει μια ταινία θα εκπροσωπείται χρησιμοποιώντας έναν άλλο δεκαδικό αριθμό μεταξύ -1.0 και 1.0. Τώρα που έχουμε μοντελοποιήσει τον κόσμο γύρω από αυτό το σύστημα χρησιμοποιώντας απλούς όρους, μπορούμε να απελευθερώσουμε μια χούφτα κομψών μαθηματικών εξισώσεων για να καθορίσουμε τη σχέση μεταξύ αυτών των αναγνωριστικών και αριθμών.
Στον αλγόριθμο προτάσεών μας, θα διατηρήσουμε έναν αριθμό συνόλων. Κάθε χρήστης θα έχει δύο σύνολα: ένα σύνολο ταινιών που αρέσει ο χρήστης και ένα σύνολο ταινιών που ο χρήστης δεν αρέσει. Κάθε ταινία θα έχει επίσης δύο σετ που σχετίζονται με αυτήν: ένα σύνολο χρηστών που τους άρεσε η ταινία και ένα σύνολο χρηστών που δεν τους άρεσε η ταινία. Κατά τη διάρκεια των σταδίων όπου δημιουργούνται συστάσεις, θα δημιουργηθούν διάφορα σύνολα - κυρίως συνδικάτα ή διασταυρώσεις των άλλων συνόλων. Θα έχουμε επίσης παραγγείλει λίστες προτάσεων και παρόμοιους χρήστες για κάθε χρήστη.
Για τον υπολογισμό του δείκτη ομοιότητας, θα χρησιμοποιήσουμε μια παραλλαγή του τύπου ευρετηρίου Jaccard. Αρχικά γνωστός ως 'συντελεστής de communauté' (επινοημένος από τον Paul Jaccard), ο τύπος συγκρίνει δύο σύνολα και παράγει μια απλή δεκαδική στατιστική μεταξύ 0 και 1,0:
Ο τύπος περιλαμβάνει τη διαίρεση του αριθμού των κοινών στοιχείων σε οποιοδήποτε σύνολο από τον αριθμό όλων των στοιχείων (μετρούνται μόνο μία φορά) και στα δύο σύνολα. Ο δείκτης Jaccard δύο πανομοιότυπων συνόλων θα είναι πάντα 1, ενώ ο δείκτης Jaccard δύο συνόλων χωρίς κοινά στοιχεία θα αποδίδει πάντα 0. Τώρα που ξέρουμε πώς να συγκρίνουμε δύο σύνολα, ας σκεφτούμε μια στρατηγική που μπορούμε να χρησιμοποιήσουμε για να συγκρίνουμε δύο χρήστες. Όπως συζητήθηκε προηγουμένως, οι χρήστες, από την άποψη του συστήματος, είναι τρία πράγματα: ένα αναγνωριστικό, ένα σύνολο ταινιών που σας αρέσουν και ένα σύνολο ταινιών που δεν σας άρεσαν. Αν θέλαμε να ορίσουμε το ευρετήριο ομοιότητας των χρηστών μας με βάση μόνο το σύνολο των ταινιών που τους άρεσαν, θα μπορούσαμε να χρησιμοποιήσουμε απευθείας τον τύπο ευρετηρίου Jaccard:
Εδώ, οι U1 και U2 είναι οι δύο χρήστες που συγκρίνουμε και οι L1 και L2 είναι τα σύνολα ταινιών που τους άρεσαν οι U1 και U2, αντίστοιχα. Τώρα, αν το σκεφτείτε, δύο χρήστες που τους αρέσουν οι ίδιες ταινίες είναι παρόμοιοι, τότε δύο χρήστες που δεν τους αρέσουν οι ίδιες ταινίες θα πρέπει επίσης να είναι παρόμοιοι. Εδώ τροποποιούμε λίγο την εξίσωση:
Αντί να εξετάζουμε απλώς τις κοινές επισημάνσεις 'μου αρέσει' στον αριθμητή του τύπου, προσθέτουμε τώρα και τον αριθμό των κοινών επισημάνσεων 'δεν μου αρέσει'. Στον παρονομαστή, παίρνουμε τον αριθμό όλων των στοιχείων που είτε ο χρήστης άρεσε είτε δεν του άρεσε. Τώρα που έχουμε εξετάσει τόσο τις προτιμήσεις όσο και τις αντιπαθείς με ανεξάρτητο τρόπο, θα πρέπει επίσης να σκεφτούμε την περίπτωση όπου δύο χρήστες είναι πολικά αντίθετα στις προτιμήσεις τους. Ο δείκτης ομοιότητας δύο χρηστών όπου ένας αρέσει μια ταινία και ο άλλος δεν του αρέσει δεν πρέπει να είναι 0:
Αυτή είναι μια μακρά φόρμουλα! Αλλά είναι απλό, υπόσχομαι. Είναι παρόμοιο με τον προηγούμενο τύπο μας με μια μικρή διαφορά στον αριθμητή. Τώρα αφαιρούμε τον αριθμό των αντικρουόμενων συμπαθειών και αντιπαθειών των δύο χρηστών από τον αριθμό των κοινών συμπαθειών και αντιπαθειών τους. Αυτό προκαλεί τον τύπο του δείκτη ομοιότητας να έχει εύρος τιμών μεταξύ -1.0 και 1.0. Δύο χρήστες που έχουν πανομοιότυπα γούστα θα έχουν δείκτη ομοιότητας 1,0, ενώ δύο χρήστες που έχουν εντελώς αντίθετες γεύσεις σε ταινίες θα έχουν δείκτη ομοιότητας -1.0.
Τώρα που ξέρουμε πώς να συγκρίνουμε δύο χρήστες με βάση το γούστο τους σε ταινίες, πρέπει να διερευνήσουμε έναν ακόμη τύπο πριν ξεκινήσουμε να εφαρμόζουμε τον αλγόριθμο μηχανών εγχώριας πρότασης:
Ας σπάσουμε αυτήν την εξίσωση λίγο. Τι εννοούμε με P(U,M) είναι η δυνατότητα ενός χρήστη U μου αρέσει η ταινία M. ZL και ZD είναι το άθροισμα των δεικτών ομοιότητας του χρήστη U με όλους τους χρήστες που άρεσαν ή δεν άρεσαν στην ταινία M, αντίστοιχα. |ML|+|MD| αντιπροσωπεύει τον συνολικό αριθμό των χρηστών που άρεσαν ή δεν άρεσαν στην ταινία M. Το αποτέλεσμα P(U,M) παράγει έναν αριθμό μεταξύ -1.0 και 1.0.
Για αυτό πρόκειται. Στην επόμενη ενότητα, μπορούμε να χρησιμοποιήσουμε αυτούς τους τύπους για να αρχίσουμε να εφαρμόζουμε τη συνεργατική μηχανή προτάσεων βάσει μνήμης.
Δημιουργία της μηχανής σύστασης
Θα κατασκευάσουμε αυτήν τη μηχανή προτάσεων ως μια πολύ απλή εφαρμογή Node.js. Θα υπάρχει επίσης πολύ λίγη δουλειά στο front-end, κυρίως σε ορισμένες σελίδες HTML και φόρμες (θα χρησιμοποιήσουμε το Bootstrap για να κάνουμε τις σελίδες να φαίνονται τακτοποιημένες). Από την πλευρά του διακομιστή, θα χρησιμοποιήσουμε το CoffeeScript. Η εφαρμογή θα έχει μερικές διαδρομές GET και POST. Παρόλο που θα έχουμε την έννοια των χρηστών στην εφαρμογή, δεν θα έχουμε περίπλοκο μηχανισμό εγγραφής / σύνδεσης. Για επιμονή, θα χρησιμοποιήσουμε το πακέτο Bourne διαθέσιμο μέσω NPM το οποίο επιτρέπει σε μια εφαρμογή να αποθηκεύει δεδομένα σε απλά αρχεία JSON και να εκτελεί βασικά ερωτήματα βάσης δεδομένων σε αυτά. Θα χρησιμοποιήσουμε το Express.js για να διευκολύνουμε τη διαδικασία διαχείρισης των διαδρομών και των χειριστών.
Σε αυτό το σημείο, εάν είστε νέοι Ανάπτυξη Node.js , ίσως θέλετε να κλωνοποιήσετε το Αποθήκη GitHub ώστε να είναι πιο εύκολο να ακολουθήσετε αυτό το σεμινάριο. Όπως και με οποιοδήποτε άλλο έργο Node.js, θα ξεκινήσουμε μέχρι δημιουργία αρχείου package.json και εγκατάσταση ενός συνόλου πακέτων εξάρτησης που απαιτούνται για αυτό το έργο. Εάν χρησιμοποιείτε το κλωνοποιημένο αποθετήριο, το αρχείο package.json θα πρέπει να είναι ήδη εκεί, από όπου η εγκατάσταση των εξαρτήσεων θα σας ζητήσει να εκτελέσετε 'εγκατάσταση $ npm'. Αυτό θα εγκαταστήσει όλα τα πακέτα που αναφέρονται στο αρχείο package.json.
Τα πακέτα Node.js που χρειαζόμαστε για αυτό το έργο είναι:
Θα κατασκευάσουμε τη μηχανή προτάσεων χωρίζοντας όλες τις σχετικές μεθόδους σε τέσσερις ξεχωριστές κατηγορίες CoffeeScript, καθεμία από τις οποίες θα αποθηκευτεί στο 'lib / engine': Engine, Rater, Similars και Suggestions. Η κλάση Engine θα είναι υπεύθυνη για την παροχή ενός απλού API για τη μηχανή προτάσεων και θα συνδέσει τις άλλες τρεις κατηγορίες μαζί. Ο Rater θα είναι υπεύθυνος για την παρακολούθηση συμπαθειών και αντιπαθειών (ως δύο ξεχωριστές περιπτώσεις της κατηγορίας Rater). Τα παρόμοια και οι προτάσεις θα είναι υπεύθυνα για τον προσδιορισμό και την παρακολούθηση παρόμοιων χρηστών και προτεινόμενων στοιχείων για τους χρήστες, αντίστοιχα.
πλαίσιο διακομιστή web node js
Παρακολούθηση συμπαθειών και αντιπαθειών
Ας αρχίσουμε πρώτα με την κατηγορία Raters. Αυτό είναι απλό:
class Rater constructor: (@engine, @kind) -> add: (user, item, done) -> remove: (user, item, done) -> itemsByUser: (user, done) -> usersByItem: (item, done) -> Όπως αναφέρθηκε νωρίτερα σε αυτό το σεμινάριο, θα έχουμε μια παρουσία του Rater για επισημάνσεις 'μου αρέσει' και μια άλλη για 'δεν μου αρέσει'. Για να καταγράψουμε ότι ένας χρήστης αρέσει ένα στοιχείο, θα το μεταφέρουμε στο 'Rater # add ()'. Ομοίως, για να αφαιρέσετε την βαθμολογία, θα τις μεταφέρουμε στο 'Rater # remove ()'.
Δεδομένου ότι χρησιμοποιούμε το Bourne ως λύση βάσης δεδομένων χωρίς διακομιστή, θα αποθηκεύσουμε αυτές τις αξιολογήσεις σε ένα αρχείο με το όνομα './db-#{@kind}.json', όπου το είδος είναι είτε 'μου αρέσει' είτε 'δεν μου αρέσει'. Θα ανοίξουμε τη βάση δεδομένων μέσα στον κατασκευαστή της παρουσίας Rater:
constructor: (@engine, @kind) -> @db = new Bourne './db-#{@kind}.json' Αυτό θα κάνει την προσθήκη εγγραφών αξιολόγησης τόσο απλή όσο η κλήση μιας μεθόδου βάσης δεδομένων Bourne μέσα στη μέθοδο 'Rater # add ()':
@db.insert user: user, item: item, (err) => Και είναι παρόμοιο να τα αφαιρέσετε ('db.delete' αντί για 'db.insert'). Ωστόσο, προτού προσθέσουμε ή καταργήσουμε κάτι, πρέπει να διασφαλίσουμε ότι δεν υπάρχει ήδη στη βάση δεδομένων. Στην ιδανική περίπτωση, με μια πραγματική βάση δεδομένων, θα μπορούσαμε να το κάνουμε ως μία λειτουργία. Με το Bourne, πρέπει πρώτα να κάνουμε έναν χειροκίνητο έλεγχο. και, μόλις ολοκληρωθεί η εισαγωγή ή διαγραφή, πρέπει να βεβαιωθούμε ότι θα υπολογίσουμε εκ νέου τους δείκτες ομοιότητας για αυτόν τον χρήστη και, στη συνέχεια, δημιουργήσουμε ένα σύνολο νέων προτάσεων. Οι μέθοδοι 'Rater # add ()' και 'Rater # remove ()' θα έχουν την εξής μορφή:
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 Για συντομία, θα παραλείψουμε τα μέρη όπου ελέγχουμε για λάθη. Αυτό μπορεί να είναι λογικό να κάνετε σε ένα άρθρο, αλλά δεν αποτελεί δικαιολογία για την παράβλεψη σφαλμάτων σε πραγματικό κώδικα.
Οι άλλες δύο μέθοδοι, 'Rater # itemsByUser ()' και 'Rater # usersByItem ()' αυτής της τάξης θα περιλαμβάνουν την εκτέλεση όσων υπονοούν τα ονόματά τους - αναζητώντας στοιχεία που έχουν βαθμολογηθεί από έναν χρήστη και χρήστες που έχουν αξιολογήσει ένα στοιχείο, αντίστοιχα. Για παράδειγμα, όταν το Rater είναι instantiated με kind = “likes”, το 'Rater # itemsByUser ()' θα βρει όλα τα στοιχεία που έχει αξιολογήσει ο χρήστης.
Εύρεση παρόμοιων χρηστών
Προχωρώντας στην επόμενη τάξη: Similars. Αυτή η τάξη θα μας βοηθήσει να υπολογίσουμε και να παρακολουθούμε τους δείκτες ομοιότητας μεταξύ των χρηστών. Όπως συζητήθηκε προηγουμένως, ο υπολογισμός της ομοιότητας μεταξύ δύο χρηστών περιλαμβάνει την ανάλυση των συνόλων αντικειμένων που τους αρέσουν και δεν τους αρέσουν. Για να το κάνουμε αυτό, θα βασιστούμε στις εμφανίσεις Rater για τη λήψη των συνόλων των σχετικών στοιχείων και, στη συνέχεια, θα καθορίσουμε τον δείκτη ομοιότητας για ορισμένα ζεύγη χρηστών που χρησιμοποιούν τον τύπο δείκτη ομοιότητας.
Όπως και η προηγούμενη τάξη μας, Rater, θα βάλουμε τα πάντα σε μια βάση δεδομένων Bourne με την ονομασία './db-similars.json', την οποία θα ανοίξουμε στον κατασκευαστή του Rater. Η τάξη θα έχει μια μέθοδο 'Similars # byUser ()', η οποία θα μας επιτρέψει να αναζητήσουμε χρήστες παρόμοιοι με έναν συγκεκριμένο χρήστη μέσω μιας απλής αναζήτησης βάσης δεδομένων:
@db.findOne user: user, (err, {others}) => Ωστόσο, η πιο σημαντική μέθοδος αυτής της κλάσης είναι το 'Similars # update ()' που λειτουργεί με τη λήψη ενός χρήστη και τον υπολογισμό μιας λίστας άλλων χρηστών που είναι παρόμοιοι και την αποθήκευση της λίστας στη βάση δεδομένων, μαζί με τους δείκτες ομοιότητάς τους. Ξεκινά με την εύρεση των προτιμήσεων και των αντιπαθειών του χρήστη:
async.auto userLikes: (done) => @engine.likes.itemsByUser user, done userDislikes: (done) => @engine.dislikes.itemsByUser user, done , (err, {userLikes, userDislikes}) => items = _.flatten([userLikes, userDislikes]) Βρίσκουμε επίσης όλους τους χρήστες που έχουν αξιολογήσει αυτά τα στοιχεία:
async.map items, (item, done) => async.map [ @engine.likes @engine.dislikes ], (rater, done) => rater.usersByItem item, done , done , (err, others) => Στη συνέχεια, για καθέναν από αυτούς τους άλλους χρήστες, υπολογίζουμε το ευρετήριο ομοιότητας και τα αποθηκεύουμε όλα στη βάση δεδομένων:
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 Μέσα στο παραπάνω απόσπασμα, θα παρατηρήσετε ότι έχουμε μια έκφραση όμοιας φύσης με τον τύπο δείκτη ομοιότητας, μια παραλλαγή του τύπου ευρετηρίου Jaccard.
Δημιουργία προτάσεων
Η επόμενη τάξη μας, Προτάσεις, είναι όπου πραγματοποιούνται όλες οι προβλέψεις. Όπως και η κατηγορία Similars, βασίζουμε σε μια άλλη βάση δεδομένων Bourne με την ονομασία './db-suggestions.json', που άνοιξε μέσα στον κατασκευαστή.
Το μάθημα θα έχει μια μέθοδο 'Προτάσεις # forUser ()' για την αναζήτηση υπολογιστικών προτάσεων για τον συγκεκριμένο χρήστη:
forUser: (user, done) -> @db.findOne user: user, (err, {suggestions}={suggestion: []}) -> done null, suggestions Η μέθοδος που θα υπολογίσει αυτά τα αποτελέσματα είναι 'Προτάσεις # ενημέρωση ()'. Αυτή η μέθοδος, όπως το 'Similars # update ()', θα χρησιμοποιήσει τον χρήστη ως επιχείρημα. Η μέθοδος ξεκινά καταγράφοντας όλους τους χρήστες παρόμοιους με τον συγκεκριμένο χρήστη και όλα τα στοιχεία που ο συγκεκριμένος χρήστης δεν έχει αξιολογήσει:
@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 Μόλις αναφερθούν όλοι οι άλλοι χρήστες και τα στοιχεία που δεν έχουν βαθμολογηθεί, μπορούμε να αρχίσουμε να υπολογίζουμε ένα νέο σύνολο προτάσεων αφαιρώντας οποιοδήποτε προηγούμενο σύνολο προτάσεων, επαναλαμβάνοντας κάθε στοιχείο και υπολογίζοντας τη δυνατότητα του χρήστη να το αρέσει βάσει των διαθέσιμων πληροφοριών:
@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) => Μόλις γίνει αυτό, το αποθηκεύουμε πίσω στη βάση δεδομένων:
@db.insert user: user suggestions: suggestions , done Έκθεση του API βιβλιοθήκης
Μέσα στην κατηγορία Engine, συνδέουμε τα πάντα σε μια τακτοποιημένη δομή τύπου API για εύκολη πρόσβαση από τον εξωτερικό κόσμο:
class Engine constructor: -> @likes = new Rater @, 'likes' @dislikes = new Rater @, 'dislikes' @similars = new Similars @ @suggestions = new Suggestions @ Μόλις δημιουργήσουμε ένα αντικείμενο μηχανής:
e = new Engine Μπορούμε εύκολα να προσθέσουμε ή να αφαιρέσουμε επισημάνσεις 'μου αρέσει' και 'δεν μου αρέσει':
e.likes.add user, item, (err) -> e.dislikes.add user, item, (err) -> Μπορούμε επίσης να αρχίσουμε να ενημερώνουμε τους δείκτες ομοιότητας και τις προτάσεις χρηστών:
e.similars.update user, (err) -> e.suggestions.update user, (err) -> Τέλος, είναι σημαντικό να εξαγάγετε αυτήν την κλάση Engine (και όλες τις άλλες κατηγορίες) από τα αντίστοιχα αρχεία '.coffee':
module.exports = Engine Στη συνέχεια, εξαγάγετε το Engine από το πακέτο δημιουργώντας ένα αρχείο 'index.coffee' με μία μόνο γραμμή:
module.exports = require './engine' Δημιουργία διεπαφής χρήστη
Για να μπορέσουμε να χρησιμοποιήσουμε τον αλγόριθμο μηχανών πρότασης σε αυτό το σεμινάριο, θέλουμε να παρέχουμε μια απλή διεπαφή χρήστη μέσω του διαδικτύου. Για να το κάνουμε αυτό, δημιουργήσαμε μια εφαρμογή Express μέσα στο αρχείο μας 'web.iced' και χειριζόμαστε μερικές διαδρομές:
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] ) Μέσα στην εφαρμογή, χειριζόμαστε τέσσερις διαδρομές. Η διαδρομή ευρετηρίου '/' είναι όπου εξυπηρετούμε το HTML front-end, δίνοντας ένα πρότυπο Jade. Η δημιουργία του προτύπου απαιτεί μια λίστα με ταινίες, το όνομα χρήστη του τρέχοντος χρήστη, τις επισημάνσεις 'μου αρέσει' και 'δεν μου αρέσει' και τις τέσσερις κορυφαίες προτάσεις για τον χρήστη. Ο πηγαίος κώδικας του προτύπου Jade παραμένει εκτός του άρθρου, αλλά είναι διαθέσιμος στο Αποθήκη GitHub .
Οι διαδρομές '/ like' και '/ dislike' είναι όπου αποδεχόμαστε αιτήματα POST για την καταγραφή των προτιμήσεων και των αντιπαθειών του χρήστη. Και οι δύο διαδρομές προσθέτουν μια βαθμολογία αφαιρώντας πρώτα οποιαδήποτε διένεξη βαθμολογία, εάν είναι απαραίτητο Για παράδειγμα, ένας χρήστης που του αρέσει κάτι που δεν του άρεσε προηγουμένως θα κάνει τον χειριστή να αφαιρέσει πρώτα την βαθμολογία «δεν μου αρέσει». Αυτές οι διαδρομές επιτρέπουν επίσης στο χρήστη να 'αντιπαθεί' ή 'να μη μου αρέσει' ένα αντικείμενο, εάν το επιθυμείτε.
Τέλος, η διαδρομή '/ refresh' επιτρέπει στο χρήστη να αναδημιουργήσει το σύνολο των προτάσεών του κατά παραγγελία. Ωστόσο, αυτή η ενέργεια εκτελείται αυτόματα κάθε φορά που ο χρήστης κάνει οποιαδήποτε βαθμολογία σε ένα στοιχείο.
Δοκιμαστική οδήγηση
Εάν έχετε προσπαθήσει να εφαρμόσετε αυτήν την εφαρμογή από το μηδέν ακολουθώντας αυτό το άρθρο, θα πρέπει να εκτελέσετε ένα τελευταίο βήμα για να μπορέσετε να το δοκιμάσετε. Θα χρειαστεί να δημιουργήσετε ένα αρχείο '.json' στο 'data / movies.json' και να το συμπληρώσετε με ορισμένα δεδομένα ταινιών όπως:
[ { 'id': '1', 'name': 'Transformers: Age of Extinction', 'thumb': { 'url': '//upload.wikimedia.org/wikipedia/en/7/7f/Inception_ver3.jpg' } }, // … ] Ίσως θέλετε να αντιγράψετε αυτό που είναι διαθέσιμο στο Αποθήκη GitHub , το οποίο είναι προπληρωμένο με λίγα ονόματα ταινιών και διευθύνσεις URL μικρογραφιών.
Μόλις ο πηγαίος κώδικας είναι έτοιμος και ενσύρματος μαζί, για την έναρξη της διαδικασίας του διακομιστή απαιτείται η επίκληση της ακόλουθης εντολής:
$ npm start Υποθέτοντας ότι όλα πήγαν ομαλά, θα πρέπει να δείτε το ακόλουθο κείμενο να εμφανίζεται στο τερματικό:
Listening on 5000 Δεδομένου ότι δεν έχουμε εφαρμόσει κανένα πραγματικό σύστημα ελέγχου ταυτότητας χρήστη, η πρωτότυπη εφαρμογή βασίζεται μόνο σε ένα όνομα χρήστη που επιλέχθηκε μετά την επίσκεψη στο 'http: // localhost: 5000'. Μόλις εισαχθεί ένα όνομα χρήστη και υποβληθεί η φόρμα, θα πρέπει να μεταφερθείτε σε μια άλλη σελίδα με δύο ενότητες: 'Προτεινόμενες ταινίες' και 'Όλες οι ταινίες'. Δεδομένου ότι δεν διαθέτουμε το πιο σημαντικό στοιχείο μιας συνεργατικής μηχανής προτάσεων με βάση τη μνήμη (δεδομένα), δεν θα είμαστε σε θέση να προτείνουμε ταινίες σε αυτόν τον νέο χρήστη.
Σε αυτό το σημείο, θα πρέπει να ανοίξετε ένα άλλο παράθυρο του προγράμματος περιήγησης στο 'http: // localhost: 5000' και να συνδεθείτε ως διαφορετικός χρήστης εκεί. Μου αρέσει και δεν μου αρέσει μερικές ταινίες ως αυτός ο δεύτερος χρήστης. Επιστρέψτε στο παράθυρο του προγράμματος περιήγησης του πρώτου χρήστη και αξιολογήστε επίσης ορισμένες ταινίες. Βεβαιωθείτε ότι έχετε βαθμολογήσει τουλάχιστον μερικές κοινές ταινίες και για τους δύο χρήστες. Θα πρέπει να αρχίσετε να βλέπετε προτάσεις αμέσως.
Βελτιώσεις
Σε αυτό το σεμινάριο αλγορίθμου, αυτό που έχουμε δημιουργήσει είναι μια πρωτότυπη μηχανή προτάσεων. Υπάρχουν σίγουρα τρόποι βελτίωσης σε αυτόν τον κινητήρα. Αυτή η ενότητα θα αναφερθεί εν συντομία σε ορισμένους τομείς όπου οι βελτιώσεις είναι απαραίτητες για να χρησιμοποιηθούν σε μεγάλη κλίμακα. Ωστόσο, σε περιπτώσεις όπου απαιτείται επεκτασιμότητα, σταθερότητα και άλλες τέτοιες ιδιότητες, θα πρέπει πάντα να καταφεύγετε στη χρήση μιας καλής χρονικά δοκιμασμένης λύσης. Όπως και το υπόλοιπο άρθρο, η ιδέα εδώ είναι να δώσουμε κάποια εικόνα για το πώς λειτουργεί μια μηχανή προτάσεων. Αντί να συζητήσουμε τα προφανή ελαττώματα της τρέχουσας μεθόδου (όπως η κατάσταση του αγώνα σε ορισμένες από τις μεθόδους που έχουμε εφαρμόσει), οι βελτιώσεις θα συζητηθούν σε υψηλότερο επίπεδο.
Μια πολύ προφανής βελτίωση εδώ είναι να χρησιμοποιήσετε μια πραγματική βάση δεδομένων, αντί της λύσης που βασίζεται σε αρχεία. Η λύση που βασίζεται σε αρχεία μπορεί να λειτουργεί καλά σε ένα πρωτότυπο σε μικρή κλίμακα, αλλά δεν είναι καθόλου λογική επιλογή για πραγματική χρήση. Μια επιλογή μεταξύ πολλών είναι το Redis. Το Redis είναι γρήγορο και έχει ειδικές δυνατότητες που είναι χρήσιμα κατά την αντιμετώπιση δομών δεδομένων που μοιάζουν με σετ.
Το node.js χρησιμοποιείται για τη δημιουργία προγραμμάτων από την πλευρά του διακομιστή.
Ένα άλλο ζήτημα που μπορούμε απλώς να επιλύσουμε είναι το γεγονός ότι υπολογίζουμε νέες προτάσεις κάθε φορά που ένας χρήστης κάνει ή αλλάζει τις αξιολογήσεις του για ταινίες. Αντί να κάνουμε επανυπολογισμούς σε πραγματικό χρόνο, θα πρέπει να περιμένουμε αυτές τις αιτήσεις ενημέρωσης προτάσεων για τους χρήστες και να τις εκτελέσουμε πίσω από τη σκηνή - ίσως θέτοντας ένα χρονικό διάστημα ανανέωσης.
Εκτός από αυτές τις «τεχνικές» επιλογές, υπάρχουν επίσης ορισμένες στρατηγικές επιλογές που μπορούν να γίνουν για τη βελτίωση των συστάσεων. Καθώς ο αριθμός των στοιχείων και των χρηστών αυξάνεται, θα είναι όλο και πιο δαπανηρό (όσον αφορά τους πόρους του χρόνου και του συστήματος) για τη δημιουργία συστάσεων. Είναι δυνατό να γίνει αυτό γρηγορότερο επιλέγοντας μόνο ένα υποσύνολο χρηστών για να δημιουργήσετε προτάσεις από, αντί να επεξεργάζεστε ολόκληρη τη βάση δεδομένων κάθε φορά. Για παράδειγμα, εάν αυτή ήταν μια μηχανή προτάσεων για εστιατόρια, θα μπορούσατε να περιορίσετε το παρόμοιο σύνολο χρηστών να περιέχει μόνο αυτούς τους χρήστες που ζουν στην ίδια πόλη ή πολιτεία.
Άλλες βελτιώσεις μπορεί να περιλαμβάνουν υβριδική προσέγγιση, όπου οι προτάσεις δημιουργούνται με βάση τόσο το συνεργατικό φιλτράρισμα όσο και το φιλτράρισμα βάσει περιεχομένου. Αυτό θα ήταν ιδιαίτερα καλό με περιεχόμενο όπως ταινίες, όπου οι ιδιότητες του περιεχομένου είναι καλά καθορισμένες. Το Netflix, για παράδειγμα, ακολουθεί αυτή τη διαδρομή, προτείνοντας ταινίες με βάση τις δραστηριότητες των άλλων χρηστών και τα χαρακτηριστικά των ταινιών.
συμπέρασμα
Οι αλγόριθμοι συνεργατικών προτάσεων με βάση τη μνήμη μπορούν να είναι αρκετά ισχυροί. Αυτό με το οποίο πειραματιστήκαμε σε αυτό το άρθρο μπορεί να είναι πρωτόγονο, αλλά είναι επίσης απλό: απλό στην κατανόηση και απλό στην κατασκευή. Μπορεί να απέχει πολύ από το τέλειο, αλλά οι ισχυρές υλοποιήσεις των μηχανών πρότασης, όπως το προτεινόμενο, βασίζονται σε παρόμοιες θεμελιώδεις ιδέες.
Όπως τα περισσότερα άλλα προβλήματα επιστήμης των υπολογιστών που περιλαμβάνουν πολλά δεδομένα, η λήψη σωστών συστάσεων είναι πολύ σημαντική επιλέγοντας τον σωστό αλγόριθμο και κατάλληλα χαρακτηριστικά του περιεχομένου για επεξεργασία. Ελπίζω αυτό το άρθρο να σας δώσει μια ματιά στο τι συμβαίνει μέσα σε μια συνεργατική μηχανή προτάσεων που βασίζεται στη μνήμη όταν τη χρησιμοποιείτε.
