Τεχνητή2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.3"
    },
    "pycharm": {
      "stem_cell": {
        "cell_type": "raw",
        "source": [],
        "metadata": {
          "collapsed": false
        }
      }
    },
    "colab": {
      "name": "Τεχνητή2.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "816WHA5P3nJT"
      },
      "source": [
        "# Τεχνητή Νοημοσύνη: Εργαστηριακή Άσκηση 2\n",
        "---\n",
        "\n",
        "Ο στόχος της εργασίας είναι η κατασκευή ενός συστήματος προτάσεων (Recommendation System) για ταινίες. Οι προτάσεις αυτές θα πηγάζουν τόσο από τα χαρακτηριστικά της ταινίας όσο και από ορισμένες αξιολογήσεις του κάθε χρήστη.\n",
        "\n",
        "Στα δεδομένα της άσκησης περιλαμβάνονται ένα αρχείο με το όνομα movies_metadata.csv το όποιο περιέχει τα χαρακτηριστικά κάθε ταινίας όπως θέμα, σκηνοθέτης, ηθοποιοί, λέξεις κλειδιά κ.α. από το imdb, τα αρχεία user1.csv και user2.csv τα όποια περιέχουν αξιολογήσεις για 2 διαφορετικούς χρήστες καθώς και το αρχείο relative_movies.csv, που περιέχει 10 όμοιες ταινίες για ορισμένους τυχαία επιλεγμένους τίτλους.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aa-wJhCX9Nwk"
      },
      "source": [
        "# Εκφώνηση\n",
        "Στην παρούσα εργασία σας ζητείται να μελετήσετε και υλοποιήσετε τα παρακάτω:<br>\n",
        "\n",
        "### Μέρος 1\n",
        "Στο μέρος 1 και 2 θα ασχοληθείτε και θα εργαστείτε μόνο με το αρχείο movies_metadata.csv.\n",
        "#### Ερώτημα 1α\n",
        "\n",
        "Αρχικά θα πρέπει αφού μελετήσετε την δομή και τα χαρακτηριστικά του αρχείου αυτού να κατασκευάσετε μια βάση γνώσης για την Prolog η όποια ουσιαστικά θα αποτελεί τον κόσμο με τον όποιο θα εργαστείτε στην συνέχεια. Τα κατηγορήματα που θα δημιουργηθούν θα σας βοηθήσουν και στην κατασκευή του recommender και θα είναι της μορφής:\n",
        "\n",
        "```\n",
        "director(Movie, Director).\n",
        "genre(Movie, Genre).\n",
        "```\n",
        "#### Ερώτημα 1β\n",
        "\n",
        "Αφού δημιουργήσετε τον κόσμο του προβλήματος στην συνέχεια καλείστε να δημιουργήσετε, σε Prolog, απλούς κανόνες οι οποίοι θα βρίσκουν όλες τις ταινίες με:\n",
        "1.\tΑρκετά κοινό θέμα (κάποιες λέξεις σχετικά με το genre κοινές)\n",
        "2.\tΣχετικά κοινό θέμα (κάποιες λιγότερες λέξεις σχετικά με το genre κοινές π.χ. 3)\n",
        "3.\tΛιγότερο κοινό θέμα (λίγες λέξεις σχετικές με το genre κοινές π.χ. 1)\n",
        "4.\tΚοινός σκηνοθέτης\n",
        "5.\tΑκριβώς ίδια πλοκή (κάποιες λέξεις κλειδιά της πλοκής να είναι κοινές)\n",
        "6.\tΣχετικά ίδια πλοκή (κάποιες λιγότερες λέξεις κλειδιά κοινές)\n",
        "7.\tΊδιους τους βασικούς ηθοποιούς (και τους 3)\n",
        "8.\tΑρκετά ίδιους βασικούς ηθοποιούς (ορισμένους βασικούς ηθοποιούς κοινούς π.χ. 2)\n",
        "9.\tΣχετικά ίδιους ηθοποιούς (π.χ. 1 από τους 3)\n",
        "10.\tΊδια γλώσσα\n",
        "11.\tΕίναι έγχρωμες ή ασπρόμαυρες\n",
        "\n",
        "Αξίζει να σημειωθεί ότι στα παραπάνω μπορείτε να προσθέσετε περισσότερα ερωτήματα ή να αλλάξετε την κλιμακωσιμότητα των queries (πέρα από το ίδιο, αρκετά ίδιο, σχετικά ίδιο) που θα κατασκευάσετε(π.χ. μια κλίμακα από 1 στα 5 όπου αυτό είναι δυνατόν), μιας και αυτά στην συνέχεια θα χρησιμοποιηθούν για την λειτουργία του recommender. Έτσι μπορείτε να προσθέσετε queries με τα όποια μπορεί να παράγονται καλύτερες συστάσεις  (το αρχείο movie_metadata.csv περιέχει πολλές πληροφορίες ακόμα για κάθε ταινία όπως έτος κυκλοφορίας, βαθμολογία στο imdb, facebοok_likes κ.α.).\n",
        "\n",
        "Περισσότερες πληροφορίες για το dataset μπορείτε να διαβάσετε σε αυτό το Link: https://www.kaggle.com/adnanr94/imdb-movies-metadata.\n",
        "\n",
        "### Μέρος 2: Recommendation System\n",
        "Στο σημείο αυτό καλείστε με βάση αυτά που κάνατε στο μέρος 1 να κατασκευάσετε queries τα όποια θα σας επιστρέφουν παρόμοιες (σε χαρακτηριστικά) ταινίες. Τα ερωτήματα αυτά θα είναι κλιμακούμενα, δηλαδή θα υπάρχουν ερωτήματα που επιστρέφουν αρκετά κοινές ταινίες, και άλλα που επιστρέφουν λιγότερο κοινές (σε μια κλίμακα π.χ. από 1 σε 5). Για παράδειγμα:\n",
        "\n",
        "```\n",
        "simple_recommender_5(\"Pirates Of The Caribbean\", M).\n",
        "M = \"Pirates Of The Caribbean: On Stranger Tides\"\n",
        "M = \"The Chronicles Of Narnia\"\n",
        "M = \"Prince Of Persia: The Sands Of Time\"\n",
        "...\n",
        "\n",
        "simple_recommender_5(\"Avatar\").\n",
        "M = 'Terminator 2: Judgment Day'\n",
        "M = 'Aliens'\n",
        "M = 'The Terminator'\n",
        "\n",
        "simple_recommender_5(\"Star Wars: Episode III - Revenge of the Sith\").\n",
        "M = Star Wars: Episode IV - A New Hope'\n",
        "M = 'Star Wars: Episode I - The Phantom Menace'\n",
        "M = 'Star Wars: Episode II - Attack of the Clones'\n",
        "\n",
        "```\n",
        "Για παράδειγμα το παραπάνω ερώτημα θα επιστρέφει αρκετά κοινές σε περιεχόμενο ταινίες με την ταινια \"Pirates Of The Caribbean\". Αντίστοιχα θα υπάρχουν και ερωτήματα που θα βρίσκουν λιγότερα όμοιες ταινίες. Ο δείκτης ομοιότητας των ταινιών είναι αυθαίρετος και μπορείτε να τον ορίσετε εσείς όπως θέλετε, αρκεί απλά να υπάρχει κάποια λογική σύνδεση με τα δεδομένα που περιέχονται στο αρχείο movies_metadata.csv. \n",
        "\n",
        "Συνεπώς η συνάρτηση που θα κάνει τις προτάσεις (recommendation) με είσοδο μια ταινία πρέπει να επιστρέφει-εκτυπώνει μια λίστα με τις προτεινόμενες ταινίες σε φθίνουσα σειρά ομοιότητας. \n",
        "\n",
        "Για να μπορείτε να αξιολογήσετε τα αποτελέσματα των συστάσεων σας σας δίνεται ένα αρχείο με ορισμένες ταινίας και τα 10 πρώτα αποτελέσματά τους σε φθίνουσα σειρά ομοιότητας. Για την σύγκρισή των αποτελεσμάτων σας με τα  αποτελέσματα του αρχείου relative_movies.csv  μπορείτε να χρησιμοποιήσετε της συνάρτηση ομοιότητας συνόλων Jaccard (https://www.statisticshowto.datasciencecentral.com/jaccard-index/).\n",
        "\n",
        "$$jaccard(A,B)=\\frac{|A\\cap B|}{|A\\cup B|}$$\n",
        "\n",
        "Η υλοποίηση της συνάρτησης αυτής σε Python σας δίνεται με το όνομα jaccard_similarity (set1, set2). \n",
        "\n",
        "Αξίζει να σημειωθεί ότι η παραπάνω σύγκριση δεν είναι απόλυτη για τον λόγο ότι οι συναρτήσεις ομοιότητας μπορεί να είναι διαφορετικές (διαφορετικά ορίζει ο καθένας της ομοιότητα μεταξύ ταινιών) καθώς επίσης αν μια ταινία δεν έχει πολύ σχετικές προτάσεις τότε οι πιο γενικές συναρτήσεις ομοιότητας θα έχουν πολλά αποτελέσματα τα όποια η Prolog θα επιστρέψει με την σειρά που τα βρίσκει στην βάση, όποτε τότε δεν έχει ιδιαίτερο νόημα η σύγκριση σε αυτήν την περίπτωση.\n",
        "Η ομοιότητα των ταινιών είναι βοηθητική και σκοπό έχει να σας βοηθήσει να κατανοήσετε την κατεύθυνση της ασκήσης και όχι για να καταφέρετε την πλήρη ταύτιση των συστάσεων.\n",
        "\n",
        "### 3ο Μέρος: Recommendation System με βάση τις προτιμήσεις-αξιολογήσεις του χρήστη\n",
        "\n",
        "\n",
        "Σε αυτό το σημείο θα εργαστείτε με τα αρχεία user1.csv και user2.csv, τα όποια περιέχουν αξιολογήσεις (από 1 μέχρι 5) για ταινίες από 2 διαφορετικούς χρήστες. Το προηγούμενο σύστημα συστάσεων προτείνει στον χρήστη ταινίες αποκλειστικά με βάση την ομοιότητά τους. Έτσι σε αυτό το σημείο θα γίνει μια αναβάθμιση του συστήματος έτσι ώστε να παράγονται καλύτερες  συστάσεις οι όποιες θα λαμβάνουν υπόψιν και τις προτιμήσεις του χρήστη, οι όποιες θα εξάγονται από τις αξιολογήσεις που έχει κάνει μέχρι στιγμής. \n",
        "\n",
        "Έτσι πλέον για κάθε ταινία θα υπάρχει ένα score το όποιο αρχικά θε είναι ίσο με 0 και θα διαμορφώνεται από τις αξιολογήσεις κάθε user. Έτσι για έναν χρήστη με βάση τις αξιολογήσεις που έχει κάνει θα πρέπει για κάθε ταινία που έχει βαθμολογήσει θα βρίσκονται οι κοινές ταινίες ανά κλίμακα και στο μέχρι τώρα σκορ κάθε παρόμοιας ταινίας θα προστίθεται ένα βάρος το όποιο θα μπορούσε να είναι το ποσοστό ομοιότητας της ταινίας (δηλαδή ένα βάρος για κάθε κλίμακα) επί τον βαθμό που έχει βάλει ο χρήστης για την αρχική ταινία (ή ένα βάρος ανά βαθμό ώστε οι καλές κριτικές να γίνονται καλύτερες ενώ οι κακές χειρότερες). Δηλαδή, αν $rated\\_movies$ είναι το σύνολο ταινιών που έχει αξιολογήσει ο χρήστης, τότε τα recommendations που θα λαμβάνει ο χρήστης θα είναι οι ταινίες που είναι τουλάχιστον similar_1 με τουλάχιστον μία ταινία που έχει βαθμολογήσει ο χρήστης, σε φθίνουσα σειρά recommendation_score, όπου:\n",
        "\n",
        "$$recommendation\\_score(m_1)=\\sum_{m_2\\in rated\\_movies} similarity\\_weight(m_1,m_2)\\cdot voting\\_weight(m_2)$$\n",
        "\n",
        "\n",
        "Έτσι για παράδειγμα αν ένας χρήστης έχει αξιολογήσει αρκετές  ταινίες οι όποιες είναι sci-fiction με 5/5 τότε όταν ζητήσει τις προτεινόμενες είναι λογικό να λάβει πρώτα κάποιες που είναι αυτού του είδους μιας και αυτές μπορεί του αρέσουν περισσότερο.\n",
        "\n",
        "Επίσης για να εξετάσετε την αποδοτικότητα του συστήματος αυτού μπορείτε να κατασκευάσετε τους δικούς σας χρήστες. Για να το κάνετε αυτό πρέπει να γράψετε ορισμένους κανόνες της μορφής: liked(X), notliked(X) οι οποίοι θα σας επιστρέφουν ταινίες που πιθανώς θα σας αρέσουν, π.χ. σας αρέσουν ταινίες επιστημονικής φαντασίας που τις έχει σκηνοθετήσει ένας συγκεκριμένος σκηνοθέτης και αυτές που δεν είναι του γούστου σας. Για την κατασκευή του αρχείου και των αξιολογήσεων σας δίνεται μια συνάρτηση η όποια δέχεται σας ορίσματα όλες τις ταινίες από κάθε κατηγορία και τυχαία επιλέγετε ένας ορισμένος αριθμός ταινιών από αυτές στις όποιες δίνεται ένας βαθμός (για αυτές που αρέσουν στον χρήστη από 3 μέχρι 5 με διαφορετικές πιθανότητες ενώ σε αυτές που δεν του αρέσουν από 1 μέχρι 3). Μπορείτε να πειραματιστείτε με αυτήν την συνάρτηση για να ελέγξετε τα αποτελέσματά σας.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mgT4rsTd4tcf"
      },
      "source": [
        "---\n",
        "## Κατασκευή Περιβάλλοντος Εργασίας\n",
        "---\n",
        "### Διάβασμα Αρχείων στο Colab (Μόνο για το Colab)\n",
        "Αν η υλοποίηση γίνει στο google colab τότε μπορεί να χρησιμοποιηθεί το google drive ως file system. Για να γίνει Mount το google drive τρέχουμε τον παρακάτω κώδικα και κλικάρουμε στο link που θα μας εμφανιστεί. \n",
        "\n",
        "```\n",
        "from google.colab import drive\n",
        "drive.mount('/gdrive')\n",
        "import os\n",
        "os.listdir('/gdrive/My Drive')\n",
        "```\n",
        "Επέιτα στην σελίδα που άνοιξε επιλέγουμε το mail μας και στο επόμενο παράθυρο που θα μας ανοίξει πατάμε Να επιτρέπεται. Στην συνέχεια αντιγράφουμε τον κωδικό που θα μας βγάλει και τον κάνουμε paste στο Input που έχει ανοίξει στο colab. Έτσι πλέον αν έχουμε ανεβάσει ένα αρχείο στο google drive μπορούμε να το βρούμε στην θέση:\n",
        "\n",
        "```\n",
        "movies_filename = '/gdrive/My Drive/' + movies_metadata.csv\n",
        "```\n",
        "Μπορούμε πλέον κανονικά να δουλέψουμε φτιάχνοντας φακέλους ή αρχεία και γενικότερα κάνοντας οτιδήποτε θα κάναμε αν ήμασταν τοπικά. \n",
        "\n",
        "### Prolog μέσω Python\n",
        "\n",
        "Το πακέτο που θα χρησιμοποιηθεί για την επικοινωνία Python και Prolog είναι το pyswip (https://pypi.org/project/pyswip/). Για να δουλέψει το Pyswip  χρειάζεται να υπάρχει το Swi-Prolog το όποιο αν δουλεύουμε τοπικά πρέπει να το εγκαταστήσουμε, ακολουθώντας αντίστοιχές οδηγίες στην σελίδα του εργαλείου. Για να γίνει του Swi-Prolog η εγκατάσταση στο Google Colab πρέπει να τρέξουμε τον παρακάτω κώδικα:\n",
        "\n",
        "```\n",
        "!sudo apt-get install software-properties-common\n",
        "!sudo apt-add-repository ppa:swi-prolog/stable\n",
        "!sudo apt-get update\n",
        "!sudo apt-get install swi-prolog\n",
        "```\n",
        "Σε κάποιο σημείο της εκτέλεσης εμφανίζεται ένα μήνυμα ότι πρέπει να πατήσουμε enter σε ένα input για να συνεχίσει η διαδικασία. Έπειτα από αυτό η εκτέλεση θα συνεχίσει χωρίς κάποιο πρόβλημα.\n",
        "\n",
        "Τέλος πρέπει να εγκαταστήσουμε το pyswip (**όπου και να δουλεύουμε**) όπως παρακάτω:\n",
        "\n",
        "```\n",
        "!pip isntall pyswip\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "21xzXVjQ5tFB"
      },
      "source": [
        "---\n",
        "#Κώδικας για κατασκευή περιβάλλοντος εργασίας\n",
        "##Μόνο για Google Colab\n",
        "\n",
        "Κώδικας για να γίνει Mount to Google Drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DfT5Z_wtrhsV"
      },
      "source": [
        "#from google.colab import drive\n",
        "#drive.mount('/gdrive')\n",
        "#import os\n",
        "#os.listdir('/gdrive/My Drive')\n",
        "#path='/gdrive/My Drive/'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rk-8r3HU6Jyo"
      },
      "source": [
        "Κώδικάς για να εγκατασταθεί το Swi-Prolog και το pyswip.<br>\n",
        "\n",
        "***Αυτά χρειάζονται σε κάθε περιβάλλον λειτουργίας, αν δεν έιναι ήδη  εγκατεστημένα.***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mHVpa_D65-E2"
      },
      "source": [
        "#install swi-prolog\n",
        "!sudo apt-get install software-properties-common\n",
        "!sudo apt-add-repository ppa:swi-prolog/stable\n",
        "!sudo apt-get update\n",
        "!sudo apt-get install swi-prolog"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oTMvKM280QJ_"
      },
      "source": [
        "#install pyswip\n",
        "!pip install pyswip"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YwVgPW316S3l"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rhbCLdSqKUy2"
      },
      "source": [
        "# **Μέρος 1: Μελέτη των Metadata, Δημιουργία κόσμου και των βασικών queries.**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z_f0xW6_tHhp"
      },
      "source": [
        "# Η βιβλιοθήκη pandas είναι χρήσιμη για την εργασία με τέτοια δεδομένα\n",
        "import pandas as pd \n",
        "# Διάβασμα του αρχείου 'movie_metadata.csv' \n",
        "data = pd.read_csv(\"movie_metadata.csv\") \n",
        "#Στο csv υπαρχούν κελία με nan τιμές\n",
        "#Στις θέσεις αυτές βάζουμε 'UNK' πράγμα που  κάνουμε με την παρακάτω συνάρτηση\n",
        "data.fillna(\"UNK\", inplace=True)\n",
        "# Preview the first 5 lines of the loaded data \n",
        "#data.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dG4-a9_FzRRd"
      },
      "source": [
        "from pyswip import Prolog"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ceBtnUMn7Mwm"
      },
      "source": [
        "def clean_text(text):\n",
        "    text = text.replace(u'\\xa0', u'')\n",
        "    text = text.replace(u\"'\", u'')\n",
        "    text = text.replace(u'\"', u'')\n",
        "    return ' '.join(text.split())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8-fmdlMxxBzx"
      },
      "source": [
        "#create World\n",
        "#Ορίζουμε τον κόσμο μας\n",
        "prolog = Prolog()\n",
        "#και σβήνουμε ότι υπήρχε αποθηκευμένο από πρίν\n",
        "prolog.query('make')\n",
        "\n",
        "#Για κάθε row του πίνακα φτιάχνουμε τα κατηγοτήματα που θέλουμε να αποθηκέυσουμε\n",
        "#αρχικά σε μια λίστα με το όνομα literals\n",
        "literals = []\n",
        "movie_score = {}\n",
        "for row in data.itertuples(index=True, name='Pandas'):\n",
        "    movie_title = clean_text(getattr(row, 'movie_title'))\n",
        "    director = clean_text(getattr(row, 'director_name'))\n",
        "    \n",
        "    movie_score[movie_title] = 0\n",
        "    if movie_title != \"UNK\":\n",
        "        if director != \"UNK\":\n",
        "            literals.append(\"director('\"+ movie_title +\"','\" + director + \"')\")\n",
        "        for genre in getattr(row, 'genres').split(\"|\"):\n",
        "            literals.append(\"genre('\"+ movie_title +\"','\"+ genre +\"')\")\n",
        "        for plot in getattr(row, 'plot_keywords').split(\"|\"):\n",
        "            literals.append(\"keyword('\"+ movie_title +\"','\"+ plot.replace(\"'\",'\"') +\"')\")\n",
        "        for actor in [getattr(row, 'actor_1_name'), getattr(row, 'actor_2_name'), getattr(row, 'actor_3_name')]:\n",
        "            literals.append(\"actors('\"+ movie_title +\"','\"+ actor.replace(\"'\",'\"') +\"')\")\n",
        "        for language in getattr(row, 'language'):\n",
        "            literals.append(\"language('\"+ movie_title +\"','\"+ language +\"')\")\n",
        "        for color in getattr(row, 'color'):\n",
        "            literals.append(\"color('\"+ movie_title +\"','\"+ color +\"')\")\n",
        "#Η Prolog θέλει τα κατηγορήματά της με την σειρά \n",
        "literals.sort()\n",
        "for literal in literals:\n",
        "    prolog.assertz(literal)\n",
        "\n",
        "#Επίσης μπορούμε να κάνουμε consult ένα έτοιμό αρχείο στον κόσμο όπως γίνεται παρακάτω\n",
        "\n",
        "#prolog.consult(\"filename.pl\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WiN7xKC9cWhM"
      },
      "source": [
        "#prolog.assertz(\"(unique_genre([],_))\")\n",
        "#prolog.assertz('(unique_genre([X|Xs],M) :- print(M),genre(M,X), \\+ member(X, Xs), unique_genre(Xs,M))')\n",
        "\n",
        "\n",
        "#prolog.assertz('(similar_genre_movies_5(X, Y) :-  length(L,Length), Length >= 3,unique_genre(L,X),unique_genre(L,Y), X \\= Y)')\n",
        "\n",
        "prolog.assertz('(similar_genre_movies_5(X, Y) :-  genre(X,A), genre(X,B), genre(X,C), genre(Y,A), genre(Y,B), genre(Y,C), X\\=Y, A \\= B, A \\= C, B \\= C )')\n",
        "prolog.assertz('(similar_genre_movies_3(X, Y) :-  genre(X,A), genre(X,B), genre(Y,A), genre(Y,B), X\\=Y, A \\= B, not(similar_genre_movies_5(X, Y)) )')\n",
        "prolog.assertz('(similar_genre_movies_1(X, Y) :-  genre(X,A), genre(Y,A), X\\=Y, not(similar_genre_movies_3(X, Y)) )')\n",
        "\n",
        "prolog.assertz('(same_director(X, Y) :-  director(X,A), director(Y,A), X\\=Y )')\n",
        "\n",
        "prolog.assertz('(similar_keyword_movies_1(X, Y) :-  keyword(X,A), keyword(Y,A), X\\=Y )')\n",
        "prolog.assertz('(similar_keyword_movies_2(X, Y) :-  keyword(X,A), keyword(X,B), keyword(Y,A), keyword(Y,B), X\\=Y , A \\= B, not(similar_keyword_movies_1(X, Y)))')\n",
        "\n",
        "prolog.assertz('(similar_actors_movies_3(X, Y) :-  actors(X,A), actors(X,B), actors(X,C), actors(Y,A), actors(Y,B), actors(Y,C), X\\=Y, A \\= B, A \\= C, B \\= C)')\n",
        "prolog.assertz('(similar_actors_movies_2(X, Y) :-  actors(X,A), actors(X,B), actors(Y,A), actors(Y,B), X\\=Y, A \\= B, not(similar_actors_movies_3(X, Y)) )')\n",
        "prolog.assertz('(similar_actors_movies_1(X, Y) :-  actors(X,A), actors(Y,A), X\\=Y, not(similar_actors_movies_2(X, Y)) )')\n",
        "\n",
        "prolog.assertz('(same_language_movies(X, Y) :-  language(X,A), language(Y,A), X\\=Y)')\n",
        "\n",
        "prolog.assertz('(same_color_movies(X, Y) :-  color(X,A), color(Y,A), X\\=Y)')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JH10XNiveacy"
      },
      "source": [
        "def test1(movie):\n",
        "    q = prolog.query(\"similar_genre_movies_5('\" + movie +\"',M)\")\n",
        "    ans5 = []\n",
        "    for soln in q:\n",
        "        ans5.append(soln[\"M\"])\n",
        "    ans = set(ans5)\n",
        "    return print(list(set(ans5))[:5])\n",
        "\n",
        "def test2(movie):\n",
        "    q = prolog.query(\"similar_genre_movies_3('\" + movie +\"',M)\")\n",
        "    ans5 = []\n",
        "    for soln in q:\n",
        "        ans5.append(soln[\"M\"])\n",
        "    ans = set(ans5)\n",
        "    return print(list(set(ans5))[:5])\n",
        "\n",
        "def test3(movie):\n",
        "    q = prolog.query(\"similar_genre_movies_1('\" + movie +\"',M)\")\n",
        "    ans5 = []\n",
        "    for soln in q:\n",
        "        ans5.append(soln[\"M\"])\n",
        "    ans = set(ans5)\n",
        "    return print(list(set(ans5))[:5])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1iO_Jln3fARx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "d9809818-6289-403b-92c9-28268192df36"
      },
      "source": [
        "test1(\"Star Wars: Episode V - The Empire Strikes Back\")\n",
        "test2(\"Star Wars: Episode V - The Empire Strikes Back\")\n",
        "test3(\"Star Wars: Episode V - The Empire Strikes Back\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['I Am Number Four', 'Lara Croft Tomb Raider: The Cradle of Life', 'Monsters vs. Aliens', 'The Saint', 'The Wolverine']\n",
            "['Land of the Lost', 'Rollerball', 'Ramona and Beezus', 'The Wiz', 'Lucy']\n",
            "['Primer', 'Nowhere to Run', 'Aqua Teen Hunger Force Colon Movie Film for Theaters', 'The Lazarus Effect', 'The Animal']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "essI0S1m22b9"
      },
      "source": [
        "Οι συναρτήσεις test έχουν σκοπό να ελέγξουν την λειτουργία των κατηγορημάτων!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gpMVPz-3K07i"
      },
      "source": [
        "# **2ο Μέρος: Recommendation System με βάση μόνο τα χαρακτηριστικά των ταινιών.**\n",
        "\n",
        "Στο σημείο αυτό με βάση τους κανόνες που κατασκευάστηκαν στο Μέρος 1 θα κατασκευαστούν κατηγορήματα για την ομοιότητα ταινιών. Παρακάτω δίνεται ένα μικρό παράδειγμα ενός κανόνα και πώς αυτός θα μπορούσε να γραφτεί μέσω του Pyswip. Επίσης όπως αναφέρεται και σε σχόλιο παραπάνω θα μπορεί να γραφτεί και μια βάση δεδομένων με τους κανόνες και να γίνει απευθείας consult.\n",
        "\n",
        "Στο παρακάτω παράδειγμα το 5 και το 4 εκφράζουν την ομοιότητα των ταινιών π.χ. οι ταινίες που παράγονται μέσω του find_similar_5 είναι πιο όμοιες από αυτές που παράγονται μέσω του find_similar_4. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h1nmSLlmA75q"
      },
      "source": [
        "prolog.assertz('(find_similar_movies_5(X, Y) :- similar_genre_movies_5(X, Y), X \\= Y; same_director(X, Y), similar_genre_movies_3(X, Y), X \\= Y )')\n",
        "prolog.assertz('(find_similar_movies_4(X, Y) :- similar_actors_movies_1(X, Y), similar_genre_movies_3(X, Y), X \\= Y)')\n",
        "prolog.assertz('(find_similar_movies_3(X, Y) :- similar_genre_movies_3(X, Y), X \\= Y)')\n",
        "prolog.assertz('(find_similar_movies_2(X, Y) :- similar_actors_movies_1(X, Y); similar_keyword_movies_1(X, Y), X \\= Y)')\n",
        "prolog.assertz('(find_similar_movies_1(X, Y) :- similar_genre_movies_1(X, Y), X \\= Y)')\n",
        "\n",
        "# prolog.consult('db.pl')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DeAvc55byC0l"
      },
      "source": [
        "def simple_recommender(movie,similarity_ratio):\n",
        "    if similarity_ratio == 4:\n",
        "        q = prolog.query(\"find_similar_movies_4('\" + movie +\"',M)\")\n",
        "        ans = []\n",
        "        for soln in q:\n",
        "            if soln[\"M\"] not in ans :\n",
        "                ans.append(soln[\"M\"])\n",
        "    #   print(ans)\n",
        "    elif similarity_ratio == 3:\n",
        "        q = prolog.query(\"find_similar_movies_3('\" + movie +\"',M)\")\n",
        "        ans = []\n",
        "        for soln in q:\n",
        "            if soln[\"M\"] not in ans :\n",
        "                ans.append(soln[\"M\"])\n",
        "    #   print(ans)\n",
        "    elif similarity_ratio == 2:\n",
        "        q = prolog.query(\"find_similar_movies_2('\" + movie +\"',M)\")\n",
        "        ans = []\n",
        "        for soln in q:\n",
        "            if soln[\"M\"] not in ans :\n",
        "                ans.append(soln[\"M\"])\n",
        "    #   print(ans)\n",
        "    elif similarity_ratio == 1:\n",
        "        q = prolog.query(\"find_similar_movies_1('\" + movie +\"',M)\")\n",
        "        ans = []\n",
        "        for soln in q:\n",
        "            if soln[\"M\"] not in ans :\n",
        "                ans.append(soln[\"M\"])\n",
        "    else:\n",
        "      q = prolog.query(\"find_similar_movies_5('\" + movie +\"',M)\")\n",
        "      ans = []\n",
        "      for soln in q:\n",
        "          if soln[\"M\"] not in ans:\n",
        "            ans.append(soln[\"M\"])\n",
        "      ans = set(ans)\n",
        " #   print(ans5)\n",
        "    #κάνουμε κάποιο Processing στα παραπάνω αποτελέσματα και επιστρέφουμε τις \"όμοιες\" ταινίες με φθίνουσα σειρά\n",
        "    if  len(list(set(ans))) > 0:\n",
        "        print(list(set(ans))[:5])\n",
        "    else :\n",
        "        print(\"Try a different recommendation setting\")\n",
        "    return \n",
        " #   return list(set(ans))\n",
        "\n",
        "def simple_recommender_j(movie):\n",
        "  q = prolog.query(\"find_similar_movies_5('\" + movie +\"',M)\")\n",
        "  ans = []\n",
        "  for soln in q:\n",
        "    if soln[\"M\"] not in ans:\n",
        "      ans.append(soln[\"M\"])\n",
        "  return list(set(ans))\n",
        "\n",
        "def recommend_me(movie):\n",
        "    for i in range(5,0,-1):\n",
        "        simple_recommender(movie,i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wCryo9VGAeWi"
      },
      "source": [
        "**Στο σημείο αυτό θα ζητήσουμε από το σύστημα να μας επιστρέψει ορισμένα αποτελέσματα για ταινίες για να εξετάσουμε την απόδοσή του.**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eIUqc6IW0QK3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "0a978c42-c87a-4bd0-caae-bed8713f3a2d"
      },
      "source": [
        "recommend_me(\"Avatar\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['I Am Number Four', 'Lara Croft Tomb Raider: The Cradle of Life', 'The Saint', 'Jimmy Neutron: Boy Genius', 'Last Action Hero']\n",
            "['Tales from the Crypt: Demon Knight', 'The Last of the Mohicans', 'Face/Off', 'RoboCop 3', 'End of Days']\n",
            "['Land of the Lost', 'Rollerball', 'Ramona and Beezus', 'The Wiz', 'Lucy']\n",
            "['High Crimes', 'Jack Ryan: Shadow Recruit', 'Hatchet', 'Automata', 'Minority Report']\n",
            "['Primer', 'Nowhere to Run', 'Aqua Teen Hunger Force Colon Movie Film for Theaters', 'The Lazarus Effect', 'The Animal']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1ufv5t07VpLP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "7448796c-0284-4bc5-f28a-03dbff9e5010"
      },
      "source": [
        "recommend_me('Star Wars: Episode V - The Empire Strikes Back')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['I Am Number Four', 'Lara Croft Tomb Raider: The Cradle of Life', 'The Saint', 'Jimmy Neutron: Boy Genius', 'Last Action Hero']\n",
            "['Enders Game', 'Raiders of the Lost Ark', 'The Expendables 3', 'Six Days Seven Nights', 'Indiana Jones and the Temple of Doom']\n",
            "['Land of the Lost', 'Rollerball', 'Ramona and Beezus', 'The Wiz', 'Lucy']\n",
            "['Return to Never Land', 'Patriot Games', 'Gunless', 'Beneath the Planet of the Apes', 'Indiana Jones and the Last Crusade']\n",
            "['Primer', 'Nowhere to Run', 'Aqua Teen Hunger Force Colon Movie Film for Theaters', 'The Lazarus Effect', 'The Animal']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_isjJITtG7P3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "f6056fbc-a2b8-4e98-d3d8-28b5a0dcf421"
      },
      "source": [
        "recommend_me('Pirates of the Caribbean: Dead Mans Chest')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Prince of Persia: The Sands of Time', 'Alpha and Omega 4: The Legend of the Saw Toothed Cave', 'Lara Croft Tomb Raider: The Cradle of Life', 'Avatar', 'The Omega Code']\n",
            "['Into the Woods', 'The Lone Ranger', 'The Three Musketeers', 'Alice in Wonderland', 'Alice Through the Looking Glass']\n",
            "['Ramona and Beezus', 'Jimmy Neutron: Boy Genius', 'The Wiz', 'The Day After Tomorrow', 'Cutthroat Island']\n",
            "['Love in the Time of Monsters', 'Hotel Transylvania', 'Predator', 'Prophecy', 'Alice Through the Looking Glass']\n",
            "['Land of the Lost', 'Lara Croft Tomb Raider: The Cradle of Life', 'War', 'Rollerball', 'Bee Movie']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KwHSGtKW0QLC"
      },
      "source": [
        "def jaccard_similarity(list1, list2):\n",
        "    set1 = set(list1)\n",
        "    set2 = set(list2)\n",
        "    intersection = len(set1.intersection(set2))\n",
        "    union = len(set1) + len(set2) - intersection\n",
        "    return intersection / union"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7GUQ6EegpP9V"
      },
      "source": [
        "#Συναρτηση για την κατασκευη ενος λεξικου με κλειδι την ταινια και περιεχομενο τις παρομοιες ταινιες αυτης!\n",
        "from collections import defaultdict\n",
        "movie_relatives = defaultdict(list)\n",
        "\n",
        "similar = pd.read_csv(\"relative_movies.csv\")\n",
        "similar.fillna(\"UNK\", inplace=True)\n",
        "for row in similar.itertuples(index=True, name='Pandas'):\n",
        "    movie_title = clean_text(getattr(row, 'movie_title'))\n",
        "    for relative_movie in getattr(row, 'relative_movies').split(\",\"):\n",
        "      movie_relatives[movie_title].append(relative_movie)\n",
        "#similar.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MtCmygT1stAj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ffc9455e-b0a8-47e9-c8df-11404f49c25e"
      },
      "source": [
        "sum = 0\n",
        "count = 0\n",
        "for key in movie_relatives.keys():\n",
        "  count = count + 1\n",
        "  sum = sum + jaccard_similarity(simple_recommender_j(key),movie_relatives[key])\n",
        "sum = sum / count\n",
        "print(sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.023277549166877895\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sPOQgQzpurQ9"
      },
      "source": [
        "Παρατηρούμε ότι ο recommender δεν επιτυγχάνει πολύ καλό αποτέλεσμα κατα μέσο όρο όσον αφορά την συνάρτηση ομοιότητας συνόλων Jaccard."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aAM9o2UZFbMC"
      },
      "source": [
        "# **3ο Μέρος: Recommendation System Με βάση τις προτιμήσεις-αξιολογήσεις του χρήστη**\n",
        "\n",
        "Αρχικά μελετάμε τις αξιολογήσεις κάθε χρήστη για να καταλάβουμε την δομή και τις πληροφορίες κάθε αρχείου.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wdheN52GETd8"
      },
      "source": [
        "user = \"user1.csv\"\n",
        "ratings = pd.read_csv(user) \n",
        "\n",
        "# Preview the first 5 lines of the loaded data \n",
        "#ratings.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_AmyMzx5dXtS"
      },
      "source": [
        "**Κατασκευάζουμε τα scores για κάθε ταινία με βάση τις προηγούμενες αξιολογήσεις του χρήστη**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6V4QJFUTbRZC"
      },
      "source": [
        "similarity_weights = {\"similarity_5\": 15, \"similarity_4\":7, \"similarity_3\":3, \"similarity_2\":1, \"similarity_1\":0}\n",
        "rating_weight = {5: 10, 4: 5, 3: 0, 2: -5, 1: -10}\n",
        "\n",
        "movie_score = {m: 0 for m in  movie_score}\n",
        "for row in ratings.itertuples(index=True, name='Pandas'):\n",
        "    dummyset = set()\n",
        "    movie = clean_text(getattr(row, 'movie_title'))\n",
        "    rating = getattr(row, 'rating')    \n",
        "    \n",
        "    q = prolog.query(\"find_similar_movies_5('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "      if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_5'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n",
        "    \n",
        "    q = prolog.query(\"find_similar_movies_4('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "      if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_4'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n",
        "\n",
        "    q = prolog.query(\"find_similar_movies_3('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "      if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_3'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n",
        "\n",
        "    q = prolog.query(\"find_similar_movies_2('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "      if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_2'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n",
        "\n",
        "    q = prolog.query(\"find_similar_movies_1('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "      if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_1'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "luU3can3dm-N"
      },
      "source": [
        "**Στο σημείο αυτό κατασκευάζουμε την νέα συνάρτηση η όποια θα επιστρέφει τις προτεινόμενες ταινίες συνυπολογίζοντας τις αξιολογήσεις του χρήστη.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kvL14dw3c9cF"
      },
      "source": [
        "def recommender(movie_score):\n",
        "    movies_score = {k: v for k, v in sorted(movie_score.items(), key=lambda item: item[1], reverse = True)}\n",
        "    return [(m,movie_score[m]) for m in movies_score][:20]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VkHP2NVEvpqR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        },
        "outputId": "711c3f24-17a8-401a-cadc-ee9c815c4120"
      },
      "source": [
        "recommender(movie_score)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('Men in Black II', 2625),\n",
              " ('G-Force', 2550),\n",
              " ('TMNT', 2540),\n",
              " ('Lilo & Stitch', 2405),\n",
              " ('Teenage Mutant Ninja Turtles III', 2355),\n",
              " ('Men in Black 3', 2350),\n",
              " ('Atlantis: The Lost Empire', 2350),\n",
              " ('Pokémon 3: The Movie', 2340),\n",
              " ('Journey 2: The Mysterious Island', 2315),\n",
              " ('Zathura: A Space Adventure', 2315),\n",
              " ('Sinbad: Legend of the Seven Seas', 2260),\n",
              " ('Big Hero 6', 2250),\n",
              " ('The Iron Giant', 2245),\n",
              " ('Ice Age: The Meltdown', 2145),\n",
              " ('The Lego Movie', 2145),\n",
              " ('How to Train Your Dragon 2', 2140),\n",
              " ('Puss in Boots', 2140),\n",
              " ('Anastasia', 2125),\n",
              " ('Inside Out', 2085),\n",
              " ('The Magic Sword: Quest for Camelot', 2065)]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "THPE8RQm0QLk"
      },
      "source": [
        "Με βάση τις επιλογές που έδωσε το σύστημα ο χρήστης φαίνεται να απολαμβάνει ιδιαίτερα τις ταινίες κατηγοριων animatons και action."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "He-pA03Y0QLm"
      },
      "source": [
        "---\n",
        "<center><h2>Κατασκευή των Δικών σας Users</h2></center>\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fdS6X3di0QLq"
      },
      "source": [
        "import csv\n",
        "import numpy as np\n",
        "\n",
        "def create_my_user(reallyliked, liked, notLiked, hated, filename, num_of_liked =50, num_of_notliked = 50):\n",
        "    with open(filename, 'w', newline='') as file:\n",
        "        writer = csv.writer(file)\n",
        "        writer.writerow([\"movie_title\",\"rating\"])\n",
        "        reallyliked = np.random.choice(reallyliked, num_of_liked)\n",
        "        liked = np.random.choice(liked, num_of_liked)\n",
        "        notLiked = np.random.choice(notliked, num_of_notliked)\n",
        "        hated = np.random.choice(hated, num_of_notliked)\n",
        "        for i in  reallyliked:\n",
        "            grade = np.random.choice([5], p = [1])\n",
        "            writer.writerow([i, grade])\n",
        "        for i in  liked:\n",
        "            grade = np.random.choice([4,3], p = [0.6, 0.4])\n",
        "            writer.writerow([i, grade])\n",
        "        for i in  notLiked:\n",
        "            grade = np.random.choice([2], p = [1])\n",
        "            writer.writerow([i, grade])\n",
        "        for i in  hated:\n",
        "            grade = np.random.choice([1], p = [1])\n",
        "            writer.writerow([i, grade])    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MmCM6VUJ0QLt"
      },
      "source": [
        "# prolog.consult(\"db.pl\")\n",
        "#Κατασκευάστε τα κατηγορήματα για τις ταινίες που σας αρέσουν και για αυτές που δεν σας αρέσουν\n",
        "#Αν μια ταινία ανήκει σε μια ευρίτερη κατηγορία κατεσκευάστε την πρώτα\n",
        "prolog.assertz(\"(sci-fi(X) :- genre(X, 'Sci-Fi'))\")\n",
        "prolog.assertz(\"(comedy(X) :- genre(X, 'Comedy'))\")\n",
        "prolog.assertz(\"(animation(X) :- genre(X,'Animation'))\")\n",
        "prolog.assertz(\"(action(X) :- genre(X,'Action'))\")\n",
        "prolog.assertz(\"(adventure(X) :- genre(X, 'Adventure'))\")\n",
        "prolog.assertz(\"(thriller(X) :- genre(X,'Thriller'))\")\n",
        "prolog.assertz(\"(musical(X) :- genre(X,'Musical'))\")\n",
        "prolog.assertz(\"(documentary(X) :- genre(X,'Documentary'))\")\n",
        "\n",
        "prolog.assertz(\"(reallyliked(X) :- not(musical(X)),(animation(X); adventure(X)))\")\n",
        "prolog.assertz(\"(liked(X) :- not(musical(X)), ( sci-fi(X); comedy(X); action(X)))\")\n",
        "prolog.assertz(\"(notLiked(X) :- thriller(X))\")\n",
        "prolog.assertz(\"(hated(X) :- musical(X);documentary(X))\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XBeosQgb5QDj"
      },
      "source": [
        "Οι προτιμησεις εγιναν με βαση 4 καταστασεις reallyliked,liked,notliked,hated και δειγμα απο καθε κατηγορια 500 ταινιες"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "INWDw6Yv0QLw"
      },
      "source": [
        "q = prolog.query(\"reallyliked(M)\")\n",
        "ans = []\n",
        "for soln in q:\n",
        "    ans.append(soln[\"M\"])\n",
        "reallyliked = list(set(ans))\n",
        "\n",
        "q = prolog.query(\"liked(M)\")\n",
        "ans = []\n",
        "for soln in q:\n",
        "    ans.append(soln[\"M\"])\n",
        "liked = list(set(ans))\n",
        "\n",
        "q = prolog.query(\"notLiked(M)\")\n",
        "ans = []\n",
        "for soln in q:\n",
        "    ans.append(soln[\"M\"])\n",
        "notliked = list(set(ans))\n",
        "\n",
        "q = prolog.query(\"hated(M)\")\n",
        "ans = []\n",
        "for soln in q:\n",
        "    ans.append(soln[\"M\"])\n",
        "hated = list(set(ans))\n",
        "\n",
        "create_my_user(reallyliked, liked, notliked, hated, filename= \"myuser.csv\", num_of_liked = 500, num_of_notliked = 500)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MLjPO3yCQNcy"
      },
      "source": [
        "myuser = \"myuser.csv\"\n",
        "ratings = pd.read_csv(myuser) \n",
        "\n",
        "similarity_weights = {\"similarity_5\": 10, \"similarity_4\":8, \"similarity_3\":6, \"similarity_2\":3, \"similarity_1\":1}\n",
        "rating_weight = {5: 10, 4: 5, 3: 0, 2: -5, 1: -10}\n",
        "\n",
        "movie_score = {m: 0 for m in  movie_score}\n",
        "for row in ratings.itertuples(index=True, name='Pandas'):\n",
        "    movie = clean_text(getattr(row, 'movie_title'))\n",
        "    rating = getattr(row, 'rating')    \n",
        "    dummyset = set()\n",
        "\n",
        "    q = prolog.query(\"find_similar_movies_5('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "        if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_5'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n",
        "    \n",
        "    q = prolog.query(\"find_similar_movies_4('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "      if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_4'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n",
        "\n",
        "    q = prolog.query(\"find_similar_movies_3('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "      if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_3'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n",
        "\n",
        "    q = prolog.query(\"find_similar_movies_2('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "      if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_2'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n",
        "\n",
        "    q = prolog.query(\"find_similar_movies_1('\" + movie + \"',M)\")\n",
        "    for soln in q:\n",
        "      if soln[\"M\"] not in dummyset:\n",
        "          dummyset.add(soln[\"M\"])\n",
        "          movie_score [soln[\"M\"]] += similarity_weights['similarity_1'] * rating_weight[rating] #το weight θα το ορίσετε ανα επίπεδο ομοιότητας οι πολύ όμοιες ταινίες θα έχουν μεγαλύτερο βάρος\n",
        "    q.close()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yYBMwyHoQplg",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        },
        "outputId": "0df4e7af-e5ba-4fa2-80f6-9feaab180aa9"
      },
      "source": [
        "recommender(movie_score)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('Sinbad: Legend of the Seven Seas', 21810),\n",
              " ('Beverly Hills Chihuahua', 20620),\n",
              " ('The Secret Life of Walter Mitty', 19560),\n",
              " ('17 Again', 19340),\n",
              " ('Big', 19240),\n",
              " ('Herbie Fully Loaded', 18440),\n",
              " ('Shrek 2', 18025),\n",
              " ('The Book of Life', 17955),\n",
              " ('The Sisterhood of the Traveling Pants 2', 17890),\n",
              " ('The Sisterhood of the Traveling Pants', 17725),\n",
              " ('Mrs. Doubtfire', 17715),\n",
              " ('Christmas Mail', 17645),\n",
              " ('My Girl', 17620),\n",
              " ('Hannah Montana: The Movie', 17605),\n",
              " ('Y Tu Mamá También', 17530),\n",
              " ('What a Girl Wants', 17520),\n",
              " ('Aladdin', 17485),\n",
              " ('Bandslam', 17455),\n",
              " ('Sideways', 17355),\n",
              " ('Seeking a Friend for the End of the World', 17355)]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YsNlOtcl6_1C"
      },
      "source": [
        "Πραγματι οι ταινιες που προτεινε το συστημα ακολουθουν σε μεγαλο βαθμο τις προτιμησεις του χρηστη που \"χτισαμε\""
      ]
    }
  ]
}