Mijn doelen voor dit project
- Begrijp de belangrijkste componenten van het django-framework
- Beschrijf de basisprincipes van een aanbevelingssysteem
- Bouw een eenvoudige app voor filmaanbevelingen door het Jaccard-algoritme toe te passen op basis van inhoudfiltermechanisme
Github-repository https://github.com/jamattey/Django-Movie-Recommendation
Tech-stack
- Django-backend
- HTML-frontend
- Bootstrap-CSS
- SQLite-database
Over Django Framework
Django splitst zijn applicatielogica op in de volgende drie Model-View-Controller-achtige componenten:
Django Model beheert gegevensmodellering en databasetoewijzing, evenals bedrijfslogica om gegevens te verwerken
Django View beschrijft welke gegevens worden gepresenteerd, maar niet hoe deze worden gepresenteerd. Meestal delegeert en rendert Django View een HTML-pagina, die beschrijft hoe de gegevens worden gepresenteerd
Django-sjabloon genereert dynamische HTML-pagina's om gegevens te presenteren
Wanneer een client een verzoek verzendt, stuurt de Django-server het verzoek naar de juiste weergave op basis van de Django-URL-configuratie en fungeert als een traditionele controller
Django-modellen
Django gebruikt Django-modellen om databasetabellen weer te geven en deze toe te wijzen aan objecten, zoals een proces dat ORM wordt genoemd. Django Models probeert het leven van de ontwikkelaar gemakkelijker te maken door databases te abstraheren en objecten en methoden automatisch in tabellen en SQL-query's in te delen.
U hoeft alleen klassen te definiëren als Django-modellen en deze worden later dienovereenkomstig toegewezen aan databasetabellen. Dan kunt u eenvoudig Django Models API gebruiken om CRUD uit te voeren op de databasetabellen zonder een enkele regel SQL te schrijven
Django-weergaven
In Django is een weergave in wezen een Python-functie. Zo'n functie neemt een webverzoek en past de nodige logica toe om een webantwoord te genereren, zoals de HTML-inhoud van een webpagina, een omleiding, een 404-fout, een XML-document, een afbeelding of een ander webantwoord. View werkt vaak samen met Django Models om de vereiste gegevens te krijgen in de vorm van QuerySet of objecten om een webreactie te genereren.
Django applicatie-ontwikkelingsproces
Eerst heb ik een Django-project gemaakt dat een container is voor Django-apps en -instellingen. Hier kan ik beslissen om een of meer Django-apps te maken en aan het project toe te voegen.
In Core Development heb ik Django-modellen gemaakt om de gegevens te modelleren en weergaven gemaakt om te bepalen welke gegevens aan de gebruikersinterface moeten worden gepresenteerd. Ik wijs ook de verzoek-URL's toe aan onze weergaven, zodat Django verzoeken via URL's kan doorsturen naar overeenkomstige weergaven. Daarna kunnen we beginnen met het ontwerpen en bouwen van de gebruikersinterface.
Deze films worden ingevuld in een CSV. De site host geen echte films, maar het is een aanbevelingsengine die gewone code en een database gebruikt.
Deze aanbevelingsengine maakt geen gebruik van Machine Learning.......nog 😂😂
Om de aanbeveling echt te laten werken, moest ik eerst de films markeren die een gebruiker heeft bekeken met behulp van de Django Admin-site. Daarna schreef ik een aanbevelingsalgoritme op basis van bekeken films.
Bekeken films markeren in Django Admin
- Voer Django-server uit
- bezoek admin-url app_url/admin
-
- Vervolgens klik je op het filmitem, markeer je het als bekeken en druk je op Opslaan.
Voer make_recommendations CMD uit om aanbevelingen te genereren
Voor elk aanbevelingssysteem is het belangrijkste idee altijd om met een goed algoritme/model te komen om te voorspellen of een specifieke gebruiker zijn/haar ongeziene item leuk of niet leuk zal vinden, zoals weergegeven in de volgende schermafbeelding:
Er zijn waarschijnlijk honderden goede aanbevelingsalgoritmen en deze kunnen grofweg in twee categorieën worden verdeeld:
Gebaseerd op inhoudsfiltering:
De aanbevelingsalgoritmen op basis van inhoudsfiltering gaan ervan uit dat je een nieuwe film leuk vindt als je eerder vergelijkbare films hebt gezien. Of op basis van uw gebruikersprofiel (zoals leeftijd, geslacht, interesses), zal het proberen nieuwe films te vinden die bij uw profiel passen.
Op samenwerking gebaseerde filtering:
De collaboratieve filteralgoritmen gaan ervan uit dat je een nieuwe film leuk vindt als andere gebruikers die op jou lijken (vergelijkbaar profiel of soortgelijke films hebben bekeken) deze film hebben bekeken.
In dit project gebruiken we een op inhoudsfilter gebaseerd algoritme, en we zullen proberen je niet-bekeken/nieuwe films aan te bevelen als ze vergelijkbaar zijn met je bekeken films.
Hoe berekenen we zo'n filmgelijkenis
Hier zullen we Jaccard-overeenkomst gebruiken, wat waarschijnlijk de eenvoudigste maar zeer effectieve methode is om de overeenkomst tussen twee sets te berekenen.
Jaccard-overeenkomst wordt gedefinieerd als de grootte van het snijpunt van twee sets gedeeld door de grootte van de vereniging van die twee sets.