KRED_notebook.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XenmVZLO1tAQ"
      },
      "source": [
        "# **Deep NLP project - Recommendation Systems**\n",
        "\n",
        "Python Notebook for the development and testing of the team project for the *Deep Natural Language Processing* course (a.a. 2022/2023) @ *Politecnico di Torino*.\n",
        "\n",
        "The [corresponding GitHub repository](https://github.com/micolrosini/KRED-Reccomendation-System) of this project consists of the following contents:\n",
        "- Implementation of the code\n",
        "- Problem statement & related works\n",
        "- Dataset description\n",
        "- Report paper about the whole activity\n",
        "- Link to this notebook for the quick execution of the code\n",
        "\n",
        "This notebook contains the loading and preprocessing of the Adressa Norwegian News Dataset used for the implementation of the Data Enrichment with News Reading Time extension.\n",
        "\n",
        "At the end of this notebook there are blocks for the execution of all the three models.\n",
        "\n",
        "***Authors:*** \\\\\n",
        "*@micolrosini - s302935@studenti.polito.it* \\\\\n",
        "*@gaiasabbatini - s291532@studenti.polito.it* \\\\\n",
        "*@matteogarbarino - s265386@studenti.polito.it*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yB6KyeqgJRs0"
      },
      "source": [
        "## 1. Import libraries & install the needed packages"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nr6X0AgQ2LoW"
      },
      "outputs": [],
      "source": [
        "# Import libraries & install packages\n",
        "from google.colab import drive      # to mount a Drive containing the dataset\n",
        "import os, sys, importlib           # to handle files and directories\n",
        "from time import time               # to estimate performances\n",
        "import tarfile                      # to unzip the dataset\n",
        "import json                         # to read structured raw text\n",
        "import pandas as pd                 # for dataset management\n",
        "from sys import getsizeof           # to check size of a variable (use %whos to see loist of all variables)\n",
        "import gc                           # garbage collector for memory management\n",
        "import pickle                       # used to store pickled versions of the datasets\n",
        "from tqdm import tqdm               # to show progress of operations\n",
        "import glob                         # to use regular expressions & paths\n",
        "import shutil                       # to easily copy files\n",
        "from urllib.parse import urlparse   # to retrieve specified fields from url string\n",
        "import ast                          # to convert the string representations to dictionaries\n",
        "import requests                     # to contact wikidata server\n",
        "import csv                          # to build kg for addressa news"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xqxhn0rdOimE"
      },
      "outputs": [],
      "source": [
        "!pip install tensorboardX\n",
        "!pip install -U sentence-transformers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Qc_ooS6JtTu"
      },
      "source": [
        "## 2. Environment setup\n",
        "- Clone the GitHub repository of the project to get the code\n",
        "- Position the working directory in the appropriate folder\n",
        "- Mount the Google Drive in order to access the dataset (contact the team to have access to it)\n",
        "- Move the dataset in the appropriate folder to be accessed by the code"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qBfi3KcS3dF_",
        "outputId": "7f2c9803-89da-4762-9728-d524fe01bd66"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'KRED-Reccomendation-System'...\n",
            "remote: Enumerating objects: 578, done.\u001b[K\n",
            "remote: Counting objects: 100% (177/177), done.\u001b[K\n",
            "remote: Compressing objects: 100% (84/84), done.\u001b[K\n",
            "remote: Total 578 (delta 106), reused 160 (delta 91), pack-reused 401\u001b[K\n",
            "Receiving objects: 100% (578/578), 7.95 MiB | 16.99 MiB/s, done.\n",
            "Resolving deltas: 100% (334/334), done.\n",
            "/content/KRED-Reccomendation-System\n",
            "Mounted at /content/drive\n",
            "cp: cannot open '/content/drive/MyDrive/AdressaProcessed/behavior-day1.gsheet' for reading: Operation not supported\n",
            "\n",
            "\n",
            "Stage completed in 5.77 minutes\n"
          ]
        }
      ],
      "source": [
        "t1 = time()\n",
        "\n",
        "# Clone the GitHub repository\n",
        "repo = \"KRED-Reccomendation-System\"\n",
        "if os.path.isdir(repo):\n",
        "  !rm -rf {repo}\n",
        "\n",
        "!git clone https://github.com/micolrosini/KRED-Reccomendation-System.git\n",
        "\n",
        "# Enter the correct directory (with main.py)\n",
        "%cd 'KRED-Reccomendation-System'\n",
        "\n",
        "# Mount Drive with Dataset\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# Move the dataset in the correct folder for the code to run\n",
        "%cp -R /content/drive/MyDrive/KRED/KRED/data /content/KRED-Reccomendation-System\n",
        "%cp -R /content/drive/MyDrive/AdressaProcessed /content/KRED-Reccomendation-System/data\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\n\\nStage completed in {str(round((t2-t1)/60, 2))} minutes\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pME33dM2KFhn"
      },
      "source": [
        "# **Extension 1: Adressa dataset - Norwegian news dataset - Data loading and preprocessing**\n",
        "\n",
        "This experiment uses the Adressa (small: 1 week) dataset which is a Norwegian news dataset including also a field representing the time spent by a user on an article. This information can be exploited to better infer the actual interest the user had towards each article and therefore enrich the model.\n",
        "\n",
        "**Requirements**:\n",
        "In order to run this section it's necessary to execute before sections *1. Import libraries & install the needed packages* and *2. Environment setup* which imports the dataset from Google Drive (section *3. Execution* shoul be skipped)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nmHA6y5rLNtr"
      },
      "source": [
        "## 1.1 Unzip dataset\n",
        "\n",
        "*Remark: This section and section 1.2 (together with its sub-sections) can be skipped since the dataset has already been generated and store on a Google Drive clound. It is possible to run directly 1.3*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GY6qf8fBKF3x",
        "outputId": "66f5ed14-a72c-4080-948a-cdd651f06473"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "Stage completed in 89.72 seconds\n"
          ]
        }
      ],
      "source": [
        "t1 = time()\n",
        "\n",
        "# UNZIP THE DATASET\n",
        "\n",
        "# File structured as:\n",
        "#   AdressaSMALL.tar.gz --> one_week.tar --> one_week (folder) --> 7 files, one for each day of the week\n",
        "\n",
        "fname = \"AdressaSMALL.tar.gz\"               # dataset compressed file name\n",
        "datapath = \"./data/\"                        # dataset location\n",
        "tar = tarfile.open(datapath+fname, \"r:gz\")  # open the .tar.gz file\n",
        "tar.extractall(path=datapath)               # extract one_week folder and place it in ./data\n",
        "tar.close()                                 # close the file handle\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\n\\nStage completed in {str(round(t2-t1, 2))} seconds\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-7sNr2Z8Sp8z"
      },
      "source": [
        "## Insights about the dataset attributes:\n",
        "\n",
        "The dataset is mostly composed of 2 types of rows (namely \"Long row\" and \"Short row\") structured as json formatting (read in memory as dictionaries).\n",
        "\n",
        "The documentation of the dataset offers a description of most of the present fields.\n",
        "\n",
        "The Short Row is (almost always) a subset of Long Row.\n",
        "\n",
        "\n",
        "\n",
        "| Attribute | Type | Description | Long row | Short row |\n",
        "|:--------------|:-----------|:------------|:------------|:------------|\n",
        "| eventId | int | The identifier used to differentiate distinct events from the same user | True | True |\n",
        "| activeTime | int | The active time on a page in seconds, if known | True | True |\n",
        "| os | string | Operating system that the user used when log in. | True | True\n",
        "| referrerUrl | sting | The URL of the referrer page. | True | False\n",
        "| deviceType | string | The type of the device. | True | True\n",
        "| sessionStart | boolean | Indicates whether the event is considered as the first event in session | True | True |\n",
        "| sessionStop | boolean | Indicates whether the event is considered as the last event in session | True | True |\n",
        "| userId | string | The cross-site user identifier which can be used to differentiate devices/browsers, or identify different subscription users by the user id | True | True |\n",
        "| category | sting | The category of the news article. | False | False |\n",
        "| city | string | The city name inferred from the IP address. | True | True |\n",
        "| country | string | The country code inferred from the user’s IP address. | True | True |\n",
        "| region | string | The region code inferred from the IP address. | True |  True |\n",
        "| time | int | The time of event, measured in Unix time. | True | True |\n",
        "| canonicalUrl | sting | Canonical URL as calculated based on incoming events and the fetched page content. | True | False |\n",
        "| documentId (present as \"id\") | string | The document id. This will be the same for different URLs | True | False |\n",
        "| title | string | The title of the article. | True | False |\n",
        "| keywords | list | The keywords of the article. | True | False |\n",
        "| namedEntities | list | The named entities of the article, including their types, counts and weights. | False | False |\n",
        "| author | string | The author of the article. | True | False |\n",
        "| publishTime | string | The publish time of the article. | True | False |\n",
        "| profile | Array of object | A set of items which are extracted or generated from the page content. Usually a string or keywords or Named Entities from the page | True | False |\n",
        "| item\\* | sting | Item extracted or generated from the page content. Usually a string or keyword extracted from the page. | True* | False |\n",
        "| referrerHostClass | string | NOT PRESENT IN THE DOCUMENTATION | True | True |\n",
        "| url | string | NOT PRESENT IN THE DOCUMENTATION | True | True |\n",
        "| referrerSearchEngine | string | NOT PRESENT IN THE DOCUMENTATION | True | False |\n",
        "| query | string | NOT PRESENT IN THE DOCUMENTATION | ? | ? |\n",
        "| referrerSocialNetwork | ? | NOT PRESENT IN THE DOCUMENTATION | ? | ? |\n",
        "| category1 | ? | NOT PRESENT IN THE DOCUMENTATION | ? | ? |\n",
        "| referrerQuery | ? | NOT PRESENT IN THE DOCUMENTATION | ? | ? |\n",
        "\n",
        "(*) Item is not a field of the rows, but is a subfield of profile in the long rows\n",
        "\n",
        "### Conclusions\n",
        "After a careful examination, the attributes to keep are:\n",
        "- eventId --> primary key of the table\n",
        "- time --> to get a ordering & needed by behaviours.tsv\n",
        "- userId --> needed by behaviours.tsv\n",
        "- url --> needed by both news.ts used as News ID\n",
        "- profile --> needed by news.tsv to extract entities\n",
        "- category1 --> needed by news.tsv to extract entities\n",
        "- keywords --> needed by news.tsv to extract entities\n",
        "- title --> needed by news.tsv to extract entities\n",
        "- activeTime --> needed to recreate user behavior.tsv\n",
        "- sessionStart --> needed to recreate user history (possibly removable)\n",
        "- sessionStop --> needed to recreate user history (possibly removable)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3gPq32iAzmHf"
      },
      "source": [
        "## 1.2 Read dataset in a proper structure\n",
        "\n",
        "The dataset is composed of 7 files, one for each day of a week. Files are in .txt extension in which rows are strings with json formatting.\n",
        "\n",
        "The 7 daily files are too big (w.r.t. Colab 12GB of RAM) to be directly loaded and processed in RAM within a single operation.\n",
        "\n",
        "The procedure is the following:\n",
        "\n",
        "Block 1.2.1\n",
        "\n",
        "1. Read one daily file at the time\n",
        "2. For each daily file, process it in batches of X rows at the time\n",
        "3. The file is initially read as a list of strings (rows), then exploit JSON formatting to transition to a list of dictionaries and eventually obtain a pandas dataframe\n",
        "4. In the process at point 3. many other transformations are applied in order to properly clean the data and reorganize the dataframe schema\n",
        "5. Each dataframe obtained at point 4. (of the given batch size X) is saved as a segment of the given day\n",
        "6. When all the segments of a day have been processed they are again loaded in memory and reassembled as a single day to be finally stored as a single .csv file\n",
        "\n",
        "Block 1.2.2\n",
        "\n",
        "7. All the 7 full daily .csv files are read and merged into a single weekly file\n",
        "8. The weekly file is saved as a .csv file\n",
        "9. All the daily and weekly files are also copied to the mounted Google Drive for future use"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dnSTTgsMfJSe",
        "outputId": "089d15c3-e3c1-4ab8-da54-d55d3d434be4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Preprocessing file 1 of 7\n",
            "\t- Reading file from disk\n",
            "\t- Transforming file into a list of rows\n",
            "\t  Stage completed in 11.45 seconds\n",
            "\n",
            "- Processing batch 1 with indices [0,350000] (total rows: 1513739)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 138.78 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 14.2 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 2 with indices [350000,700000] (total rows: 1513739)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 139.51 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 12.67 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 3 with indices [700000,1050000] (total rows: 1513739)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 146.41 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 15.45 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 4 with indices [1050000,1400000] (total rows: 1513739)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 158.01 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 21.09 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 5 with indices [1400000,1513739] (total rows: 1513739)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 68.29 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 7.47 seconds\n",
            "\n",
            "\n",
            "- All batches have been processed and saved\n",
            "\n",
            "Reassembling segments of day 1:\n",
            "- Reading all the .CSV segments to build final dataset\n",
            "\t- Unpickling segments: 100.0%\n",
            "\t- Concatenating segments into a single dataframe\n",
            "\t- Freeing memory\n",
            "- Saving final dataset as: ./data/pickled_dataset/day1.csv\n",
            "- Saved successfully\n",
            "- Removing segments\n",
            "  Stage completed in 43.73 seconds\n",
            "\n",
            "Preprocessing file 2 of 7\n",
            "\t- Reading file from disk\n",
            "\t- Transforming file into a list of rows\n",
            "\t  Stage completed in 13.36 seconds\n",
            "\n",
            "- Processing batch 1 with indices [0,350000] (total rows: 1613128)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 127.76 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 13.99 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 2 with indices [350000,700000] (total rows: 1613128)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 135.89 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 9.12 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 3 with indices [700000,1050000] (total rows: 1613128)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 147.81 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 18.98 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 4 with indices [1050000,1400000] (total rows: 1613128)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 162.7 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 22.78 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 5 with indices [1400000,1613128] (total rows: 1613128)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 113.35 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 15.95 seconds\n",
            "\n",
            "\n",
            "- All batches have been processed and saved\n",
            "\n",
            "Reassembling segments of day 2:\n",
            "- Reading all the .CSV segments to build final dataset\n",
            "\t- Unpickling segments: 100.0%\n",
            "\t- Concatenating segments into a single dataframe\n",
            "\t- Freeing memory\n",
            "- Saving final dataset as: ./data/pickled_dataset/day2.csv\n",
            "- Saved successfully\n",
            "- Removing segments\n",
            "  Stage completed in 49.6 seconds\n",
            "\n",
            "Preprocessing file 3 of 7\n",
            "\t- Reading file from disk\n",
            "\t- Transforming file into a list of rows\n",
            "\t  Stage completed in 9.47 seconds\n",
            "\n",
            "- Processing batch 1 with indices [0,350000] (total rows: 1087223)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 128.4 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 15.43 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 2 with indices [350000,700000] (total rows: 1087223)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 156.99 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 19.95 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 3 with indices [700000,1050000] (total rows: 1087223)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 158.43 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 19.4 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 4 with indices [1050000,1087223] (total rows: 1087223)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 34.77 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 1.94 seconds\n",
            "\n",
            "\n",
            "- All batches have been processed and saved\n",
            "\n",
            "Reassembling segments of day 3:\n",
            "- Reading all the .CSV segments to build final dataset\n",
            "\t- Unpickling segments: 100.0%\n",
            "\t- Concatenating segments into a single dataframe\n",
            "\t- Freeing memory\n",
            "- Saving final dataset as: ./data/pickled_dataset/day3.csv\n",
            "- Saved successfully\n",
            "- Removing segments\n",
            "  Stage completed in 36.21 seconds\n",
            "\n",
            "Preprocessing file 4 of 7\n",
            "\t- Reading file from disk\n",
            "\t- Transforming file into a list of rows\n",
            "\t  Stage completed in 15.31 seconds\n",
            "\n",
            "- Processing batch 1 with indices [0,350000] (total rows: 1496417)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 143.34 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 20.01 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 2 with indices [350000,700000] (total rows: 1496417)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 163.15 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 19.54 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 3 with indices [700000,1050000] (total rows: 1496417)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 174.69 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 28.18 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 4 with indices [1050000,1400000] (total rows: 1496417)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 179.13 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 26.4 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 5 with indices [1400000,1496417] (total rows: 1496417)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 68.93 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 6.62 seconds\n",
            "\n",
            "\n",
            "- All batches have been processed and saved\n",
            "\n",
            "Reassembling segments of day 4:\n",
            "- Reading all the .CSV segments to build final dataset\n",
            "\t- Unpickling segments: 100.0%\n",
            "\t- Concatenating segments into a single dataframe\n",
            "\t- Freeing memory\n",
            "- Saving final dataset as: ./data/pickled_dataset/day4.csv\n",
            "- Saved successfully\n",
            "- Removing segments\n",
            "  Stage completed in 61.1 seconds\n",
            "\n",
            "Preprocessing file 5 of 7\n",
            "\t- Reading file from disk\n",
            "\t- Transforming file into a list of rows\n",
            "\t  Stage completed in 11.48 seconds\n",
            "\n",
            "- Processing batch 1 with indices [0,350000] (total rows: 1327429)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 138.54 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 19.27 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 2 with indices [350000,700000] (total rows: 1327429)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 152.61 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 19.98 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 3 with indices [700000,1050000] (total rows: 1327429)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 159.76 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 19.85 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 4 with indices [1050000,1327429] (total rows: 1327429)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 135.48 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 17.51 seconds\n",
            "\n",
            "\n",
            "- All batches have been processed and saved\n",
            "\n",
            "Reassembling segments of day 5:\n",
            "- Reading all the .CSV segments to build final dataset\n",
            "\t- Unpickling segments: 100.0%\n",
            "\t- Concatenating segments into a single dataframe\n",
            "\t- Freeing memory\n",
            "- Saving final dataset as: ./data/pickled_dataset/day5.csv\n",
            "- Saved successfully\n",
            "- Removing segments\n",
            "  Stage completed in 47.4 seconds\n",
            "\n",
            "Preprocessing file 6 of 7\n",
            "\t- Reading file from disk\n",
            "\t- Transforming file into a list of rows\n",
            "\t  Stage completed in 12.87 seconds\n",
            "\n",
            "- Processing batch 1 with indices [0,350000] (total rows: 1648346)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 133.52 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 17.25 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 2 with indices [350000,700000] (total rows: 1648346)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 148.59 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 15.97 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 3 with indices [700000,1050000] (total rows: 1648346)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 150.3 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 18.82 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 4 with indices [1050000,1400000] (total rows: 1648346)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 155.58 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 19.29 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 5 with indices [1400000,1648346] (total rows: 1648346)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 121.39 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 15.01 seconds\n",
            "\n",
            "\n",
            "- All batches have been processed and saved\n",
            "\n",
            "Reassembling segments of day 6:\n",
            "- Reading all the .CSV segments to build final dataset\n",
            "\t- Unpickling segments: 100.0%\n",
            "\t- Concatenating segments into a single dataframe\n",
            "\t- Freeing memory\n",
            "- Saving final dataset as: ./data/pickled_dataset/day6.csv\n",
            "- Saved successfully\n",
            "- Removing segments\n",
            "  Stage completed in 52.87 seconds\n",
            "\n",
            "Preprocessing file 7 of 7\n",
            "\t- Reading file from disk\n",
            "\t- Transforming file into a list of rows\n",
            "\t  Stage completed in 8.43 seconds\n",
            "\n",
            "- Processing batch 1 with indices [0,350000] (total rows: 1356987)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 135.94 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 18.57 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 2 with indices [350000,700000] (total rows: 1356987)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 146.16 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 11.76 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 3 with indices [700000,1050000] (total rows: 1356987)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 131.94 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 11.3 seconds\n",
            "\n",
            "\n",
            "\n",
            "- Processing batch 4 with indices [1050000,1356987] (total rows: 1356987)\n",
            "\t- Transforming the json-formatted list of rows into a list of dictionaries\n",
            "\t- Casting JSON strings to dictionaries progress: 100.0%\n",
            "\t- Transforming the list of dictionaries into a pandas dataframe\n",
            "\t- Projecting on the needed dataframe attributes\n",
            "\t  Stage completed in 118.75 seconds\n",
            "\n",
            "\t- Saving the segment on disk\n",
            "\t  Stage completed in 7.34 seconds\n",
            "\n",
            "\n",
            "- All batches have been processed and saved\n",
            "\n",
            "Reassembling segments of day 7:\n",
            "- Reading all the .CSV segments to build final dataset\n",
            "\t- Unpickling segments: 100.0%\n",
            "\t- Concatenating segments into a single dataframe\n",
            "\t- Freeing memory\n",
            "- Saving final dataset as: ./data/pickled_dataset/day7.csv\n",
            "- Saved successfully\n",
            "- Removing segments\n",
            "  Stage completed in 31.75 seconds\n",
            "\n",
            "\n",
            "\n",
            "Stage completed in 4853.15 seconds\n"
          ]
        }
      ],
      "source": [
        "\"\"\"\n",
        "Remark: pickle has been abandoned due to lack of RAM, CSV format is in use, but\n",
        "        the old variable and path names including \"pickle\" remain for sake of simplicity\n",
        "        (could be refactored)\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "t_start = time()\n",
        "\n",
        "days = [1,2,3,4,5,6,7]\n",
        "\n",
        "for d in days:\n",
        "  SELECTED_DAY = d                            # loop on all the days\n",
        "\n",
        "  BATCH_SIZE = 350000                         # how many lines to process at the time\n",
        "\n",
        "  if SELECTED_DAY not in range(1,8):          # check selection is in [1,2,3,4,5,6,7]\n",
        "    exit(-1)\n",
        "\n",
        "  VERBOSE = False                              # print some additional info\n",
        "\n",
        "  SAVE_MODE = \"csv\"                           # use pickle only with more than 12 GB of ram\n",
        "  if SAVE_MODE not in ['csv', 'pkl']:         # check selection is valid\n",
        "    exit(-1)\n",
        "\n",
        "  DELETE_FINAL_DATAFRAME = True               # clear final df (whole day)\n",
        "\n",
        "  datapath = \"./data/\"                                        # just a reminder\n",
        "  adressa_datapath = datapath + \"one_week/\"                   # build the path of the unzipped Adressa dataset\n",
        "  pickled_dataset_path = datapath + \"pickled_dataset/\"        # build the path where the csv datasets will be stored\n",
        "  segments_dataset_path = pickled_dataset_path + \"segments/\"  # build the path where the daily csv segments will be stored\n",
        "\n",
        "  filenames = os.listdir(adressa_datapath)    # get the list of the 7 daily filenames\n",
        "  inputFileName = filenames[SELECTED_DAY-1]\n",
        "\n",
        "  # Complete list of dataset attributes:\n",
        "  \"\"\"\n",
        "  | eventId | city | activeTime | url | referrerHostClass | region | time\n",
        "  | userId | sessionStart | deviceType | sessionStop | country | os | referrerUrl\n",
        "  | profile | category1 | canonicalUrl | publishtime | keywords | id | title\n",
        "  | author | referrerSearchEngine | referrerSocialNetwork | referrerQuery | query |\n",
        "  \"\"\"\n",
        "  # Keep a subset of attributes\n",
        "  attributes = [\n",
        "                'eventId',        # primary key of the table\n",
        "                'time',           # to get a ordering & needed by behaviours.tsv\n",
        "                'userId',         # needed by behaviours.tsv\n",
        "\n",
        "                #'id',            # newsId, needed by both news.tsv & behaviours.tsv BUT DROPPED since it not complete (url will work also as newsId, i.e. primary key for news)\n",
        "                'url',            # needed by both news.tsv and behaviour.tsv (AND read line above)\n",
        "                'profile',        # needed by both news.tsv and behaviour.tsv\n",
        "                'category1',      # needed by both news.tsv and behaviour.tsv\n",
        "                'keywords',       # needed by both news.tsv and behaviour.tsv\n",
        "                'title',          # needed by both news.tsv and behaviour.tsv\n",
        "\n",
        "                'activeTime',     # needed to classify into positive and negative list + useful to extract user history\n",
        "                'sessionStart',   # potentially needed to recreate user history (boolean columns are negligible in terms of space)\n",
        "                'sessionStop',    # potentially needed to recreate user history (boolean columns are negligible in terms of space)\n",
        "                ]\n",
        "\n",
        "\n",
        "  # =================================== START ===================================\n",
        "\n",
        "  print(f\"Preprocessing file {SELECTED_DAY} of {len(filenames)}\")\n",
        "\n",
        "\n",
        "  # 1. Read single file from disk\n",
        "  # 2. split in rows\n",
        "  # 3. free memory\n",
        "  # 4. remove empty rows\n",
        "\n",
        "  t1 = time()\n",
        "\n",
        "  dataset = list()\n",
        "\n",
        "  with open(adressa_datapath + inputFileName) as daily_file:  # open the selected file\n",
        "\n",
        "    print('\\t- Reading file from disk')\n",
        "    fileContents = daily_file.read()                          # load the file into a single big string\n",
        "\n",
        "    print('\\t- Transforming file into a list of rows')\n",
        "    dataset = dataset + fileContents.split(\"\\n\")              # split the whole file into lines & save the obtained rows into a list\n",
        "\n",
        "    del fileContents                                          # free the memory\n",
        "    gc.collect()                                              # call the garbage collector to force variables deletion\n",
        "\n",
        "    dataset = list(filter(lambda a: a != '', dataset))        # lambda expression to keep only non-empty rows\n",
        "\n",
        "  t2 = time()\n",
        "  print(f\"\\t  Stage completed in {str(round(t2-t1, 2))} seconds\")\n",
        "\n",
        "  # 5. Loop on batches\n",
        "  # 6. Restrict dataset size\n",
        "  # 7. Cast to list of dictionaries\n",
        "  # 8. Cast to datadrame\n",
        "  # 9. Project on attributes\n",
        "  # 10. Reorder & rename columns\n",
        "  # 11. Free memory\n",
        "\n",
        "  t1 = time()\n",
        "\n",
        "  rowsOfTheDay = len(dataset)                             # total rows of selected day\n",
        "  segmentsProcessed = 0                                   # how many batches have already been processed so far\n",
        "\n",
        "  while segmentsProcessed*BATCH_SIZE < rowsOfTheDay:      # as long as there are still rows to process\n",
        "    startIndex = segmentsProcessed*BATCH_SIZE             # reposition start index\n",
        "    stopIndex = startIndex + BATCH_SIZE                   # reposition end index\n",
        "    if stopIndex > rowsOfTheDay:                          # fix end index out of boundaries of dataframe\n",
        "      stopIndex = rowsOfTheDay\n",
        "\n",
        "    print(f'\\n- Processing batch {segmentsProcessed+1} with indices [{startIndex},{stopIndex}] (total rows: {rowsOfTheDay})')\n",
        "\n",
        "    datasetSmall = dataset[startIndex:stopIndex]          # restrict the dataset size to a batch\n",
        "    gc.collect()                                          # free memory (nothing to free at first iteration)\n",
        "\n",
        "    # Exploit JSON formatting of rows to get a list of dictionaries\n",
        "    print('\\t- Transforming the json-formatted list of rows into a list of dictionaries')\n",
        "    c = 0                                                 # counter to track progression\n",
        "    JSONDataset = list()                                  # new dataset handle\n",
        "    for r in datasetSmall:                                # loop over each single row (string with json formatting)\n",
        "      JSONDataset.append(json.loads(r))                   # each json row is transformed to a dictionary\n",
        "      c += 1                                              # count the row as read\n",
        "      print(f\"\\r\\t- Casting JSON strings to dictionaries progress: {str(round(c/(stopIndex-startIndex)*100, 2))}%\",end='')\n",
        "    print(f\"\\r\\t- Casting JSON strings to dictionaries progress: {str(round(c/(stopIndex-startIndex)*100, 2))}%\")\n",
        "    del datasetSmall                                      # free memory asap\n",
        "    gc.collect()                                          # call the garbage collector to force variables deletion\n",
        "\n",
        "    print('\\t- Transforming the list of dictionaries into a pandas dataframe')\n",
        "    df = pd.DataFrame(JSONDataset)                        # cast list of dictionaries to Pandas DataFrame\n",
        "    del JSONDataset                                       # free memory asap\n",
        "    gc.collect()                                          # call the garbage collector to force variables deletion\n",
        "\n",
        "    print('\\t- Projecting on the needed dataframe attributes')\n",
        "    dfSmall = df[attributes]                              # project onto the needed attributes only\n",
        "    dfSmall = dfSmall.reindex(columns=attributes)         # rearrange columns order\n",
        "\n",
        "    if \"category1\" in dfSmall.columns:                    # rename column \"category\"\n",
        "      dfSmall.rename(columns = {'category1':'category'}, inplace = True)\n",
        "\n",
        "    del df                                                # free memory asap\n",
        "    gc.collect()                                          # call the garbage collector to force variables deletion\n",
        "\n",
        "    t2 = time()\n",
        "    print(f\"\\t  Stage completed in {str(round(t2-t1, 2))} seconds\\n\")\n",
        "\n",
        "\n",
        "\n",
        "    # 12. Save csv version of the segment\n",
        "    # 13. Go back to 5. until all file has been processed\n",
        "\n",
        "    t1 = time()\n",
        "    outputSegmentName = f\"day{SELECTED_DAY}segment{segmentsProcessed+1}.csv\" # e.g. day1segment1.csv\n",
        "    outputPath = segments_dataset_path + outputSegmentName                   # e.g. ./data/pickled_dataset/segments/day1segment1.csv\n",
        "\n",
        "    if not os.path.exists(segments_dataset_path):          # create ./data/pickled_dataset/segments/ if not exists\n",
        "      os.makedirs(segments_dataset_path)\n",
        "\n",
        "    print('\\t- Saving the segment on disk')\n",
        "    dfSmall.to_csv(outputPath, index = False)              # ./data/pickled_dataset/segments/day1segment1.csv\n",
        "    del dfSmall                                            # free the memory asap\n",
        "    gc.collect()                                           # call the garbage collector to force variables deletion\n",
        "\n",
        "    t2 = time()\n",
        "    print(f\"\\t  Stage completed in {str(round(t2-t1, 2))} seconds\\n\")\n",
        "\n",
        "\n",
        "    segmentsProcessed += 1\n",
        "    print()\n",
        "\n",
        "  print(f\"- All batches have been processed and saved\\n\")\n",
        "\n",
        "  # 14. re-load all .csv segments\n",
        "  # 15. concatenate dataframe segments into a single dataframe\n",
        "  # 16. save final pickled versionn of the day\n",
        "\n",
        "  t1 = time()\n",
        "\n",
        "  print(f\"Reassembling segments of day {SELECTED_DAY}:\")\n",
        "\n",
        "  print('- Reading all the .CSV segments to build final dataset')\n",
        "\n",
        "  segmentNames = glob.glob(segments_dataset_path + '*.csv')         # read all segments full paths\n",
        "\n",
        "  c = 0                                                             # track the progression\n",
        "  segments = list()                                                 # list of segments df that are going to be read\n",
        "  for segmentName in segmentNames:                                  # for each csv segment\n",
        "    print(f\"\\r\\t- Unpickling segments: {str(round(c/len(segmentNames)*100, 2))}%\",end='')\n",
        "    segments.append(pd.read_csv(segmentName, index_col=False))      # read the segment\n",
        "    c += 1\n",
        "  print(f\"\\r\\t- Unpickling segments: {str(round(c/len(segmentNames)*100, 2))}%\")\n",
        "  gc.collect()                                                      # free some memory in case of memory leaks\n",
        "\n",
        "  print(f\"\\t- Concatenating segments into a single dataframe\")\n",
        "  finalDf = pd.concat(segments, ignore_index=True)                  # build final dataset concatenating segments (whole day)\n",
        "  print(f\"\\t- Freeing memory\")\n",
        "  segments.clear()                                                  # free memory asap\n",
        "  del segments                                                      # free memory asap\n",
        "  gc.collect()                                                      # free memory asap\n",
        "\n",
        "  if VERBOSE:                                                       # additional info on screen\n",
        "    print(f\"Dataframe length: {len(finalDf)} rows\")\n",
        "    print(f\"Dataframe size: {str(round(getsizeof(finalDf) /1024 /1024,2))} MB\")\n",
        "    print(finalDf.info())\n",
        "\n",
        "  if SAVE_MODE == 'pkl':                                            # DEPRECATED\n",
        "    outputFileName = f\"day{SELECTED_DAY}.pkl\"\n",
        "    outputPath = pickled_dataset_path + outputFileName\n",
        "    print(f'- Saving final dataset as: {outputPath}')\n",
        "    finalDf.to_pickle(outputPath)\n",
        "\n",
        "  elif SAVE_MODE == 'csv':                                          # TO BE USED\n",
        "    outputFileName = f\"day{SELECTED_DAY}.csv\"\n",
        "    outputPath = pickled_dataset_path + outputFileName               # e.g. /content/KRED-Reccomendation-System/data/pickled_dataset/day1.csv\n",
        "    print(f'- Saving final dataset as: {outputPath}')\n",
        "    finalDf.to_csv(outputPath, index = False)\n",
        "\n",
        "  else:\n",
        "    # Should not happen\n",
        "    print(f'- Failed to save final dataframe')\n",
        "\n",
        "  print(f'- Saved successfully')\n",
        "\n",
        "  if DELETE_FINAL_DATAFRAME:                                        # delete whole day df if not needed immediately\n",
        "    del finalDf                                                     # free memory asap\n",
        "\n",
        "  gc.collect()                                                      # free memory asap\n",
        "\n",
        "  print(f'- Removing segments')\n",
        "  if os.path.isdir(segments_dataset_path):                          # segments folder must be removed\n",
        "    !rm -rf {segments_dataset_path}                                 #  to avoid interactions over different runs\n",
        "\n",
        "  t2 = time()\n",
        "  print(f\"  Stage completed in {str(round(t2-t1, 2))} seconds\\n\")\n",
        "\n",
        "\n",
        "t_end = time()\n",
        "print(f\"\\n\\nStage completed in {str(round(t_end-t_start, 2))} seconds\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cs8GUQ0QVKRp"
      },
      "source": [
        "1.2.2 Build final dataset:\n",
        "- load all 7 daily files\n",
        "- build weekly dataset\n",
        "- store weekly dataset in the mounted Drive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lULCZCe1bVsG",
        "outputId": "a5581d3f-eb70-44b5-b7b1-5c0464ffa3a0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "./data/pickled_dataset/day3.csv\n",
            "Dataframe length: 1087223 rows\n",
            "Dataframe size: 1334.42 MB\n",
            "\n",
            "./data/pickled_dataset/day1.csv\n",
            "Dataframe length: 1513739 rows\n",
            "Dataframe size: 1630.48 MB\n",
            "\n",
            "./data/pickled_dataset/day6.csv\n",
            "Dataframe length: 1648346 rows\n",
            "Dataframe size: 1935.27 MB\n",
            "\n",
            "./data/pickled_dataset/day5.csv\n",
            "Dataframe length: 1327429 rows\n",
            "Dataframe size: 1674.37 MB\n",
            "\n",
            "./data/pickled_dataset/day2.csv\n",
            "Dataframe length: 1613128 rows\n",
            "Dataframe size: 1880.59 MB\n",
            "\n",
            "./data/pickled_dataset/day4.csv\n",
            "Dataframe length: 1496417 rows\n",
            "Dataframe size: 2182.39 MB\n",
            "\n",
            "./data/pickled_dataset/day7.csv\n",
            "Dataframe length: 1356987 rows\n",
            "Dataframe size: 1237.12 MB\n",
            "\n",
            "Dataframe length: 10043269 rows\n",
            "Dataframe size: 11874.65 MB\n",
            "\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 10043269 entries, 0 to 10043268\n",
            "Data columns (total 11 columns):\n",
            " #   Column        Dtype  \n",
            "---  ------        -----  \n",
            " 0   eventId       int64  \n",
            " 1   time          int64  \n",
            " 2   userId        object \n",
            " 3   url           object \n",
            " 4   profile       object \n",
            " 5   category      object \n",
            " 6   keywords      object \n",
            " 7   title         object \n",
            " 8   activeTime    float64\n",
            " 9   sessionStart  bool   \n",
            " 10  sessionStop   bool   \n",
            "dtypes: bool(2), float64(1), int64(2), object(6)\n",
            "memory usage: 708.8+ MB\n",
            "None\n",
            "\n",
            "Stage completed in 104.11 seconds\n",
            "\n"
          ]
        }
      ],
      "source": [
        "t1 = time()\n",
        "\n",
        "DELETE = True                                               # cleanup at the end\n",
        "\n",
        "dailyFileNames = glob.glob(pickled_dataset_path + '*.csv')  # get list of daily files paths\n",
        "\n",
        "dayilyDfs = list()                                          # read all daily files into a list\n",
        "progress = 0\n",
        "for name in dailyFileNames:\n",
        "  print(name)\n",
        "  dayilyDfs.append(pd.read_csv(name, index_col=False))\n",
        "  print(f\"Dataframe length: {len(dayilyDfs[progress])} rows\")\n",
        "  print(f\"Dataframe size: {str(round(getsizeof(dayilyDfs[progress]) /1024 /1024,2))} MB\\n\")\n",
        "  progress += 1\n",
        "\n",
        "weeklyDf = pd.concat(dayilyDfs, ignore_index=True)          # concatenate all daily files into a weekly file\n",
        "print(f\"Dataframe length: {len(weeklyDf)} rows\")\n",
        "print(f\"Dataframe size: {str(round(getsizeof(weeklyDf) /1024 /1024,2))} MB\\n\")\n",
        "print(weeklyDf.info())\n",
        "\n",
        "\n",
        "if DELETE:                                                   # cleanup\n",
        "  dayilyDfs.clear()\n",
        "  del(dayilyDfs)\n",
        "  gc.collect()\n",
        "\n",
        "\n",
        "outputFileName = \"week.csv\"                         # Save weekly df on disk\n",
        "outputPath = pickled_dataset_path + outputFileName  # e.g. /content/KRED-Reccomendation-System/data/pickled_dataset/week.csv\n",
        "print(f'- Saving final dataset as: {outputPath}')\n",
        "weeklyDf.to_csv(outputPath, index = False)          # WARNING: files is 9+GB --> takes a lot of time\n",
        "\n",
        "# save on drive --> i.e. copy files in drive folder\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/pickled_dataset/week.csv\", \"/content/drive/MyDrive/AdressaProcessed/week.csv\")\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/pickled_dataset/day1.csv\", \"/content/drive/MyDrive/AdressaProcessed/day1.csv\")\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/pickled_dataset/day2.csv\", \"/content/drive/MyDrive/AdressaProcessed/day2.csv\")\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/pickled_dataset/day3.csv\", \"/content/drive/MyDrive/AdressaProcessed/day3.csv\")\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/pickled_dataset/day4.csv\", \"/content/drive/MyDrive/AdressaProcessed/day4.csv\")\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/pickled_dataset/day5.csv\", \"/content/drive/MyDrive/AdressaProcessed/day5.csv\")\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/pickled_dataset/day6.csv\", \"/content/drive/MyDrive/AdressaProcessed/day6.csv\")\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/pickled_dataset/day7.csv\", \"/content/drive/MyDrive/AdressaProcessed/day7.csv\")\n",
        "\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nStage completed in {str(round(t2-t1, 2))} seconds\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "30RHOSN7na6V"
      },
      "source": [
        "##1.3 Read preprocess Adressa dataset\n",
        "\n",
        "*Remark: This block doesn't necessarily require the execution of blocks 1.1, 1.2 and their sub-blocks since the preprocessed datasets have already been stored on Google Drive*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I0-FgY-UsJQZ"
      },
      "source": [
        "1.3.1 Load the desired input\n",
        "\n",
        "Can load one of the seven daily files or the week file (latter to be used for final model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-laijz6ezS1r"
      },
      "outputs": [],
      "source": [
        "t1 = time()\n",
        "\n",
        "SELECTED_INPUT = 'week.csv'         # select the needed input file\n",
        "VERBOSE = True                      # to print additional information\n",
        "\n",
        "if SELECTED_INPUT not in ['week.csv', 'day1.csv', 'day2.csv', 'day3csv', 'day4.csv', 'day5.csv', 'day6.csv', 'day7.csv']:\n",
        "  exit(-1)\n",
        "\n",
        "inputFolder = '/content/KRED-Reccomendation-System/data/AdressaProcessed/'  # use this copy in local disk, never modify version in Drive folder\n",
        "inputPath = inputFolder + SELECTED_INPUT                                    # e.g. /content/KRED-Reccomendation-System/data/AdressaProcessed/day1.csv\n",
        "\n",
        "inputDf = pd.read_csv(inputPath, index_col=False)\n",
        "print(f'Loaded file: {SELECTED_INPUT}')\n",
        "if VERBOSE:\n",
        "  print(f\"Dataframe length: {len(inputDf)} rows\")\n",
        "  print(f\"Dataframe size: {str(round(getsizeof(inputDf) /1024 /1024,2))} MB\\n\")\n",
        "  print(inputDf.info())\n",
        "  # print(inputDf[0:10])\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nStage completed in {str(round(t2-t1, 2))} seconds\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IcTxFvnNtWR-"
      },
      "source": [
        "1.3.2 Work towards behaviours.tsv format\n",
        "- compute mean & standard deviation of reading time (for each user)\n",
        "- classify each entry as element to be put into positive or negative list\n",
        "- build dataset structured as behaviours.tsv"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o6oofZhNtVlK"
      },
      "outputs": [],
      "source": [
        "# Build the columns of mean active time for each user\n",
        "# --> obtain: userDf\n",
        "t1 = time()\n",
        "\n",
        "VERBOSE = True\n",
        "\n",
        "userTimeDf = inputDf.groupby(['userId'])[\"activeTime\"].aggregate(['min', 'max', 'median', 'mean', 'std'])     # for each userId obtain mean & std dev of activeTime (+ other aggregations useful for data exploration)\n",
        "userTimeDf.rename(columns = {'mean':'userMeanActiveTime', 'std':'userStdDevActiveTime'}, inplace = True)      # rename useful columns\n",
        "userTimeDf = userTimeDf[['userMeanActiveTime', 'userStdDevActiveTime']]                                       # select columns for the join (userId isn't a column, but the index of the table)\n",
        "\n",
        "userDf = inputDf.join(userTimeDf, on='userId', validate='m:1')                                                # left-join over userId, validate n:1 multiplicity of key attributes\n",
        "\n",
        "if VERBOSE:\n",
        "  print(userTimeDf.info())\n",
        "  print(userDf.info())\n",
        "\n",
        "del userTimeDf                                                                  # free memory\n",
        "gc.collect()                                                                    # free memory\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nStage completed in {str(round(t2-t1, 2))} seconds\\n\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kEzpXxCKRXMf"
      },
      "outputs": [],
      "source": [
        "\"\"\"\n",
        "1. Filter out useless attributes\n",
        "2. Filter out users whose activeTime is always NaN --> not informative (do not allow computation of userMeanActiveTime)\n",
        "3. Set all remaining NaN activeTimes to -1 (this tell us that the user immediately closed the page, in less than a second)\n",
        "4. Classify each row as element for a Positive List or Negative List\n",
        "6. Build positive & negative lists and drop users with empty lists\n",
        "7. Build a new datadrame with same schema of behaviors.tsv and save it\n",
        "\"\"\"\n",
        "\n",
        "t1 = time()\n",
        "\n",
        "VERBOSE = True\n",
        "DOUBLE_BOUNDARY = True\n",
        "\n",
        "# 1. FILTER OUT USELESS ATTRIBUTES\n",
        "#   Select only the columns needed by behaviours.tsv\n",
        "#   ---> obtain: behaviorDf1\n",
        "\n",
        "print(\"\\n1. Projecting on columns subset\")\n",
        "attributes = ['userId', 'time', 'url', 'activeTime', 'userMeanActiveTime', 'userStdDevActiveTime']\n",
        "behaviorDf1 = userDf[attributes]\n",
        "if VERBOSE:\n",
        "  print(\"\\n\\n=============== STEP 1 ===============\\n\")\n",
        "  print(behaviorDf1.info())\n",
        "\n",
        "\n",
        "# 2. FILTER OUT NON-INFORMATIVE USERS\n",
        "#   Keep only a subset of rows where the users have at least one activeTime not NaN (i.e. discard users for which can't compute mean active time)\n",
        "#   ---> obtain: behaviorDf2\n",
        "\n",
        "print(\"\\n2. Removing users without at least 1 activeTime!=NaN\")\n",
        "behaviorDf2 = behaviorDf1[behaviorDf1['userMeanActiveTime'].notna()]   # filter out users whose activeTime = NaN for all rows\n",
        "behaviorDf2 = behaviorDf2[behaviorDf2['userStdDevActiveTime'].notna()]   # filter out users whose activeTime = NaN for all rows\n",
        "if VERBOSE:\n",
        "  print(\"\\n\\n=============== STEP 2 ===============\\n\")\n",
        "  print(f'Dropped {len(behaviorDf1)-len(behaviorDf2)} rows of the initial {len(behaviorDf1)}')\n",
        "  print(behaviorDf2.info())\n",
        "\n",
        "\n",
        "# 3. FILL \"MISSING\" DATA\n",
        "#   Whenever activeTime = NaN it means that activeTime < 1second therefore it can still be treated as a low active time and flagged with a -1 to make it numerical\n",
        "#   ---> obtain: behaviorsDf3\n",
        "#   should this approach have negative impact on the performances they can still be dropped instead (since are flagged with a unique value)\n",
        "print(\"\\n3. Filling remaining NaN activeTime with -1\")\n",
        "behaviorDf3 = behaviorDf2\n",
        "behaviorDf3['activeTime'] = behaviorDf3['activeTime'].fillna(-1)\n",
        "# behaviorDf3 = behaviorDf3[behaviorDf3['activeTime'].notna()]           # use this row instead to drop rows with -1\n",
        "if VERBOSE:\n",
        "  print(\"\\n\\n=============== STEP 3 ===============\\n\")\n",
        "  filled = len(behaviorDf3[behaviorDf3['activeTime']==-1])\n",
        "  print(f'Filled {filled} rows of the {len(behaviorDf3)} total rows')\n",
        "  print(behaviorDf3.info())\n",
        "\n",
        "\n",
        "# 4. CLASSIFY EACH ROW (i.e. each clicked news by each user) AS POSITIVE/NEGATIVE LIST ELEMENT\n",
        "#   If activeTime <  meanUserActiveTime - 1 * userStdDevActiveTime --> Negative List\n",
        "#   If activeTime >= meanUserActiveTime - 1 * userStdDevActiveTime --> Negative List\n",
        "#   alternatively use a range: positive if inside range [mean - stdDev ; mean + stdDev] & negative otherwise\n",
        "#   ---> obtain: behaviorDf4\n",
        "\n",
        "print(\"\\n4. Classifying clicks\")\n",
        "behaviorDf4 = behaviorDf3\n",
        "\n",
        "if DOUBLE_BOUNDARY:\n",
        "  behaviorDf4['condition1'] = (behaviorDf4['activeTime'] >= (behaviorDf4['userMeanActiveTime'] - behaviorDf4['userStdDevActiveTime']))\n",
        "  behaviorDf4['condition2'] = (behaviorDf4['activeTime'] <= (behaviorDf4['userMeanActiveTime'] + behaviorDf4['userStdDevActiveTime']))\n",
        "  behaviorDf4['positiveElement'] = (behaviorDf4['condition1'] == behaviorDf4['condition2'])\n",
        "else:\n",
        "  behaviorDf4['positiveElement'] = (behaviorDf4['activeTime'] >= (behaviorDf4['userMeanActiveTime'] - behaviorDf4['userStdDevActiveTime']))\n",
        "attrib = ['userId', 'time', 'url', 'positiveElement']\n",
        "behaviorDf4 = behaviorDf4[attrib]\n",
        "\n",
        "\n",
        "\n",
        "#   (DEPRECATED approach below)\n",
        "#   Add two columns with satisfaction indices as satisfactionIndexMean   = activeTime / userMeanActiveTime\n",
        "#                                                satisfactionIndexMedian = activeTime / userMedianActiveTime\n",
        "#   Normalize these indices in range [0,1] to make them comparable with each other --> not necessary since it's just used for ordering\n",
        "# behaviorDf4['satisfactionIndexMean']   = userDf['activeTime'] / userDf['userMeanActiveTime']      # compute a statistic based on the mean active time of each user\n",
        "# Indices normalization\n",
        "# minSatisfactionIndexMean = behaviorDf4['satisfactionIndexMean'].min()\n",
        "# maxSatisfactionIndexMean = behaviorDf4['satisfactionIndexMean'].max()\n",
        "# behaviorDf4['satisfactionIndexMeanNormalized'] = (behaviorDf4['satisfactionIndexMean'] - minSatisfactionIndexMean) / (maxSatisfactionIndexMean - minSatisfactionIndexMean)\n",
        "\n",
        "\n",
        "if VERBOSE:\n",
        "  print(\"\\n\\n=============== STEP 4 ===============\\n\")\n",
        "  posCount = len( behaviorDf4[behaviorDf4['positiveElement'] == True] )\n",
        "  negCount = len( behaviorDf4[behaviorDf4['positiveElement'] == False] )\n",
        "  print(f'{posCount} rows classified as positive clicks ({str(round(posCount/len(behaviorDf4)*100, 2))}%)')\n",
        "  print(f'{negCount} rows classified as negative clicks ({str(round(negCount/len(behaviorDf4)*100, 2))}%)')\n",
        "  print(behaviorDf4.info())\n",
        "\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nStage completed in {str(round(t2-t1, 2))} seconds\\n\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RcQwU-YHZJeN"
      },
      "outputs": [],
      "source": [
        "t1 = time()\n",
        "\n",
        "\n",
        "updateFreq = 500\n",
        "GC_FREQ = 1000\n",
        "VERBOSE = True\n",
        "\n",
        "\n",
        "behaviorDf5 = pd.DataFrame(columns=['userId', 'timestamp', 'positiveList', 'negativeList'])         # final dataframe initialization\n",
        "\n",
        "uniqueUsersDf = behaviorDf4['userId'].unique()                                                      # list of unique userIds\n",
        "amountOfUsers = len(uniqueUsersDf)                                                                  # count of unique userIds\n",
        "totRowsProcessed = 0                             # count how many rows from behaviorDf4 have been processed\n",
        "inputRowsKept = 0                                # count how many rows from behaviorDf4 have been kept and condensed into pos/neg lists\n",
        "totRows = len(behaviorDf4)                       # tot rows to be processed from behaviorDf4\n",
        "progress = 0                                     # track progress of behaviorDf5 creation (row by row) --> i.e. how many users have been processed and kept\n",
        "usersDropped = 0                                 # count how many users dropped due to empty lists\n",
        "\n",
        "\n",
        "print(f'(printing updates every: {updateFreq} users - tot users: {amountOfUsers})\\n')\n",
        "\n",
        "for usr in uniqueUsersDf:                                                                           # for each user\n",
        "  if (progress+usersDropped) % updateFreq == 0:                                                     # print every X users processed (to not impact on performances)\n",
        "    print(f\"\\rProcessing: {str(round((progress+usersDropped)/amountOfUsers*100, 2))}% - Elapsed time: {str(round(time()-t1, 2))}s\",end='')\n",
        "  userClicksDf = behaviorDf4[behaviorDf4['userId'] == usr]                                          # get the user's clicks\n",
        "  tstamp = (userClicksDf.sort_values(by=['time'], ascending=True).head(1)).iloc[0]['time']          # get the earlier timestamp of that user's clicks\n",
        "\n",
        "  positiveClicks = (userClicksDf[userClicksDf['positiveElement'] == True])['url'].unique().tolist() # get positive list\n",
        "  negativeClicks = (userClicksDf[userClicksDf['positiveElement'] == False])['url'].unique().tolist()# get negative list\n",
        "  commonElements = set(positiveClicks).intersection(negativeClicks)                                 # check if the lists have elements in common\n",
        "  if len(commonElements) > 0:                                                                       # if they have, remove them from the longer list\n",
        "    for elem in commonElements:\n",
        "      if len(negativeClicks) >= len(positiveClicks):\n",
        "        negativeClicks.remove(elem)\n",
        "      else:\n",
        "        positiveClicks.remove(elem)\n",
        "  commonElements = set(positiveClicks).intersection(negativeClicks)                                 # double check if some common elements still exist (redundandt)\n",
        "  if len(commonElements) > 0:\n",
        "    print(f\"\\nWARNING: overlapping positive & negative lists at row {progress}\")\n",
        "    print(commonElements)\n",
        "\n",
        "  totRowsProcessed += len(userClicksDf)                                                             # keep track of how many rows have been read from input\n",
        "\n",
        "  if len(positiveClicks) == 0 or len(negativeClicks) == 0:                                          # if at least a list is empty --> discard user\n",
        "    usersDropped += 1\n",
        "  else:                                                                                             # else add new row and increase counter progress\n",
        "    behaviorDf5.loc[progress] = [usr, tstamp, positiveClicks, negativeClicks]\n",
        "    inputRowsKept += len(positiveClicks)                                                            # keep count of how many clicks have been kept\n",
        "    inputRowsKept += len(negativeClicks)\n",
        "    progress += 1\n",
        "\n",
        "  del positiveClicks                                                                                # delete all temporary dfs\n",
        "  del negativeClicks\n",
        "  del userClicksDf\n",
        "  del commonElements\n",
        "  if (progress+usersDropped) % GC_FREQ == 0:\n",
        "    gc.collect()                                                                                    # free memory every X users\n",
        "\n",
        "print(f\"\\rProcessing: {str(round((progress+usersDropped)/amountOfUsers*100, 2))}%\")\n",
        "\n",
        "print(f'Tot input rows processed: {totRowsProcessed} wrt to total input rows: {len(behaviorDf4)}')\n",
        "print(f'Dropped input rows: {totRowsProcessed-inputRowsKept} (due to empty lists)')\n",
        "print(f'Users dropped: {usersDropped} wrt to processed users: {usersDropped+progress}(due to empty lists)')\n",
        "\n",
        "\n",
        "\n",
        "# SAVE ON DISK & ON MOUNTED DRIVE:\n",
        "\n",
        "DELETE = False                                                # cleanup dataframe at the end?\n",
        "\n",
        "outputFileName = SELECTED_INPUT                               # usually \"day1.csv\" or \"week.csv\"\n",
        "outputFolder = '/content/KRED-Reccomendation-System/data/AdressaProcessed/'\n",
        "outputPath = outputFolder + 'behavior-' + outputFileName      # '/content/KRED-Reccomendation-System/data/AdressaProcessed/behavior-day1.csv'\n",
        "print(f'\\nSaving final dataset as: {outputPath}')\n",
        "behaviorDf5.to_csv(outputPath, index = True)\n",
        "\n",
        "if DELETE:                                                    # cleanup\n",
        "  print('\\n Deleting final dataframe')\n",
        "  behaviorDf5.clear()\n",
        "  del(behaviorDf5)\n",
        "  gc.collect()\n",
        "\n",
        "# save on drive --> i.e. copy files in drive folder\n",
        "mountedDriveOutputPath = \"/content/drive/MyDrive/AdressaProcessed/\"+'behavior-' + outputFileName\n",
        "print(f'Copying final dataset into mounted Drive at: {mountedDriveOutputPath}')\n",
        "shutil.copy(outputPath, mountedDriveOutputPath)\n",
        "\n",
        "if VERBOSE:\n",
        "  print(behaviorDf5)\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nStage completed in {str(round(t2-t1, 2))} seconds\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WIesnGceSWYw"
      },
      "source": [
        "1.3.2.1  Build final weekly dataset *behavior-week.tsv*\n",
        "\n",
        "- Read the 7 daily behavior files: behavior-day1.csv, behavior-day2.csv, ...\n",
        "- Reshape the columns properly (there was an error in the formatting of history and positive/negative lists)\n",
        "- Concatenate the 7 files into one single file"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yhNm22vWRseO",
        "outputId": "e08b7d96-ab50-428e-8940-fadb58755d9d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Loaded file: behavior-day1.csv\n",
            "Loaded file: behavior-day2.csv\n",
            "Loaded file: behavior-day3.csv\n",
            "Loaded file: behavior-day4.csv\n",
            "Loaded file: behavior-day5.csv\n",
            "Loaded file: behavior-day6.csv\n",
            "Loaded file: behavior-day7.csv\n",
            "The 7 input dataframes have been loaded correctly\n",
            "\n",
            "Stage completed in 9.06 seconds\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# LOAD THE DAILY FULLY PROCESSED DATAFRAMES\n",
        "t1 = time()\n",
        "\n",
        "SELECTED_INPUTS = ['behavior-day1.csv', 'behavior-day2.csv', 'behavior-day3.csv', 'behavior-day4.csv', 'behavior-day5.csv', 'behavior-day6.csv', 'behavior-day7.csv']\n",
        "VERBOSE = False                                                                 # to print additional information\n",
        "\n",
        "inputFolder = '/content/KRED-Reccomendation-System/data/AdressaProcessed/'      # source folder\n",
        "\n",
        "dfsToReshape = list()                                                           # list where input DFs will be stored\n",
        "counter = 0\n",
        "for i in SELECTED_INPUTS:\n",
        " inputPath = inputFolder + i                                                    # e.g. /content/KRED-Reccomendation-System/data/AdressaProcessed/behavior-day1.csv\n",
        " dfsToReshape.append(pd.read_csv(inputPath, index_col=False))                   # read all daily behaviors and add them to the list\n",
        " print(f'Loaded file: {SELECTED_INPUTS[counter]}')\n",
        " if VERBOSE:\n",
        "    print(f\"Dataframe length: {len(dfsToReshape[counter])} rows\")\n",
        "    print(f\"Dataframe size: {str(round(getsizeof(dfsToReshape[counter]) /1024 /1024,2))} MB\\n\")\n",
        "    print(dfsToReshape[counter].info())\n",
        " counter += 1\n",
        "\n",
        "print(f\"The {len(dfsToReshape)} input dataframes have been loaded correctly\")\n",
        "if VERBOSE:\n",
        " print(dfsToReshape)\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nStage completed in {str(round(t2-t1, 2))} seconds\\n\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "32XAJZnoVwXH",
        "outputId": "4345b0a7-6e91-4b94-e0f0-2a2d4b0693cf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "Completed processing of day 1 behaviors\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 101726 entries, 0 to 101725\n",
            "Data columns (total 4 columns):\n",
            " #   Column                    Non-Null Count   Dtype \n",
            "---  ------                    --------------   ----- \n",
            " 0   userId                    101726 non-null  object\n",
            " 1   timestamp                 101726 non-null  int64 \n",
            " 2   userHistory               101726 non-null  object\n",
            " 3   positiveAndNegativeLists  101726 non-null  object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 3.1+ MB\n",
            "None\n",
            "\n",
            "\n",
            "Completed processing of day 2 behaviors\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 111067 entries, 0 to 111066\n",
            "Data columns (total 4 columns):\n",
            " #   Column                    Non-Null Count   Dtype \n",
            "---  ------                    --------------   ----- \n",
            " 0   userId                    111067 non-null  object\n",
            " 1   timestamp                 111067 non-null  int64 \n",
            " 2   userHistory               111067 non-null  object\n",
            " 3   positiveAndNegativeLists  111067 non-null  object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 3.4+ MB\n",
            "None\n",
            "\n",
            "\n",
            "Completed processing of day 3 behaviors\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 76951 entries, 0 to 76950\n",
            "Data columns (total 4 columns):\n",
            " #   Column                    Non-Null Count  Dtype \n",
            "---  ------                    --------------  ----- \n",
            " 0   userId                    76951 non-null  object\n",
            " 1   timestamp                 76951 non-null  int64 \n",
            " 2   userHistory               76951 non-null  object\n",
            " 3   positiveAndNegativeLists  76951 non-null  object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 2.3+ MB\n",
            "None\n",
            "\n",
            "\n",
            "Completed processing of day 4 behaviors\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 105377 entries, 0 to 105376\n",
            "Data columns (total 4 columns):\n",
            " #   Column                    Non-Null Count   Dtype \n",
            "---  ------                    --------------   ----- \n",
            " 0   userId                    105377 non-null  object\n",
            " 1   timestamp                 105377 non-null  int64 \n",
            " 2   userHistory               105377 non-null  object\n",
            " 3   positiveAndNegativeLists  105377 non-null  object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 3.2+ MB\n",
            "None\n",
            "\n",
            "\n",
            "Completed processing of day 5 behaviors\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 96323 entries, 0 to 96322\n",
            "Data columns (total 4 columns):\n",
            " #   Column                    Non-Null Count  Dtype \n",
            "---  ------                    --------------  ----- \n",
            " 0   userId                    96323 non-null  object\n",
            " 1   timestamp                 96323 non-null  int64 \n",
            " 2   userHistory               96323 non-null  object\n",
            " 3   positiveAndNegativeLists  96323 non-null  object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 2.9+ MB\n",
            "None\n",
            "\n",
            "\n",
            "Completed processing of day 6 behaviors\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 114010 entries, 0 to 114009\n",
            "Data columns (total 4 columns):\n",
            " #   Column                    Non-Null Count   Dtype \n",
            "---  ------                    --------------   ----- \n",
            " 0   userId                    114010 non-null  object\n",
            " 1   timestamp                 114010 non-null  int64 \n",
            " 2   userHistory               114010 non-null  object\n",
            " 3   positiveAndNegativeLists  114010 non-null  object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 3.5+ MB\n",
            "None\n",
            "\n",
            "\n",
            "Completed processing of day 7 behaviors\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 98531 entries, 0 to 98530\n",
            "Data columns (total 4 columns):\n",
            " #   Column                    Non-Null Count  Dtype \n",
            "---  ------                    --------------  ----- \n",
            " 0   userId                    98531 non-null  object\n",
            " 1   timestamp                 98531 non-null  int64 \n",
            " 2   userHistory               98531 non-null  object\n",
            " 3   positiveAndNegativeLists  98531 non-null  object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 3.0+ MB\n",
            "None\n",
            "\n",
            "Stage completed in 77.8 seconds\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# RESHAPE THE COLUMNS PROPERLY\n",
        "t1 = time()\n",
        "\n",
        "reshapedDfs = list()                                                            # list to store the final version of the daily behavior dataframes\n",
        "counter = 0\n",
        "\n",
        "for df in dfsToReshape:                                                         # for each daily behavior DF\n",
        "\n",
        "  newDf = df.copy(deep=True)                                                    # make a true copy, not just a link\n",
        "  newDf['newPositiveList'] = ''                                                 # add two new columns\n",
        "  newDf['newPosNegList'] = ''\n",
        "  for index, row in newDf.iterrows():                                                                                           # process it row by row\n",
        "    newPosListCol = row['positiveList'].replace(\"'\", \"\").replace(\"[\", \"\").replace(\"]\", \"\").replace(\",\", \"\")                     # create a userHistory column from the previous positiveList (it's an approximation)\n",
        "    oldPosList = row['positiveList'].replace(\"'\", \"\").replace(\"[\", \"\").replace(\"]\", \"-1\").replace(\",\", \"\").replace(\" \", \"-1 \")  # append a -1 to all the elements of the positive list (as if they were indeed clicked in KRED)\n",
        "    oldNegList = row['negativeList'].replace(\"'\", \"\").replace(\"[\", \"\").replace(\"]\", \"-0\").replace(\",\", \"\").replace(\" \", \"-0 \")  # append a -0 to all the elements of the negative list (as if they were NOT clicked in KRED)\n",
        "    newPosNegListCol = oldPosList + ' ' + oldNegList                                                                            # build one final list of positive and negative elements as required by KRED in input\n",
        "    newDf.at[index, 'newPositiveList'] = newPosListCol                                                                          # store obtained results in the new columns\n",
        "    newDf.at[index, 'newPosNegList'] = newPosNegListCol\n",
        "\n",
        "  columnsToKeep = ['userId', 'timestamp', 'newPositiveList', 'newPosNegList']                                                   # project on the needed columns only\n",
        "  newDf = newDf[columnsToKeep]\n",
        "  newDf = newDf.rename(columns={'newPositiveList': 'userHistory', 'newPosNegList': 'positiveAndNegativeLists'})                 # give meaningful names\n",
        "\n",
        "  counter += 1\n",
        "  print(f\"\\n\\nCompleted processing of day {counter} behaviors\")\n",
        "  print(newDf.info())\n",
        "\n",
        "\n",
        "  reshapedDfs.append(newDf)                                                                                                     # store the final version of the daily behavior DF\n",
        "\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nStage completed in {str(round(t2-t1, 2))} seconds\\n\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "scs0kCOS8iXk",
        "outputId": "6ecac6eb-429a-471b-da7d-f12ec2eefefc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Int64Index: 703985 entries, 0 to 98530\n",
            "Data columns (total 5 columns):\n",
            " #   Column                    Non-Null Count   Dtype \n",
            "---  ------                    --------------   ----- \n",
            " 0   index                     703985 non-null  int64 \n",
            " 1   userId                    703985 non-null  object\n",
            " 2   timestamp                 703985 non-null  int64 \n",
            " 3   userHistory               703985 non-null  object\n",
            " 4   positiveAndNegativeLists  703985 non-null  object\n",
            "dtypes: int64(2), object(3)\n",
            "memory usage: 32.2+ MB\n",
            "None\n",
            "       index                                       userId   timestamp  \\\n",
            "0          1            cx:hwwz74npvfpbeb6t:3r8a34vl30pzx  1483258706   \n",
            "1          2   cx:35qzmnop24aabdict6ce06jeu:3oh8amzr1ymie  1483235637   \n",
            "2          3   cx:g5w8dqvwmphi3312fz77s1cnu:1lphshweqrtpp  1483268001   \n",
            "3          4   cx:2wdlftbi226e93j6ubrrr9ywlk:xi3bokxgktuc  1483231519   \n",
            "4          5   cx:1tsqelygc061ozuetu9i0pkny:2ko62cresl3dx  1483278506   \n",
            "...      ...                                          ...         ...   \n",
            "98526  98527  cx:2k8lgs1vgl9xz1a6kr7rjx7kjy:2n79xb1k1lwjf  1483743465   \n",
            "98527  98528   cx:3v8gihnk10reauqe9k0y0txe9:2ka2lazfrqc0q  1483743471   \n",
            "98528  98529  cx:18c0bo93pwom21dssre7v527ba:2h8mqy93ylyei  1483743473   \n",
            "98529  98530             cx:hvl65l18rxqbg0p9:999mgd3b8ile  1483743504   \n",
            "98530  98531             cx:i6vg2muycor2g7tb:wqowc9878gun  1483743516   \n",
            "\n",
            "                                             userHistory  \\\n",
            "0      http://adressa.no/nyheter/trondheim/2016/12/29...   \n",
            "1                                      http://adressa.no   \n",
            "2      http://adressa.no http://adressa.no/folk/doeds...   \n",
            "3      http://adressa.no http://adressa.no/nyheter/so...   \n",
            "4                                      http://adressa.no   \n",
            "...                                                  ...   \n",
            "98526  http://adressa.no/nyheter/sortrondelag/2017/01...   \n",
            "98527  http://adressa.no/nyheter/sortrondelag/2017/01...   \n",
            "98528  http://adressa.no http://adressa.no/nyheter/so...   \n",
            "98529  http://adressa.no/nyheter/okonomi/2017/01/06/f...   \n",
            "98530  http://adressa.no/100sport/vintersport/dette-e...   \n",
            "\n",
            "                                positiveAndNegativeLists  \n",
            "0      http://adressa.no/nyheter/trondheim/2016/12/29...  \n",
            "1      http://adressa.no-1 http://adressa.no/nyheter/...  \n",
            "2      http://adressa.no-1 http://adressa.no/folk/doe...  \n",
            "3      http://adressa.no-1 http://adressa.no/nyheter/...  \n",
            "4      http://adressa.no-1 http://adressa.no/nyheter/...  \n",
            "...                                                  ...  \n",
            "98526  http://adressa.no/nyheter/sortrondelag/2017/01...  \n",
            "98527  http://adressa.no/nyheter/sortrondelag/2017/01...  \n",
            "98528  http://adressa.no-1 http://adressa.no/nyheter/...  \n",
            "98529  http://adressa.no/nyheter/okonomi/2017/01/06/f...  \n",
            "98530  http://adressa.no/100sport/vintersport/dette-e...  \n",
            "\n",
            "[703985 rows x 5 columns]\n",
            "Saving final dataset as: /content/KRED-Reccomendation-System/data/AdressaProcessed/behavior-week.tsv\n",
            "Saving backup on mounted Drive: /content/drive/MyDrive/AdressaProcessed/behavior-week.tsv\n",
            "\n",
            "Stage completed in 22.89 seconds\n",
            "\n"
          ]
        }
      ],
      "source": [
        "t1 = time()\n",
        "# CONCATENATE DAYS AND SAVE\n",
        "behaviorWeek = pd.concat(reshapedDfs)                                                                       # build weekly behavior DF by concatenation\n",
        "behaviorWeek['index'] = behaviorWeek.index + 1                                                              # build the index column (needed to match KRED input schema)\n",
        "behaviorWeek = behaviorWeek[['index', 'userId', 'timestamp', 'userHistory', 'positiveAndNegativeLists']]\n",
        "\n",
        "outputFileName = \"behavior-week.tsv\"                                                                        # Save weekly df on disk\n",
        "outputPath = \"/content/KRED-Reccomendation-System/data/AdressaProcessed/\" + outputFileName\n",
        "print(f'Saving final dataset as: {outputPath}')\n",
        "if not os.path.exists(\"/content/KRED-Reccomendation-System/data/AdressaProcessed/\"):                        # create directory to store data if doesnt exists\n",
        "  os.makedirs(\"/content/KRED-Reccomendation-System/data/AdressaProcessed/\")\n",
        "\n",
        "behaviorWeek.to_csv(outputPath, sep=\"\\t\", index = False, header = False)                                    # save as .tsv (tab separated values)\n",
        "\n",
        "# save on drive --> i.e. copy files in drive folder\n",
        "print(f'Saving backup on mounted Drive: /content/drive/MyDrive/AdressaProcessed/behavior-week.tsv')         # save backup on Google Drive\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/AdressaProcessed/behavior-week.tsv\", \"/content/drive/MyDrive/AdressaProcessed/behavior-week.tsv\")\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nStage completed in {str(round(t2-t1, 2))} seconds\\n\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "azhrA-r9I6Sb",
        "outputId": "6aff507c-f0f5-44ae-c848-4fa42b092ecc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "            0                                            1           2  \\\n",
            "0           1            cx:hwwz74npvfpbeb6t:3r8a34vl30pzx  1483258706   \n",
            "1           2   cx:35qzmnop24aabdict6ce06jeu:3oh8amzr1ymie  1483235637   \n",
            "2           3   cx:g5w8dqvwmphi3312fz77s1cnu:1lphshweqrtpp  1483268001   \n",
            "3           4   cx:2wdlftbi226e93j6ubrrr9ywlk:xi3bokxgktuc  1483231519   \n",
            "4           5   cx:1tsqelygc061ozuetu9i0pkny:2ko62cresl3dx  1483278506   \n",
            "...       ...                                          ...         ...   \n",
            "703980  98527  cx:2k8lgs1vgl9xz1a6kr7rjx7kjy:2n79xb1k1lwjf  1483743465   \n",
            "703981  98528   cx:3v8gihnk10reauqe9k0y0txe9:2ka2lazfrqc0q  1483743471   \n",
            "703982  98529  cx:18c0bo93pwom21dssre7v527ba:2h8mqy93ylyei  1483743473   \n",
            "703983  98530             cx:hvl65l18rxqbg0p9:999mgd3b8ile  1483743504   \n",
            "703984  98531             cx:i6vg2muycor2g7tb:wqowc9878gun  1483743516   \n",
            "\n",
            "                                                        3  \\\n",
            "0       http://adressa.no/nyheter/trondheim/2016/12/29...   \n",
            "1                                       http://adressa.no   \n",
            "2       http://adressa.no http://adressa.no/folk/doeds...   \n",
            "3       http://adressa.no http://adressa.no/nyheter/so...   \n",
            "4                                       http://adressa.no   \n",
            "...                                                   ...   \n",
            "703980  http://adressa.no/nyheter/sortrondelag/2017/01...   \n",
            "703981  http://adressa.no/nyheter/sortrondelag/2017/01...   \n",
            "703982  http://adressa.no http://adressa.no/nyheter/so...   \n",
            "703983  http://adressa.no/nyheter/okonomi/2017/01/06/f...   \n",
            "703984  http://adressa.no/100sport/vintersport/dette-e...   \n",
            "\n",
            "                                                        4  \n",
            "0       http://adressa.no/nyheter/trondheim/2016/12/29...  \n",
            "1       http://adressa.no-1 http://adressa.no/nyheter/...  \n",
            "2       http://adressa.no-1 http://adressa.no/folk/doe...  \n",
            "3       http://adressa.no-1 http://adressa.no/nyheter/...  \n",
            "4       http://adressa.no-1 http://adressa.no/nyheter/...  \n",
            "...                                                   ...  \n",
            "703980  http://adressa.no/nyheter/sortrondelag/2017/01...  \n",
            "703981  http://adressa.no/nyheter/sortrondelag/2017/01...  \n",
            "703982  http://adressa.no-1 http://adressa.no/nyheter/...  \n",
            "703983  http://adressa.no/nyheter/okonomi/2017/01/06/f...  \n",
            "703984  http://adressa.no/100sport/vintersport/dette-e...  \n",
            "\n",
            "[703985 rows x 5 columns]\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 703985 entries, 0 to 703984\n",
            "Data columns (total 5 columns):\n",
            " #   Column  Non-Null Count   Dtype \n",
            "---  ------  --------------   ----- \n",
            " 0   0       703985 non-null  int64 \n",
            " 1   1       703985 non-null  object\n",
            " 2   2       703985 non-null  int64 \n",
            " 3   3       703985 non-null  object\n",
            " 4   4       703985 non-null  object\n",
            "dtypes: int64(2), object(3)\n",
            "memory usage: 26.9+ MB\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "# CHECKING FINAL RESULT\n",
        "inputFolder = '/content/KRED-Reccomendation-System/data/AdressaProcessed/'\n",
        "inputPath = inputFolder + 'behavior-week.tsv'\n",
        "df = pd.read_csv(inputPath, header = None, sep='\\t')\n",
        "print(df)\n",
        "print(df.info())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lURklo3NIIR7",
        "outputId": "fad3607f-694a-4901-9470-8aa8e10f53b0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "281521\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 10043269 entries, 0 to 10043268\n",
            "Data columns (total 11 columns):\n",
            " #   Column        Dtype  \n",
            "---  ------        -----  \n",
            " 0   eventId       int64  \n",
            " 1   time          int64  \n",
            " 2   userId        object \n",
            " 3   url           object \n",
            " 4   profile       object \n",
            " 5   category      object \n",
            " 6   keywords      object \n",
            " 7   title         object \n",
            " 8   activeTime    float64\n",
            " 9   sessionStart  bool   \n",
            " 10  sessionStop   bool   \n",
            "dtypes: bool(2), float64(1), int64(2), object(6)\n",
            "memory usage: 708.8+ MB\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "# GET STATISTICS\n",
        "uniqueUsers = df[1].unique()\n",
        "print(len(uniqueUsers))\n",
        "\n",
        "inputPath = '/content/KRED-Reccomendation-System/data/AdressaProcessed/week.csv'\n",
        "inputDf = pd.read_csv(inputPath, index_col=False)\n",
        "print(inputDf.info())\n",
        "\n",
        "uniqueURLs = inputDf['url'].unique()\n",
        "print(len(uniqueURLs))\n",
        "print(inputDf.shape[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d0Lkv5CYEhkH",
        "outputId": "19fe6334-099b-47e3-a290-8933f604ed9e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Progress: 0/703985\n",
            "Progress: 1000/703985\n",
            "Progress: 2000/703985\n",
            "Progress: 3000/703985\n",
            "Progress: 4000/703985\n",
            "Progress: 5000/703985\n",
            "Progress: 6000/703985\n",
            "Progress: 7000/703985\n",
            "Progress: 8000/703985\n",
            "Progress: 9000/703985\n",
            "Progress: 10000/703985\n",
            "Progress: 11000/703985\n",
            "Progress: 12000/703985\n",
            "Progress: 13000/703985\n",
            "Progress: 14000/703985\n",
            "Progress: 15000/703985\n",
            "Progress: 16000/703985\n",
            "Progress: 17000/703985\n",
            "Progress: 18000/703985\n",
            "Progress: 19000/703985\n",
            "Progress: 20000/703985\n",
            "Progress: 21000/703985\n",
            "Progress: 22000/703985\n",
            "Progress: 23000/703985\n",
            "Progress: 24000/703985\n",
            "Progress: 25000/703985\n",
            "Progress: 26000/703985\n",
            "Progress: 27000/703985\n",
            "Progress: 28000/703985\n",
            "Progress: 29000/703985\n",
            "Progress: 30000/703985\n",
            "Progress: 31000/703985\n",
            "Progress: 32000/703985\n",
            "Progress: 33000/703985\n",
            "Progress: 34000/703985\n",
            "Progress: 35000/703985\n",
            "Progress: 36000/703985\n",
            "Progress: 37000/703985\n",
            "Progress: 38000/703985\n",
            "Progress: 39000/703985\n",
            "Progress: 40000/703985\n",
            "Progress: 41000/703985\n",
            "Progress: 42000/703985\n",
            "Progress: 43000/703985\n",
            "Progress: 44000/703985\n",
            "Progress: 45000/703985\n",
            "Progress: 46000/703985\n",
            "Progress: 47000/703985\n",
            "Progress: 48000/703985\n",
            "Progress: 49000/703985\n",
            "Progress: 50000/703985\n",
            "Progress: 51000/703985\n",
            "Progress: 52000/703985\n",
            "Progress: 53000/703985\n",
            "Progress: 54000/703985\n",
            "Progress: 55000/703985\n",
            "Progress: 56000/703985\n",
            "Progress: 57000/703985\n",
            "Progress: 58000/703985\n",
            "Progress: 59000/703985\n",
            "Progress: 60000/703985\n",
            "Progress: 61000/703985\n",
            "Progress: 62000/703985\n",
            "Progress: 63000/703985\n",
            "Progress: 64000/703985\n",
            "Progress: 65000/703985\n",
            "Progress: 66000/703985\n",
            "Progress: 67000/703985\n",
            "Progress: 68000/703985\n",
            "Progress: 69000/703985\n",
            "Progress: 70000/703985\n",
            "Progress: 71000/703985\n",
            "Progress: 72000/703985\n",
            "Progress: 73000/703985\n",
            "Progress: 74000/703985\n",
            "Progress: 75000/703985\n",
            "Progress: 76000/703985\n",
            "Progress: 77000/703985\n",
            "Progress: 78000/703985\n",
            "Progress: 79000/703985\n",
            "Progress: 80000/703985\n",
            "Progress: 81000/703985\n",
            "Progress: 82000/703985\n",
            "Progress: 83000/703985\n",
            "Progress: 84000/703985\n",
            "Progress: 85000/703985\n",
            "Progress: 86000/703985\n",
            "Progress: 87000/703985\n",
            "Progress: 88000/703985\n",
            "Progress: 89000/703985\n",
            "Progress: 90000/703985\n",
            "Progress: 91000/703985\n",
            "Progress: 92000/703985\n",
            "Progress: 93000/703985\n",
            "Progress: 94000/703985\n",
            "Progress: 95000/703985\n",
            "Progress: 96000/703985\n",
            "Progress: 97000/703985\n",
            "Progress: 98000/703985\n",
            "Progress: 99000/703985\n",
            "Progress: 100000/703985\n",
            "Progress: 101000/703985\n",
            "Progress: 102000/703985\n",
            "Progress: 103000/703985\n",
            "Progress: 104000/703985\n",
            "Progress: 105000/703985\n",
            "Progress: 106000/703985\n",
            "Progress: 107000/703985\n",
            "Progress: 108000/703985\n",
            "Progress: 109000/703985\n",
            "Progress: 110000/703985\n",
            "Progress: 111000/703985\n",
            "Progress: 112000/703985\n",
            "Progress: 113000/703985\n",
            "Progress: 114000/703985\n",
            "Progress: 115000/703985\n",
            "Progress: 116000/703985\n",
            "Progress: 117000/703985\n",
            "Progress: 118000/703985\n",
            "Progress: 119000/703985\n",
            "Progress: 120000/703985\n",
            "Progress: 121000/703985\n",
            "Progress: 122000/703985\n",
            "Progress: 123000/703985\n",
            "Progress: 124000/703985\n",
            "Progress: 125000/703985\n",
            "Progress: 126000/703985\n",
            "Progress: 127000/703985\n",
            "Progress: 128000/703985\n",
            "Progress: 129000/703985\n",
            "Progress: 130000/703985\n",
            "Progress: 131000/703985\n",
            "Progress: 132000/703985\n",
            "Progress: 133000/703985\n",
            "Progress: 134000/703985\n",
            "Progress: 135000/703985\n",
            "Progress: 136000/703985\n",
            "Progress: 137000/703985\n",
            "Progress: 138000/703985\n",
            "Progress: 139000/703985\n",
            "Progress: 140000/703985\n",
            "Progress: 141000/703985\n",
            "Progress: 142000/703985\n",
            "Progress: 143000/703985\n",
            "Progress: 144000/703985\n",
            "Progress: 145000/703985\n",
            "Progress: 146000/703985\n",
            "Progress: 147000/703985\n",
            "Progress: 148000/703985\n",
            "Progress: 149000/703985\n",
            "Progress: 150000/703985\n",
            "Progress: 151000/703985\n",
            "Progress: 152000/703985\n",
            "Progress: 153000/703985\n",
            "Progress: 154000/703985\n",
            "Progress: 155000/703985\n",
            "Progress: 156000/703985\n",
            "Progress: 157000/703985\n",
            "Progress: 158000/703985\n",
            "Progress: 159000/703985\n",
            "Progress: 160000/703985\n",
            "Progress: 161000/703985\n",
            "Progress: 162000/703985\n",
            "Progress: 163000/703985\n",
            "Progress: 164000/703985\n",
            "Progress: 165000/703985\n",
            "Progress: 166000/703985\n",
            "Progress: 167000/703985\n",
            "Progress: 168000/703985\n",
            "Progress: 169000/703985\n",
            "Progress: 170000/703985\n",
            "Progress: 171000/703985\n",
            "Progress: 172000/703985\n",
            "Progress: 173000/703985\n",
            "Progress: 174000/703985\n",
            "Progress: 175000/703985\n",
            "Progress: 176000/703985\n",
            "Progress: 177000/703985\n",
            "Progress: 178000/703985\n",
            "Progress: 179000/703985\n",
            "Progress: 180000/703985\n",
            "Progress: 181000/703985\n",
            "Progress: 182000/703985\n",
            "Progress: 183000/703985\n",
            "Progress: 184000/703985\n",
            "Progress: 185000/703985\n",
            "Progress: 186000/703985\n",
            "Progress: 187000/703985\n",
            "Progress: 188000/703985\n",
            "Progress: 189000/703985\n",
            "Progress: 190000/703985\n",
            "Progress: 191000/703985\n",
            "Progress: 192000/703985\n",
            "Progress: 193000/703985\n",
            "Progress: 194000/703985\n",
            "Progress: 195000/703985\n",
            "Progress: 196000/703985\n",
            "Progress: 197000/703985\n",
            "Progress: 198000/703985\n",
            "Progress: 199000/703985\n",
            "Progress: 200000/703985\n",
            "Progress: 201000/703985\n",
            "Progress: 202000/703985\n",
            "Progress: 203000/703985\n",
            "Progress: 204000/703985\n",
            "Progress: 205000/703985\n",
            "Progress: 206000/703985\n",
            "Progress: 207000/703985\n",
            "Progress: 208000/703985\n",
            "Progress: 209000/703985\n",
            "Progress: 210000/703985\n",
            "Progress: 211000/703985\n",
            "Progress: 212000/703985\n",
            "Progress: 213000/703985\n",
            "Progress: 214000/703985\n",
            "Progress: 215000/703985\n",
            "Progress: 216000/703985\n",
            "Progress: 217000/703985\n",
            "Progress: 218000/703985\n",
            "Progress: 219000/703985\n",
            "Progress: 220000/703985\n",
            "Progress: 221000/703985\n",
            "Progress: 222000/703985\n",
            "Progress: 223000/703985\n",
            "Progress: 224000/703985\n",
            "Progress: 225000/703985\n",
            "Progress: 226000/703985\n",
            "Progress: 227000/703985\n",
            "Progress: 228000/703985\n",
            "Progress: 229000/703985\n",
            "Progress: 230000/703985\n",
            "Progress: 231000/703985\n",
            "Progress: 232000/703985\n",
            "Progress: 233000/703985\n",
            "Progress: 234000/703985\n",
            "Progress: 235000/703985\n",
            "Progress: 236000/703985\n",
            "Progress: 237000/703985\n",
            "Progress: 238000/703985\n",
            "Progress: 239000/703985\n",
            "Progress: 240000/703985\n",
            "Progress: 241000/703985\n",
            "Progress: 242000/703985\n",
            "Progress: 243000/703985\n",
            "Progress: 244000/703985\n",
            "Progress: 245000/703985\n",
            "Progress: 246000/703985\n",
            "Progress: 247000/703985\n",
            "Progress: 248000/703985\n",
            "Progress: 249000/703985\n",
            "Progress: 250000/703985\n",
            "Progress: 251000/703985\n",
            "Progress: 252000/703985\n",
            "Progress: 253000/703985\n",
            "Progress: 254000/703985\n",
            "Progress: 255000/703985\n",
            "Progress: 256000/703985\n",
            "Progress: 257000/703985\n",
            "Progress: 258000/703985\n",
            "Progress: 259000/703985\n",
            "Progress: 260000/703985\n",
            "Progress: 261000/703985\n",
            "Progress: 262000/703985\n",
            "Progress: 263000/703985\n",
            "Progress: 264000/703985\n",
            "Progress: 265000/703985\n",
            "Progress: 266000/703985\n",
            "Progress: 267000/703985\n",
            "Progress: 268000/703985\n",
            "Progress: 269000/703985\n",
            "Progress: 270000/703985\n",
            "Progress: 271000/703985\n",
            "Progress: 272000/703985\n",
            "Progress: 273000/703985\n",
            "Progress: 274000/703985\n",
            "Progress: 275000/703985\n",
            "Progress: 276000/703985\n",
            "Progress: 277000/703985\n",
            "Progress: 278000/703985\n",
            "Progress: 279000/703985\n",
            "Progress: 280000/703985\n",
            "Progress: 281000/703985\n",
            "Progress: 282000/703985\n",
            "Progress: 283000/703985\n",
            "Progress: 284000/703985\n",
            "Progress: 285000/703985\n",
            "Progress: 286000/703985\n",
            "Progress: 287000/703985\n",
            "Progress: 288000/703985\n",
            "Progress: 289000/703985\n",
            "Progress: 290000/703985\n",
            "Progress: 291000/703985\n",
            "Progress: 292000/703985\n",
            "Progress: 293000/703985\n",
            "Progress: 294000/703985\n",
            "Progress: 295000/703985\n",
            "Progress: 296000/703985\n",
            "Progress: 297000/703985\n",
            "Progress: 298000/703985\n",
            "Progress: 299000/703985\n",
            "Progress: 300000/703985\n",
            "Progress: 301000/703985\n",
            "Progress: 302000/703985\n",
            "Progress: 303000/703985\n",
            "Progress: 304000/703985\n",
            "Progress: 305000/703985\n",
            "Progress: 306000/703985\n",
            "Progress: 307000/703985\n",
            "Progress: 308000/703985\n",
            "Progress: 309000/703985\n",
            "Progress: 310000/703985\n",
            "Progress: 311000/703985\n",
            "Progress: 312000/703985\n",
            "Progress: 313000/703985\n",
            "Progress: 314000/703985\n",
            "Progress: 315000/703985\n",
            "Progress: 316000/703985\n",
            "Progress: 317000/703985\n",
            "Progress: 318000/703985\n",
            "Progress: 319000/703985\n",
            "Progress: 320000/703985\n",
            "Progress: 321000/703985\n",
            "Progress: 322000/703985\n",
            "Progress: 323000/703985\n",
            "Progress: 324000/703985\n",
            "Progress: 325000/703985\n",
            "Progress: 326000/703985\n",
            "Progress: 327000/703985\n",
            "Progress: 328000/703985\n",
            "Progress: 329000/703985\n",
            "Progress: 330000/703985\n",
            "Progress: 331000/703985\n",
            "Progress: 332000/703985\n",
            "Progress: 333000/703985\n",
            "Progress: 334000/703985\n",
            "Progress: 335000/703985\n",
            "Progress: 336000/703985\n",
            "Progress: 337000/703985\n",
            "Progress: 338000/703985\n",
            "Progress: 339000/703985\n",
            "Progress: 340000/703985\n",
            "Progress: 341000/703985\n",
            "Progress: 342000/703985\n",
            "Progress: 343000/703985\n",
            "Progress: 344000/703985\n",
            "Progress: 345000/703985\n",
            "Progress: 346000/703985\n",
            "Progress: 347000/703985\n",
            "Progress: 348000/703985\n",
            "Progress: 349000/703985\n",
            "Progress: 350000/703985\n",
            "Progress: 351000/703985\n",
            "Progress: 352000/703985\n",
            "Progress: 353000/703985\n",
            "Progress: 354000/703985\n",
            "Progress: 355000/703985\n",
            "Progress: 356000/703985\n",
            "Progress: 357000/703985\n",
            "Progress: 358000/703985\n",
            "Progress: 359000/703985\n",
            "Progress: 360000/703985\n",
            "Progress: 361000/703985\n",
            "Progress: 362000/703985\n",
            "Progress: 363000/703985\n",
            "Progress: 364000/703985\n",
            "Progress: 365000/703985\n",
            "Progress: 366000/703985\n",
            "Progress: 367000/703985\n",
            "Progress: 368000/703985\n",
            "Progress: 369000/703985\n",
            "Progress: 370000/703985\n",
            "Progress: 371000/703985\n",
            "Progress: 372000/703985\n",
            "Progress: 373000/703985\n",
            "Progress: 374000/703985\n",
            "Progress: 375000/703985\n",
            "Progress: 376000/703985\n",
            "Progress: 377000/703985\n",
            "Progress: 378000/703985\n",
            "Progress: 379000/703985\n",
            "Progress: 380000/703985\n",
            "Progress: 381000/703985\n",
            "Progress: 382000/703985\n",
            "Progress: 383000/703985\n",
            "Progress: 384000/703985\n",
            "Progress: 385000/703985\n",
            "Progress: 386000/703985\n",
            "Progress: 387000/703985\n",
            "Progress: 388000/703985\n",
            "Progress: 389000/703985\n",
            "Progress: 390000/703985\n",
            "Progress: 391000/703985\n",
            "Progress: 392000/703985\n",
            "Progress: 393000/703985\n",
            "Progress: 394000/703985\n",
            "Progress: 395000/703985\n",
            "Progress: 396000/703985\n",
            "Progress: 397000/703985\n",
            "Progress: 398000/703985\n",
            "Progress: 399000/703985\n",
            "Progress: 400000/703985\n",
            "Progress: 401000/703985\n",
            "Progress: 402000/703985\n",
            "Progress: 403000/703985\n",
            "Progress: 404000/703985\n",
            "Progress: 405000/703985\n",
            "Progress: 406000/703985\n",
            "Progress: 407000/703985\n",
            "Progress: 408000/703985\n",
            "Progress: 409000/703985\n",
            "Progress: 410000/703985\n",
            "Progress: 411000/703985\n",
            "Progress: 412000/703985\n",
            "Progress: 413000/703985\n",
            "Progress: 414000/703985\n",
            "Progress: 415000/703985\n",
            "Progress: 416000/703985\n",
            "Progress: 417000/703985\n",
            "Progress: 418000/703985\n",
            "Progress: 419000/703985\n",
            "Progress: 420000/703985\n",
            "Progress: 421000/703985\n",
            "Progress: 422000/703985\n",
            "Progress: 423000/703985\n",
            "Progress: 424000/703985\n",
            "Progress: 425000/703985\n",
            "Progress: 426000/703985\n",
            "Progress: 427000/703985\n",
            "Progress: 428000/703985\n",
            "Progress: 429000/703985\n",
            "Progress: 430000/703985\n",
            "Progress: 431000/703985\n",
            "Progress: 432000/703985\n",
            "Progress: 433000/703985\n",
            "Progress: 434000/703985\n",
            "Progress: 435000/703985\n",
            "Progress: 436000/703985\n",
            "Progress: 437000/703985\n",
            "Progress: 438000/703985\n",
            "Progress: 439000/703985\n",
            "Progress: 440000/703985\n",
            "Progress: 441000/703985\n",
            "Progress: 442000/703985\n",
            "Progress: 443000/703985\n",
            "Progress: 444000/703985\n",
            "Progress: 445000/703985\n",
            "Progress: 446000/703985\n",
            "Progress: 447000/703985\n",
            "Progress: 448000/703985\n",
            "Progress: 449000/703985\n",
            "Progress: 450000/703985\n",
            "Progress: 451000/703985\n",
            "Progress: 452000/703985\n",
            "Progress: 453000/703985\n",
            "Progress: 454000/703985\n",
            "Progress: 455000/703985\n",
            "Progress: 456000/703985\n",
            "Progress: 457000/703985\n",
            "Progress: 458000/703985\n",
            "Progress: 459000/703985\n",
            "Progress: 460000/703985\n",
            "Progress: 461000/703985\n",
            "Progress: 462000/703985\n",
            "Progress: 463000/703985\n",
            "Progress: 464000/703985\n",
            "Progress: 465000/703985\n",
            "Progress: 466000/703985\n",
            "Progress: 467000/703985\n",
            "Progress: 468000/703985\n",
            "Progress: 469000/703985\n",
            "Progress: 470000/703985\n",
            "Progress: 471000/703985\n",
            "Progress: 472000/703985\n",
            "Progress: 473000/703985\n",
            "Progress: 474000/703985\n",
            "Progress: 475000/703985\n",
            "Progress: 476000/703985\n",
            "Progress: 477000/703985\n",
            "Progress: 478000/703985\n",
            "Progress: 479000/703985\n",
            "Progress: 480000/703985\n",
            "Progress: 481000/703985\n",
            "Progress: 482000/703985\n",
            "Progress: 483000/703985\n",
            "Progress: 484000/703985\n",
            "Progress: 485000/703985\n",
            "Progress: 486000/703985\n",
            "Progress: 487000/703985\n",
            "Progress: 488000/703985\n",
            "Progress: 489000/703985\n",
            "Progress: 490000/703985\n",
            "Progress: 491000/703985\n",
            "Progress: 492000/703985\n",
            "Progress: 493000/703985\n",
            "Progress: 494000/703985\n",
            "Progress: 495000/703985\n",
            "Progress: 496000/703985\n",
            "Progress: 497000/703985\n",
            "Progress: 498000/703985\n",
            "Progress: 499000/703985\n",
            "Progress: 500000/703985\n",
            "Progress: 501000/703985\n",
            "Progress: 502000/703985\n",
            "Progress: 503000/703985\n",
            "Progress: 504000/703985\n",
            "Progress: 505000/703985\n",
            "Progress: 506000/703985\n",
            "Progress: 507000/703985\n",
            "Progress: 508000/703985\n",
            "Progress: 509000/703985\n",
            "Progress: 510000/703985\n",
            "Progress: 511000/703985\n",
            "Progress: 512000/703985\n",
            "Progress: 513000/703985\n",
            "Progress: 514000/703985\n",
            "Progress: 515000/703985\n",
            "Progress: 516000/703985\n",
            "Progress: 517000/703985\n",
            "Progress: 518000/703985\n",
            "Progress: 519000/703985\n",
            "Progress: 520000/703985\n",
            "Progress: 521000/703985\n",
            "Progress: 522000/703985\n",
            "Progress: 523000/703985\n",
            "Progress: 524000/703985\n",
            "Progress: 525000/703985\n",
            "Progress: 526000/703985\n",
            "Progress: 527000/703985\n",
            "Progress: 528000/703985\n",
            "Progress: 529000/703985\n",
            "Progress: 530000/703985\n",
            "Progress: 531000/703985\n",
            "Progress: 532000/703985\n",
            "Progress: 533000/703985\n",
            "Progress: 534000/703985\n",
            "Progress: 535000/703985\n",
            "Progress: 536000/703985\n",
            "Progress: 537000/703985\n",
            "Progress: 538000/703985\n",
            "Progress: 539000/703985\n",
            "Progress: 540000/703985\n",
            "Progress: 541000/703985\n",
            "Progress: 542000/703985\n",
            "Progress: 543000/703985\n",
            "Progress: 544000/703985\n",
            "Progress: 545000/703985\n",
            "Progress: 546000/703985\n",
            "Progress: 547000/703985\n",
            "Progress: 548000/703985\n",
            "Progress: 549000/703985\n",
            "Progress: 550000/703985\n",
            "Progress: 551000/703985\n",
            "Progress: 552000/703985\n",
            "Progress: 553000/703985\n",
            "Progress: 554000/703985\n",
            "Progress: 555000/703985\n",
            "Progress: 556000/703985\n",
            "Progress: 557000/703985\n",
            "Progress: 558000/703985\n",
            "Progress: 559000/703985\n",
            "Progress: 560000/703985\n",
            "Progress: 561000/703985\n",
            "Progress: 562000/703985\n",
            "Progress: 563000/703985\n",
            "Progress: 564000/703985\n",
            "Progress: 565000/703985\n",
            "Progress: 566000/703985\n",
            "Progress: 567000/703985\n",
            "Progress: 568000/703985\n",
            "Progress: 569000/703985\n",
            "Progress: 570000/703985\n",
            "Progress: 571000/703985\n",
            "Progress: 572000/703985\n",
            "Progress: 573000/703985\n",
            "Progress: 574000/703985\n",
            "Progress: 575000/703985\n",
            "Progress: 576000/703985\n",
            "Progress: 577000/703985\n",
            "Progress: 578000/703985\n",
            "Progress: 579000/703985\n",
            "Progress: 580000/703985\n",
            "Progress: 581000/703985\n",
            "Progress: 582000/703985\n",
            "Progress: 583000/703985\n",
            "Progress: 584000/703985\n",
            "Progress: 585000/703985\n",
            "Progress: 586000/703985\n",
            "Progress: 587000/703985\n",
            "Progress: 588000/703985\n",
            "Progress: 589000/703985\n",
            "Progress: 590000/703985\n",
            "Progress: 591000/703985\n",
            "Progress: 592000/703985\n",
            "Progress: 593000/703985\n",
            "Progress: 594000/703985\n",
            "Progress: 595000/703985\n",
            "Progress: 596000/703985\n",
            "Progress: 597000/703985\n",
            "Progress: 598000/703985\n",
            "Progress: 599000/703985\n",
            "Progress: 600000/703985\n",
            "Progress: 601000/703985\n",
            "Progress: 602000/703985\n",
            "Progress: 603000/703985\n",
            "Progress: 604000/703985\n",
            "Progress: 605000/703985\n",
            "Progress: 606000/703985\n",
            "Progress: 607000/703985\n",
            "Progress: 608000/703985\n",
            "Progress: 609000/703985\n",
            "Progress: 610000/703985\n",
            "Progress: 611000/703985\n",
            "Progress: 612000/703985\n",
            "Progress: 613000/703985\n",
            "Progress: 614000/703985\n",
            "Progress: 615000/703985\n",
            "Progress: 616000/703985\n",
            "Progress: 617000/703985\n",
            "Progress: 618000/703985\n",
            "Progress: 619000/703985\n",
            "Progress: 620000/703985\n",
            "Progress: 621000/703985\n",
            "Progress: 622000/703985\n",
            "Progress: 623000/703985\n",
            "Progress: 624000/703985\n",
            "Progress: 625000/703985\n",
            "Progress: 626000/703985\n",
            "Progress: 627000/703985\n",
            "Progress: 628000/703985\n",
            "Progress: 629000/703985\n",
            "Progress: 630000/703985\n",
            "Progress: 631000/703985\n",
            "Progress: 632000/703985\n",
            "Progress: 633000/703985\n",
            "Progress: 634000/703985\n",
            "Progress: 635000/703985\n",
            "Progress: 636000/703985\n",
            "Progress: 637000/703985\n",
            "Progress: 638000/703985\n",
            "Progress: 639000/703985\n",
            "Progress: 640000/703985\n",
            "Progress: 641000/703985\n",
            "Progress: 642000/703985\n",
            "Progress: 643000/703985\n",
            "Progress: 644000/703985\n",
            "Progress: 645000/703985\n",
            "Progress: 646000/703985\n",
            "Progress: 647000/703985\n",
            "Progress: 648000/703985\n",
            "Progress: 649000/703985\n",
            "Progress: 650000/703985\n",
            "Progress: 651000/703985\n",
            "Progress: 652000/703985\n",
            "Progress: 653000/703985\n",
            "Progress: 654000/703985\n",
            "Progress: 655000/703985\n",
            "Progress: 656000/703985\n",
            "Progress: 657000/703985\n",
            "Progress: 658000/703985\n",
            "Progress: 659000/703985\n",
            "Progress: 660000/703985\n",
            "Progress: 661000/703985\n",
            "Progress: 662000/703985\n",
            "Progress: 663000/703985\n",
            "Progress: 664000/703985\n",
            "Progress: 665000/703985\n",
            "Progress: 666000/703985\n",
            "Progress: 667000/703985\n",
            "Progress: 668000/703985\n",
            "Progress: 669000/703985\n",
            "Progress: 670000/703985\n",
            "Progress: 671000/703985\n",
            "Progress: 672000/703985\n",
            "Progress: 673000/703985\n",
            "Progress: 674000/703985\n",
            "Progress: 675000/703985\n",
            "Progress: 676000/703985\n",
            "Progress: 677000/703985\n",
            "Progress: 678000/703985\n",
            "Progress: 679000/703985\n",
            "Progress: 680000/703985\n",
            "Progress: 681000/703985\n",
            "Progress: 682000/703985\n",
            "Progress: 683000/703985\n",
            "Progress: 684000/703985\n",
            "Progress: 685000/703985\n",
            "Progress: 686000/703985\n",
            "Progress: 687000/703985\n",
            "Progress: 688000/703985\n",
            "Progress: 689000/703985\n",
            "Progress: 690000/703985\n",
            "Progress: 691000/703985\n",
            "Progress: 692000/703985\n",
            "Progress: 693000/703985\n",
            "Progress: 694000/703985\n",
            "Progress: 695000/703985\n",
            "Progress: 696000/703985\n",
            "Progress: 697000/703985\n",
            "Progress: 698000/703985\n",
            "Progress: 699000/703985\n",
            "Progress: 700000/703985\n",
            "Progress: 701000/703985\n",
            "Progress: 702000/703985\n",
            "Progress: 703000/703985\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 703985 entries, 0 to 703984\n",
            "Data columns (total 5 columns):\n",
            " #   Column  Non-Null Count   Dtype \n",
            "---  ------  --------------   ----- \n",
            " 0   0       703985 non-null  int64 \n",
            " 1   1       703985 non-null  object\n",
            " 2   2       703985 non-null  int64 \n",
            " 3   3       703985 non-null  object\n",
            " 4   4       703985 non-null  object\n",
            "dtypes: int64(2), object(3)\n",
            "memory usage: 26.9+ MB\n",
            "None\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Int64Index: 430642 entries, 0 to 430641\n",
            "Data columns (total 5 columns):\n",
            " #   Column                    Non-Null Count   Dtype \n",
            "---  ------                    --------------   ----- \n",
            " 0   index                     430642 non-null  int64 \n",
            " 1   userId                    430642 non-null  object\n",
            " 2   timestamp                 430642 non-null  int64 \n",
            " 3   userHistory               430642 non-null  object\n",
            " 4   positiveAndNegativeLists  430642 non-null  object\n",
            "dtypes: int64(2), object(3)\n",
            "memory usage: 19.7+ MB\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "# DEPRECATED BLOCK OF CODE\n",
        "# Schema:[['index', 'userId', 'timestamp', 'userHistory', 'positiveAndNegativeLists']]\n",
        "# EXPERIMENT: REMOVING THE URL 'http://adressa.no' AND SAVING AS \"behavior-week-v2.tsv\"\n",
        "\n",
        "newDf = pd.DataFrame(columns=['index','userId','timestamp','userHistory','positiveAndNegativeLists'])\n",
        "\n",
        "for i, row in df.iterrows():\n",
        "  DISCARD_ROW_FLAG = False\n",
        "\n",
        "  userHistory = row[3]\n",
        "  userBehavior = row[4]\n",
        "\n",
        "  userHistory = userHistory.split(' ')\n",
        "  userBehavior = userBehavior.split(' ')\n",
        "\n",
        "  newUserHistory = []\n",
        "  newUserBehavior = []\n",
        "\n",
        "  for el in userHistory:\n",
        "    if el != 'http://adressa.no':\n",
        "      newUserHistory.append(el)\n",
        "\n",
        "  countPos = 0\n",
        "  countNeg = 0\n",
        "  for el in userBehavior:\n",
        "    if el != 'http://adressa.no-1' and el != 'http://adressa.no-0':\n",
        "      newUserBehavior.append(el)\n",
        "      label = (el.split('-'))[-1]\n",
        "      if label == '1':\n",
        "        countPos += 1\n",
        "      elif label == '0':\n",
        "        countNeg += 1\n",
        "      else:\n",
        "        print(\"ERROR: unidentified label\")\n",
        "\n",
        "  if len(newUserHistory) == 0 or countPos == 0 or countNeg == 0:\n",
        "    DISCARD_ROW_FLAG = True\n",
        "\n",
        "  finalUserHistory = ''\n",
        "  finalUserBehavior = ''\n",
        "\n",
        "  for el in newUserHistory:\n",
        "    finalUserHistory = finalUserHistory + el + ' '\n",
        "\n",
        "  for el in newUserBehavior:\n",
        "    finalUserBehavior = finalUserBehavior + el + ' '\n",
        "\n",
        "  finalUserHistory = finalUserHistory[:-1]\n",
        "  finalUserBehavior = finalUserBehavior[:-1]\n",
        "\n",
        "\n",
        "  if not DISCARD_ROW_FLAG:\n",
        "    newDf.loc[len(newDf)] = [row[0], row[1], row[2], finalUserHistory, finalUserBehavior]\n",
        "\n",
        "  if i % 1000 == 0:\n",
        "    print(f'Progress: {i}/{df.shape[0]}')\n",
        "\n",
        "newDf['index'] = newDf.index + 1\n",
        "\n",
        "print(df.info())\n",
        "print(newDf.info())\n",
        "\n",
        "outputFileName = \"behavior-week-v2.tsv\"                                                                        # Save weekly df on disk\n",
        "outputPath = \"/content/KRED-Reccomendation-System/data/AdressaProcessed/\" + outputFileName\n",
        "print(f'Saving final dataset as: {outputPath}')\n",
        "if not os.path.exists(\"/content/KRED-Reccomendation-System/data/AdressaProcessed/\"):                        # create directory to store data if doesnt exists\n",
        "  os.makedirs(\"/content/KRED-Reccomendation-System/data/AdressaProcessed/\")\n",
        "\n",
        "newDf.to_csv(outputPath, sep=\"\\t\", index = False, header = False)                                    # save as .tsv (tab separated values)\n",
        "\n",
        "# save on drive --> i.e. copy files in drive folder\n",
        "print(f'Saving backup on mounted Drive: /content/drive/MyDrive/AdressaProcessed/behavior-week-v2.tsv')         # save backup on Google Drive\n",
        "shutil.copy(\"/content/KRED-Reccomendation-System/data/AdressaProcessed/behavior-week-v2.tsv\", \"/content/drive/MyDrive/AdressaProcessed/behavior-week-v2.tsv\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rMnvXbO84VkI"
      },
      "source": [
        "# 1.3.3 Work towards news.tsv format\n",
        "*Now that all news have been extracted one can skip this section and go to 1.3.4 to directly build knowledge graph *"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WWFlJooPmzTO"
      },
      "outputs": [],
      "source": [
        "# Fill category and add subcategory column starting from url\n",
        "def cat_subcat_from_url(url):\n",
        "  \"\"\"Given an URL as input, return title, category, subcategory as strings\"\"\"\n",
        "  #Parse the URL\n",
        "  parsed_url = urlparse(url)\n",
        "\n",
        "  #Get path from parsed URL\n",
        "  path = parsed_url.path\n",
        "\n",
        "  #Split path into segments divided by '/'\n",
        "  segments = path.split('/')\n",
        "\n",
        "  #Extract desired parts\n",
        "\n",
        "  #Category\n",
        "  category = segments[1]\n",
        "\n",
        "  #Subcategory\n",
        "  if (len(segments) > 2):\n",
        "    subcategory = segments[2]\n",
        "  else:\n",
        "    subcategory = None\n",
        "\n",
        "  return category, subcategory\n",
        "\n",
        "# get wikiid for each entity\n",
        "# Function to retrieve Wikidata ID for an item\n",
        "def get_wikidata_id(item):\n",
        "    # Query Wikidata for the item using its label\n",
        "    url = f'https://www.wikidata.org/w/api.php?action=wbsearchentities&format=json&language=en&search={item}'\n",
        "    response = requests.get(url)\n",
        "    if response.status_code == 200:\n",
        "        data = response.json()\n",
        "        if 'search' in data:\n",
        "            search_results = data['search']\n",
        "            if search_results:\n",
        "                # Get the first result (highest score)\n",
        "                result = search_results[0]\n",
        "                if 'id' in result:\n",
        "                    return result['id']\n",
        "    return None\n",
        "\n",
        "# Transform 'profile' column\n",
        "def df_get_wikidata_id(df):\n",
        "  df['profile'] = df['profile'].apply(lambda x: [{'Label': item['item'], 'Type': item['group'], 'Confidence': item['weight'], 'WikidataId': get_wikidata_id(item['item'])} for item in x])\n",
        "  return None"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 799
        },
        "id": "EwoW9WhddU3R",
        "outputId": "67a2fe8e-a2a1-41eb-c864-ffa34bd92844"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The Datasets contains the following null values in the fields:\n",
            "eventId               0\n",
            "time                  0\n",
            "userId                0\n",
            "url                   0\n",
            "profile         6941278\n",
            "category        7756434\n",
            "keywords        7391531\n",
            "title           6941278\n",
            "activeTime      4780659\n",
            "sessionStart          0\n",
            "sessionStop           0\n",
            "dtype: int64\n",
            "\n",
            "New df containing only rows with profile:\n",
            " url              0\n",
            "profile          0\n",
            "category    815156\n",
            "keywords    450253\n",
            "title            0\n",
            "dtype: int64\n",
            "\n",
            "Starting to extract info from news URL and update rows...\n",
            "\n",
            "\n",
            "Extraction completed in 989.98 seconds\n",
            "\n",
            "Resulting DataFrame with unique URLs has 20429 rows \n",
            "\n",
            "Starting to modify profile column towards new.tsv format...\n",
            "\n",
            "profile column is already a python dictionary\n",
            "\n",
            "Operation completed in 16.99 seconds\n",
            "\n",
            "Adding WikidataID to news entities and remove etities not found on wikidata server...\n",
            "\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "20429it [00:03, 6361.19it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Operation completed in 3.36 seconds\n",
            "\n",
            "\n",
            "Saving final dataset as: /content/KRED-Reccomendation-System/data/AdressaProcessed/week_updated_news_dataset.tsv\n",
            "Copying final dataset into mounted Drive at: /content/drive/MyDrive/AdressaProcessed/week_updated_news_dataset.tsv\n"
          ]
        },
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/content/drive/MyDrive/AdressaProcessed/week_updated_news_dataset.tsv'"
            ]
          },
          "execution_count": 82,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Observe number of missing values per attribute\n",
        "print(f'The Datasets contains the following null values in the fields:\\n{inputDf.isnull().sum()}')\n",
        "#create dataset with only profile rows\n",
        "df_profile = inputDf.dropna(subset=['profile'])\n",
        "df_profile = df_profile.drop(['eventId', 'time', 'userId', 'activeTime', 'sessionStart', 'sessionStop'], axis=1)\n",
        "print(f'\\nNew df containing only rows with profile:\\n {df_profile.isnull().sum()}')\n",
        "\n",
        "t1 = time()\n",
        "print('\\nStarting to extract info from news URL and update rows...\\n')\n",
        "\n",
        "# Apply the function to the 'url' column and store the results in new columns\n",
        "df_profile[['new_category', 'subcategory']] = df_profile['url'].apply(lambda url: pd.Series(cat_subcat_from_url(url)))\n",
        "\n",
        "# Fill NaN values in the 'category' column using values from 'title' column\n",
        "df_profile['category'].fillna(df_profile['new_category'], inplace=True)\n",
        "df_profile = df_profile.drop(['category'], axis=1)\n",
        "df_profile.rename(columns={'new_category': 'category'}, inplace=True)\n",
        "df_profile.head()# Apply the function to the 'url' column and store the results in new columns\n",
        "df_profile[['new_category', 'subcategory']] = df_profile['url'].apply(lambda url: pd.Series(cat_subcat_from_url(url)))\n",
        "\n",
        "# Fill NaN values in the 'category' column using values from 'title' column\n",
        "df_profile['category'].fillna(df_profile['new_category'], inplace=True)\n",
        "df_profile = df_profile.drop(['category'], axis=1)\n",
        "df_profile.rename(columns={'new_category': 'category'}, inplace=True)\n",
        "df_profile.head()\n",
        "\n",
        "# Remove duplicate rows\n",
        "df_profile = df_profile.drop_duplicates(subset='url', keep='first')\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nExtraction completed in {str(round(t2-t1, 2))} seconds\\n\")\n",
        "\n",
        "# Print the resulting DataFrame with unique URLs\n",
        "print(f'Resulting DataFrame with unique URLs has {len(df_profile)} rows \\n')\n",
        "\n",
        "t1 = time()\n",
        "print('Starting to modify profile column towards new.tsv format...\\n')\n",
        "\n",
        "\n",
        "# Update the 'profile' column to contain the desired list of dictionaries, remove items with 'group' : ['site', 'author', 'language', 'pageclass', 'adressa-access', 'adressa-tag']\n",
        "#df_profile['profile'].to_dict()\n",
        "try:\n",
        "  df_profile['profile'] = df_profile['profile'].apply(ast.literal_eval)\n",
        "except:\n",
        "  print('profile column is already a python dictionary')\n",
        "df_profile['profile'] = df_profile['profile'].apply(lambda x: [{'item': item['item'], **group} for item in x for group in item['groups']if item['item'] != '0' and group['group'] not in ['site', 'author', 'language', 'pageclass', 'adressa-access', 'adressa-tag']])# Update the 'profile' column to contain the desired list of dictionaries, remove items with 'group' : ['site', 'author', 'language', 'pageclass', 'adressa-access', 'adressa-tag']\n",
        "#df_profile['profile'].to_dict()\n",
        "try:\n",
        "  df_profile['profile'] = df_profile['profile'].apply(ast.literal_eval)\n",
        "  df_profile['profile'] = df_profile['profile'].apply(lambda x: [{'item': item['item'], **group} for item in x for group in item['groups']if item['item'] != '0' and group['group'] not in ['site', 'author', 'language', 'pageclass', 'adressa-access', 'adressa-tag']])\n",
        "except:\n",
        "  print('profile column is already a python dictionary')\n",
        "  # Update the 'profile' column to contain the desired list of dictionaries\n",
        "  df_profile['profile'] = df_profile['profile'].apply(lambda x: [item for item in x if item['item'] != '0' and item['group'] not in ['site', 'author', 'language', 'pageclass', 'adressa-access', 'adressa-tag']])\n",
        "#df_profile['profile'] = df_profile['profile'].apply(lambda x: [{'item': item['item'], **group} for item in x for group in item['groups']if item['item'] != '0' and group['group'] not in ['site', 'author', 'language', 'pageclass', 'adressa-access', 'adressa-tag']])\n",
        "\n",
        "# Update the 'profile' column to contain the desired list of dictionaries\n",
        "#df_profile['profile'] = df_profile['profile'].apply(lambda x: [item for item in x if item['item'] != '0' and item['group'] not in ['site', 'author', 'language', 'pageclass', 'adressa-access', 'adressa-tag']])\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nOperation completed in {str(round(t2-t1, 2))} seconds\\n\")\n",
        "#------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
        "#------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
        "t1 = time()\n",
        "print('Adding WikidataID to news entities and remove etities not found on wikidata server...\\n')\n",
        "# Load the datasets\n",
        "inputPath_news = inputFolder + SELECTED_INPUT\n",
        "inputPath_ent =  inputFolder + 'entities-week.csv'\n",
        "df_entities = pd.read_csv(inputPath_ent, index_col=False)\n",
        "df_news = df_profile\n",
        "\n",
        "# Create a dictionary to map wikiid values to entities\n",
        "wikiid_dict = dict(zip(df_entities['item'], df_entities['wikiid']))\n",
        "\n",
        "# Iterate over each row in the news dataset\n",
        "for index, row in tqdm(df_news.iterrows()):\n",
        "    profile = row['profile']\n",
        "    updated_profile = []\n",
        "\n",
        "    # Iterate over each dictionary in the 'profile' list\n",
        "    for dictionary in profile:\n",
        "        label = dictionary['item']\n",
        "        group = dictionary['group']\n",
        "        weight = dictionary['weight']\n",
        "        count = dictionary['count']\n",
        "\n",
        "        # Get the corresponding wikiid from the entities dataset\n",
        "        wikiid = wikiid_dict.get(label)\n",
        "\n",
        "        # Only add dictionaries with a valid wikiid\n",
        "        if wikiid is not None:\n",
        "            updated_dict = {\n",
        "                'Label': label,\n",
        "                'Type': group,\n",
        "                'WikidataId': wikiid,\n",
        "                'Confidence': weight,\n",
        "                'OccurrenceOffsets': count,\n",
        "                'SurfaceForms': [label.split(',')[0]]  # Modify?\n",
        "            }\n",
        "            updated_profile.append(updated_dict)\n",
        "\n",
        "    # Update the 'profile' column with the updated profile list\n",
        "    df_news.at[index, 'profile'] = updated_profile\n",
        "\n",
        "t2 = time()\n",
        "print(f\"\\nOperation completed in {str(round(t2-t1, 2))} seconds\\n\")\n",
        "\n",
        "# Update the output path construction\n",
        "outputFileName = SELECTED_INPUT.split('.')[0] + '_updated_news_dataset.tsv'\n",
        "outputPath = outputFolder + outputFileName\n",
        "\n",
        "print(f'\\nSaving final dataset as: {outputPath}')\n",
        "\n",
        "# Save the updated dataset as TSV\n",
        "df_news.to_csv(outputPath, sep='\\t', index=False, quoting=csv.QUOTE_NONNUMERIC)\n",
        "\n",
        "# Copy the file to the mounted drive folder\n",
        "mountedDriveOutputPath = \"/content/drive/MyDrive/AdressaProcessed/\" + outputFileName\n",
        "print(f'Copying final dataset into mounted Drive at: {mountedDriveOutputPath}')\n",
        "shutil.copy(outputPath, mountedDriveOutputPath)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cf1HefSTDKXO",
        "outputId": "c1a67a43-6e9d-4d51-dbcd-89bcde0eb3ea"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "new dataset length 1094 and it has url               0\n",
            "profile           0\n",
            "keywords       1092\n",
            "title             0\n",
            "category          0\n",
            "subcategory       2\n",
            "dtype: int64 empty rows \n",
            "\n"
          ]
        }
      ],
      "source": [
        "news_path = '/content/drive/MyDrive/AdressaProcessed/news_day2.csv'\n",
        "if SELECTED_INPUT != 'day2.csv':\n",
        "  # First dataset\n",
        "  df1 = pd.read_csv(news_path, index_col=False, header= None)\n",
        "  df1.columns = ['url']\n",
        "\n",
        "  # Second dataset\n",
        "  df2 = df_profile\n",
        "\n",
        "  # Merge the datasets based on 'url' column\n",
        "  merged = df2.merge(df1, on='url', how='left')\n",
        "\n",
        "  # Filter the rows where the other columns are not null (not present in the first dataset)\n",
        "  filtered_df2 = merged[merged['url'].isnull() | merged['profile'].isnull() | merged['keywords'].isnull() | merged['title'].isnull() | merged['category'].isnull() | merged['subcategory'].isnull()]\n",
        "  df_profile = filtered_df2\n",
        "  # Print the filtered dataframe\n",
        "  print(f'new dataset length {len(filtered_df2)} and it has {filtered_df2.isnull().sum()} empty rows \\n')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KlwI2RyxxPHk",
        "outputId": "30001ee8-10d1-4008-c7ba-5efc35a3872c"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 1094/1094 [00:02<00:00, 506.80it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            " The resulting list of entities contains 12406 items\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "# Initialize an empty list\n",
        "item_list = []\n",
        "\n",
        "# Iterate over each row in the column\n",
        "for row in tqdm(df_profile['profile']):\n",
        "    # Iterate over each dictionary in the row\n",
        "    for dictionary in row:\n",
        "        # Extract the 'item' value from the dictionary\n",
        "        item = dictionary['item']\n",
        "\n",
        "        # Check if the 'item' value is already in the list\n",
        "        if item not in item_list:\n",
        "            # Append the 'item' value to the list\n",
        "            item_list.append(item)\n",
        "\n",
        "# Print the resulting list length\n",
        "print(f'\\n The resulting list of entities contains {len(item_list)} items')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qurgbIKqyhiH",
        "outputId": "c71da11c-25a5-43b0-b729-84b5d1bbed5a"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 12406/12406 [26:35<00:00,  7.78it/s]\n"
          ]
        }
      ],
      "source": [
        "# Create a list of dictionaries with 'item' and 'wikiid'\n",
        "list_ent = []\n",
        "\n",
        "# Iterate over the item_list\n",
        "for el in tqdm(item_list):\n",
        "    # Create a new dictionary for each item\n",
        "    dict_ent = {}\n",
        "    dict_ent['item'] = el\n",
        "    dict_ent['wikiid'] = get_wikidata_id(el)\n",
        "\n",
        "    # Append the dictionary to the list\n",
        "    list_ent.append(dict_ent)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        },
        "id": "Fl7gl0Eh0xLN",
        "outputId": "bb2f46b5-65a1-4d06-9c60-24475d4fd756"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Saving final dataset as: /content/KRED-Reccomendation-System/data/AdressaProcessed/entities-day7.csv\n",
            "Copying final dataset into mounted Drive at: /content/drive/MyDrive/AdressaProcessed/entities-day7.csv\n"
          ]
        },
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/content/drive/MyDrive/AdressaProcessed/entities-day7.csv'"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# save current day entities and wiki_id into a csv\n",
        "#DELETE = False                                                # cleanup dataframe at the end?\n",
        "\n",
        "outputFileName = SELECTED_INPUT                               # usually \"day1.csv\" or \"week.csv\"\n",
        "outputFolder = '/content/KRED-Reccomendation-System/data/AdressaProcessed/'\n",
        "outputPath = outputFolder + 'entities-' + outputFileName      # '/content/KRED-Reccomendation-System/data/AdressaProcessed/entities-day1.csv'\n",
        "print(f'\\nSaving final dataset as: {outputPath}')\n",
        "df_entites = pd.DataFrame.from_dict(list_ent)\n",
        "df_entites.to_csv(outputPath, index = True)\n",
        "\n",
        "\n",
        "# save on drive --> i.e. copy files in drive folder\n",
        "mountedDriveOutputPath = \"/content/drive/MyDrive/AdressaProcessed/\"+'entities-' + outputFileName\n",
        "print(f'Copying final dataset into mounted Drive at: {mountedDriveOutputPath}')\n",
        "shutil.copy(outputPath, mountedDriveOutputPath)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "O6iV8Q0gQklQ",
        "outputId": "138e182c-fac9-4b54-ac41-68510d5672bb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Copying final dataset into mounted Drive at: /content/drive/MyDrive/AdressaProcessed/news_news_day2.csv\n"
          ]
        },
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/content/drive/MyDrive/AdressaProcessed/news_news_day2.csv'"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "if SELECTED_INPUT != 'day2.csv':\n",
        "  # Append the DataFrame rows to the existing file\n",
        "  outputPath = 'news_day2.csv'\n",
        "  df_profile['url'].to_csv(outputPath, header=False, index=False, mode='a')\n",
        "else:\n",
        "  outputPath = 'news_'+ outputFileName +'.txt'\n",
        "  file = open('news_'+ outputFileName +'.txt','w')\n",
        "  for item in df_profile['url']:\n",
        "    file.write(item+\"\\n\")\n",
        "  file.close()\n",
        "\n",
        "# save on drive --> i.e. copy files in drive folder\n",
        "mountedDriveOutputPath = \"/content/drive/MyDrive/AdressaProcessed/\"+'news_' + outputPath\n",
        "print(f'Copying final dataset into mounted Drive at: {mountedDriveOutputPath}')\n",
        "shutil.copy(outputPath, mountedDriveOutputPath)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8B06Vsgamoha"
      },
      "source": [
        "## 1.3.4 Build KG\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OMIH-Qdond6m"
      },
      "outputs": [],
      "source": [
        "def get_entity_info(entity_id):\n",
        "    response = requests.get(f\"https://www.wikidata.org/wiki/Special:EntityData/{entity_id}.json\")\n",
        "    if response.status_code == 200:\n",
        "        entity_data = response.json()\n",
        "        entities = entity_data.get('entities', {})\n",
        "        if entity_id in entities:\n",
        "            return entities[entity_id]\n",
        "    return None\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 105
        },
        "id": "OtPR2WaCIRVP",
        "outputId": "6b258b10-5b19-4d40-fd71-beb40d1d5f7f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "we have collected 71394 entities\n",
            "\n",
            "Saving final dataset as: /content/KRED-Reccomendation-System/data/AdressaProcessed/entities-week.csv\n",
            "Copying final dataset into mounted Drive at: /content/drive/MyDrive/AdressaProcessed/entities-week.csv\n"
          ]
        },
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/content/drive/MyDrive/AdressaProcessed/entities-week.csv'"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "input_path = \"/content/drive/MyDrive/AdressaProcessed/\"\n",
        "# Concatenate datasets vertically\n",
        "# First dataset\n",
        "df1 = pd.read_csv(input_path + 'entities-day1.csv', index_col=False) # entities extracted from day 1\n",
        "df1.dropna(subset=['wikiid'], inplace=True) # Drop rows with NaN values in the 'wikiid' column\n",
        "df2 = pd.read_csv(input_path + 'entities-day2.csv', index_col=False) # entities extracted from day 2\n",
        "df2.dropna(subset=['wikiid'], inplace=True) # Drop rows with NaN values in the 'wikiid' column\n",
        "df3 = pd.read_csv(input_path + 'entities-day3.csv', index_col=False) # entities extracted from day 3\n",
        "df3.dropna(subset=['wikiid'], inplace=True) # Drop rows with NaN values in the 'wikiid' column\n",
        "df4 = pd.read_csv(input_path + 'entities-day4.csv', index_col=False) # entities extracted from day 4\n",
        "df4.dropna(subset=['wikiid'], inplace=True) # Drop rows with NaN values in the 'wikiid' column\n",
        "df5 = pd.read_csv(input_path + 'entities-day5.csv', index_col=False) # entities extracted from day 5\n",
        "df5.dropna(subset=['wikiid'], inplace=True) # Drop rows with NaN values in the 'wikiid' column\n",
        "df6 = pd.read_csv(input_path + 'entities-day6.csv', index_col=False) # entities extracted from day 6\n",
        "df6.dropna(subset=['wikiid'], inplace=True) # Drop rows with NaN values in the 'wikiid' column\n",
        "df7 = pd.read_csv(input_path + 'entities-day7.csv', index_col=False) # entities extracted from day 7\n",
        "df7.dropna(subset=['wikiid'], inplace=True) # Drop rows with NaN values in the 'wikiid' column\n",
        "\n",
        "# The ignore_index=True option resets the index of the appended dataset\n",
        "appended_df = pd.concat([df1, df2, df3, df4, df5, df6, df7], ignore_index=True)\n",
        "\n",
        "# Remove duplicates from the DataFrame\n",
        "appended_df = appended_df.drop_duplicates()\n",
        "# Drop unamed column\n",
        "appended_df = appended_df.drop('Unnamed: 0', axis=1)\n",
        "# Print the appended dataset length\n",
        "print(f'we have collected {len(appended_df)} entities')\n",
        "\n",
        "outputFileName = 'week.csv'                            # usually \"day1.csv\" or \"week.csv\"\n",
        "outputFolder = '/content/KRED-Reccomendation-System/data/AdressaProcessed/'\n",
        "outputPath = outputFolder + 'entities-' + outputFileName      # '/content/KRED-Reccomendation-System/data/AdressaProcessed/entities-day1.csv'\n",
        "print(f'\\nSaving final dataset as: {outputPath}')\n",
        "appended_df.to_csv(outputPath, index = True)\n",
        "\n",
        "# save on drive --> i.e. copy files in drive folder\n",
        "mountedDriveOutputPath = \"/content/drive/MyDrive/AdressaProcessed/\"+'entities-' + outputFileName\n",
        "print(f'Copying final dataset into mounted Drive at: {mountedDriveOutputPath}')\n",
        "shutil.copy(outputPath, mountedDriveOutputPath)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-56SGmgwgUtc",
        "outputId": "9d9a48bb-4528-45fd-9f80-29d9fd547d48"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 71394/71394 [2:28:56<00:00,  7.99it/s]\n",
            "100%|██████████| 33681/33681 [00:02<00:00, 11567.58it/s]\n"
          ]
        }
      ],
      "source": [
        "def get_entity_info(entity_id):\n",
        "    response = requests.get(f\"https://www.wikidata.org/wiki/Special:EntityData/{entity_id}.json\")\n",
        "    if response.status_code == 200:\n",
        "        entity_data = response.json()\n",
        "        entities = entity_data.get('entities', {})\n",
        "        if entity_id in entities:\n",
        "            return entities[entity_id]\n",
        "    return None\n",
        "\n",
        "\n",
        "entity_ids = appended_df['wikiid']  # Entity IDs to build to kg\n",
        "entities = {}\n",
        "for entity_id in tqdm(entity_ids):\n",
        "    entity_info = get_entity_info(entity_id)\n",
        "    if entity_info:\n",
        "        entities[entity_id] = entity_info\n",
        "\n",
        "knowledge_graph = {}\n",
        "for entity_id, entity_info in tqdm(entities.items()):\n",
        "    knowledge_graph[entity_id] = {}\n",
        "    if 'claims' in entity_info:\n",
        "        claims = entity_info['claims']\n",
        "        for prop, values in claims.items():\n",
        "            property_values = []\n",
        "            for value in values:\n",
        "                if 'mainsnak' in value and 'datavalue' in value['mainsnak']:\n",
        "                    data_value = value['mainsnak']['datavalue']\n",
        "                    if data_value.get('type') == 'wikibase-entityid' and 'value' in data_value:\n",
        "                        property_values.append(data_value['value']['id'])\n",
        "            if property_values:\n",
        "                knowledge_graph[entity_id][prop] = property_values"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "id": "pgnIQlaXkGSb",
        "outputId": "f337fce8-2d7a-4314-ce55-0b89ded8b1a5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Knowledge graph saved to 'knowledge_graph_addressa.tsv'.\n",
            "\n",
            " Copying final KG into mounted Drive at: /content/drive/MyDrive/AdressaProcessed/knowledge_graph_addressa.tsv\n"
          ]
        },
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/content/drive/MyDrive/AdressaProcessed/knowledge_graph_addressa.tsv'"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Specify the output file name\n",
        "output_file = 'knowledge_graph_addressa.tsv'\n",
        "outputFolder = '/content/KRED-Reccomendation-System/data/AdressaProcessed/'\n",
        "outputPath = output_file     # '/content/KRED-Reccomendation-System/data/AdressaProcessed/knowledge_graph_addressa.tsv'\n",
        "\n",
        "# Write the knowledge graph to the .tsv file\n",
        "with open(output_file, 'w', newline='') as f:\n",
        "    writer = csv.writer(f, delimiter='\\t')\n",
        "\n",
        "    # Iterate over each entity and its properties in the knowledge graph\n",
        "    for entity_id, properties in knowledge_graph.items():\n",
        "        for prop, values in properties.items():\n",
        "            # Write each relationship to a row in the .tsv file\n",
        "            for value in values:\n",
        "                writer.writerow([entity_id, prop, value])\n",
        "\n",
        "print(f\"Knowledge graph saved to '{outputFolder + output_file}'.\")\n",
        "\n",
        "# save on drive --> i.e. copy files in drive folder\n",
        "mountedDriveOutputPath = \"/content/drive/MyDrive/AdressaProcessed/\"+ output_file\n",
        "print(f'\\n Copying final KG into mounted Drive at: {mountedDriveOutputPath}')\n",
        "shutil.copy(outputPath, mountedDriveOutputPath)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Execution section:**\n",
        "The following subsections to run the extensions and base model follow:\n",
        "- Extension 1: Domain Adaptation to Movies Recommendation\n",
        "- Extension 2: Data Enrichment with News Reading Time\n",
        "- KRED Base Model on News Articles user2item recommendation"
      ],
      "metadata": {
        "id": "qqiMWk9Mq5du"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NWVSUse7YSbK"
      },
      "source": [
        "# **Extension 1: MindReader dataset for Domain Adaptation to Movies Recommendation**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XiIKgOvLCH4Y",
        "outputId": "dcb20808-a8b8-458c-c034-3a726a78e700"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mon Jul 17 18:11:07 2023       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 525.105.17   Driver Version: 525.105.17   CUDA Version: 12.0     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   45C    P8    11W /  70W |      0MiB / 15360MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ],
      "source": [
        "!nvidia-smi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uUb3ndwxCJgC"
      },
      "outputs": [],
      "source": [
        "!cp \"/content/drive/MyDrive/KRED/KRED/data/mind_reader_dataset/movies.pkl\" \"/content/KRED-Reccomendation-System/data/mind_reader_dataset/\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fynaevCfR19J",
        "outputId": "f6a45c35-2638-46cd-bc77-d1f47fa64d62"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Starting grid search for hyper-parameters optimization:\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 5\n",
            "Batch size: 64\n",
            "Learning rate: 1e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(205.7510, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.5787044620398795\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(201.8669, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6041049475175382\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(195.8505, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6457361759641226\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(189.8437, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6707151435866288\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(186.4525, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6814602760608335\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "Model testing:\n",
            "auc score:0.6814602760608335\n",
            "ndcg score:0.6410457898283654\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 5\n",
            "Batch size: 64\n",
            "Learning rate: 2e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(203.3474, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6179666813549767\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(190.1213, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6797897021815347\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(183.3391, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6900674272829406\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(181.4840, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.69215087703869\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(180.3909, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.695238178124312\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "Model testing:\n",
            "auc score:0.695238178124312\n",
            "ndcg score:0.9148568823583791\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 5\n",
            "Batch size: 64\n",
            "Learning rate: 5e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(196.8472, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.682327229897704\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(184.2606, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6952535000777168\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(181.7773, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6993090692222494\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(180.3309, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.7018734389853402\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(179.1944, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.7048497456112947\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "Model testing:\n",
            "auc score:0.7048497456112947\n",
            "ndcg score:0.7670273914429264\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 5\n",
            "Batch size: 128\n",
            "Learning rate: 1e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(103.3789, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6057798194834173\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(102.3588, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6026628745786272\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(101.1934, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6133556131483888\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(99.3752, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6340016896137158\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(96.9906, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6571823622405994\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "Model testing:\n",
            "auc score:0.6571823622405994\n",
            "ndcg score:0.4922818839877926\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 5\n",
            "Batch size: 128\n",
            "Learning rate: 2e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(102.8458, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.5956986459576763\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(100.4119, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6281190443254111\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(96.0906, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6702935799259355\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(93.0985, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6838091841941568\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(92.1189, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6895128519659585\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "Model testing:\n",
            "auc score:0.6895128519659585\n",
            "ndcg score:0.571614567891588\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 5\n",
            "Batch size: 128\n",
            "Learning rate: 5e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(100.8148, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.650610771081313\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(93.0393, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6780100042354856\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(90.8336, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6868393199648335\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(90.0238, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6938391929308003\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(89.3535, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6857091522218894\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "Model testing:\n",
            "auc score:0.6857091522218894\n",
            "ndcg score:0.8669479898642711\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 7\n",
            "Batch size: 64\n",
            "Learning rate: 1e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(205.9097, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.5790411556676874\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(201.7245, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6082688314975999\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(195.7605, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6510535198046363\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(188.5797, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6774614294443513\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(184.6975, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.685399529668707\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "all loss: tensor(182.9385, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6905381326546784\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch6.pth ...\n",
            "all loss: tensor(181.7656, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6927520213221738\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch7.pth ...\n",
            "Model testing:\n",
            "auc score:0.6927520213221738\n",
            "ndcg score:0.7818048722226502\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 7\n",
            "Batch size: 64\n",
            "Learning rate: 2e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(203.5871, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.5972479725704207\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(192.1713, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6690251557922786\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(185.2460, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6826441202633635\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(183.3711, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6856505287638948\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(181.9630, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6934512734398403\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "all loss: tensor(180.5227, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6962058736139625\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch6.pth ...\n",
            "all loss: tensor(179.3640, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6930816532624385\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch7.pth ...\n",
            "Model testing:\n",
            "auc score:0.6930816532624385\n",
            "ndcg score:0.6754160255557639\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 7\n",
            "Batch size: 64\n",
            "Learning rate: 5e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(196.8151, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6711704353938803\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(183.9505, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6870520637991787\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(181.0952, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6927761379394164\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(179.1298, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6931182213525278\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(177.6748, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6942575349351227\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "all loss: tensor(176.0413, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.7035309811882752\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch6.pth ...\n",
            "all loss: tensor(174.9890, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6971757754038292\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch7.pth ...\n",
            "Model testing:\n",
            "auc score:0.6971757754038292\n",
            "ndcg score:0.8165901947515999\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 7\n",
            "Batch size: 128\n",
            "Learning rate: 1e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(103.7140, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6050160197244767\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(102.0961, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6092164183548299\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(100.8755, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6208082815196324\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(98.9978, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6424030899807096\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(96.5965, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6639092876230681\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "all loss: tensor(94.4615, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6755166330606683\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch6.pth ...\n",
            "all loss: tensor(93.1629, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6823132668420102\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch7.pth ...\n",
            "Model testing:\n",
            "auc score:0.6823132668420102\n",
            "ndcg score:0.7702043899253147\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 7\n",
            "Batch size: 128\n",
            "Learning rate: 2e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(103.3116, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.5916402521381263\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(101.4583, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6055680681024567\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(98.0424, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6543560229552942\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(94.2861, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6818010387475177\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(92.6314, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6886783742575303\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "all loss: tensor(91.8996, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6929833240348086\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch6.pth ...\n",
            "all loss: tensor(91.3656, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6955314862707052\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch7.pth ...\n",
            "Model testing:\n",
            "auc score:0.6955314862707052\n",
            "ndcg score:0.47682620352203725\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 7\n",
            "Batch size: 128\n",
            "Learning rate: 5e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(102.2020, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6264310185350594\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(95.0126, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6830377196413854\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(91.5001, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6920422950041729\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(90.4748, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6978671795055016\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(89.9047, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6996690244305379\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "all loss: tensor(89.3413, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.700861029653591\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch6.pth ...\n",
            "all loss: tensor(88.9359, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.7027064203794349\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch7.pth ...\n",
            "Model testing:\n",
            "auc score:0.7027064203794349\n",
            "ndcg score:0.7624164915943119\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 10\n",
            "Batch size: 64\n",
            "Learning rate: 1e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(205.3805, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.5803030448775206\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(202.1078, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.5986753190279576\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(196.5343, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6373782450553681\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(188.9821, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6643095135359953\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(185.0898, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6733657422803159\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "all loss: tensor(183.5374, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6786299669619903\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch6.pth ...\n",
            "all loss: tensor(182.4809, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6834135541038253\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch7.pth ...\n",
            "all loss: tensor(181.6281, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6859563265544186\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch8.pth ...\n",
            "all loss: tensor(180.9904, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6885363083726727\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch9.pth ...\n",
            "all loss: tensor(180.4595, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6903038983874311\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch10.pth ...\n",
            "Model testing:\n",
            "auc score:0.6903038983874311\n",
            "ndcg score:0.9148568823583791\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 10\n",
            "Batch size: 64\n",
            "Learning rate: 2e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(203.1351, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6089125825683045\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(191.4950, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6712598325410501\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(185.1042, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6840738638775368\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(183.1874, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6895259065450926\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(181.9892, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6916442066831505\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "all loss: tensor(181.0950, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6939046414143775\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch6.pth ...\n",
            "all loss: tensor(180.0376, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6975151410215186\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch7.pth ...\n",
            "all loss: tensor(179.1224, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.7010875685899803\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch8.pth ...\n",
            "all loss: tensor(178.1858, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.7000051989288831\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch9.pth ...\n",
            "all loss: tensor(177.3271, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.7002926134290242\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch10.pth ...\n",
            "Model testing:\n",
            "auc score:0.7002926134290242\n",
            "ndcg score:0.715550648768261\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 10\n",
            "Batch size: 64\n",
            "Learning rate: 5e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(197.0766, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6683811451568428\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(184.1250, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6874290663029096\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(181.5034, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6906226286089804\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(179.6247, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6934589305994144\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n",
            "all loss: tensor(178.4318, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6961302410318095\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch5.pth ...\n",
            "all loss: tensor(177.2258, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.702733812092846\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch6.pth ...\n",
            "all loss: tensor(176.2559, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.7054117566944035\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch7.pth ...\n",
            "all loss: tensor(175.0332, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.7016440982767039\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch8.pth ...\n",
            "all loss: tensor(173.8129, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.701798043065148\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch9.pth ...\n",
            "all loss: tensor(173.1250, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.701366753361287\n",
            "Early stopping\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch10.pth ...\n",
            "Model testing:\n",
            "auc score:0.701366753361287\n",
            "ndcg score:0.7573821447149967\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 10\n",
            "Batch size: 128\n",
            "Learning rate: 1e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(103.1926, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6026119769885178\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch1.pth ...\n",
            "all loss: tensor(102.0026, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.600230279722223\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch2.pth ...\n",
            "all loss: tensor(100.8760, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6040653409932413\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch3.pth ...\n",
            "all loss: tensor(99.2078, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc socre: 0.6223395912863203\n",
            "Saving checkpoint: out/saved/models/KRED/0717_181114/checkpoint-model-epoch4.pth ...\n"
          ]
        }
      ],
      "source": [
        "t1 = time()\n",
        "!python movies_rec_training.py\n",
        "t2 = time()\n",
        "print(f\"\\n\\nStage completed in {str(round((t2-t1)/60, 2))} minutes\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "urAXbV1mOpCJ",
        "outputId": "82ccaf7d-b9d5-490e-b1ef-5d04cf5a84e3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'epochs': 5, 'batch_size': 64, 'learning_rate': 1e-05, 'auc_score': 0.6814602760608335, 'ndcg_score': 0.6410457898283654}\n",
            "{'epochs': 5, 'batch_size': 64, 'learning_rate': 2e-05, 'auc_score': 0.695238178124312, 'ndcg_score': 0.9148568823583791}\n",
            "{'epochs': 5, 'batch_size': 64, 'learning_rate': 5e-05, 'auc_score': 0.7048497456112947, 'ndcg_score': 0.7670273914429264}\n",
            "{'epochs': 5, 'batch_size': 128, 'learning_rate': 1e-05, 'auc_score': 0.6571823622405994, 'ndcg_score': 0.4922818839877926}\n",
            "{'epochs': 5, 'batch_size': 128, 'learning_rate': 2e-05, 'auc_score': 0.6895128519659585, 'ndcg_score': 0.571614567891588}\n",
            "{'epochs': 5, 'batch_size': 128, 'learning_rate': 5e-05, 'auc_score': 0.6857091522218894, 'ndcg_score': 0.8669479898642711}\n",
            "{'epochs': 7, 'batch_size': 64, 'learning_rate': 1e-05, 'auc_score': 0.6927520213221738, 'ndcg_score': 0.7818048722226502}\n",
            "{'epochs': 7, 'batch_size': 64, 'learning_rate': 2e-05, 'auc_score': 0.6930816532624385, 'ndcg_score': 0.6754160255557639}\n",
            "{'epochs': 7, 'batch_size': 64, 'learning_rate': 5e-05, 'auc_score': 0.6971757754038292, 'ndcg_score': 0.8165901947515999}\n",
            "{'epochs': 7, 'batch_size': 128, 'learning_rate': 1e-05, 'auc_score': 0.6823132668420102, 'ndcg_score': 0.7702043899253147}\n",
            "{'epochs': 7, 'batch_size': 128, 'learning_rate': 2e-05, 'auc_score': 0.6955314862707052, 'ndcg_score': 0.47682620352203725}\n",
            "{'epochs': 7, 'batch_size': 128, 'learning_rate': 5e-05, 'auc_score': 0.7027064203794349, 'ndcg_score': 0.7624164915943119}\n",
            "{'epochs': 10, 'batch_size': 64, 'learning_rate': 1e-05, 'auc_score': 0.6903038983874311, 'ndcg_score': 0.9148568823583791}\n",
            "{'epochs': 10, 'batch_size': 64, 'learning_rate': 2e-05, 'auc_score': 0.7002926134290242, 'ndcg_score': 0.715550648768261}\n",
            "{'epochs': 10, 'batch_size': 64, 'learning_rate': 5e-05, 'auc_score': 0.701366753361287, 'ndcg_score': 0.7573821447149967}\n",
            "{'epochs': 10, 'batch_size': 128, 'learning_rate': 1e-05, 'auc_score': 0.6911652792168351, 'ndcg_score': 0.4105719800676482}\n",
            "{'epochs': 10, 'batch_size': 128, 'learning_rate': 2e-05, 'auc_score': 0.692617116370198, 'ndcg_score': 0.9148568823583791}\n",
            "{'epochs': 10, 'batch_size': 128, 'learning_rate': 5e-05, 'auc_score': 0.7058701022043764, 'ndcg_score': 0.6678262889110272}\n"
          ]
        }
      ],
      "source": [
        "r1 = dict({'epochs': 5, 'batch_size': 64, 'learning_rate': 1e-05, 'auc_score': 0.6814602760608335, 'ndcg_score': 0.6410457898283654})\n",
        "r2 = dict({'epochs': 5, 'batch_size': 64, 'learning_rate': 2e-05, 'auc_score': 0.695238178124312, 'ndcg_score': 0.9148568823583791})\n",
        "r3 = dict({'epochs': 5, 'batch_size': 64, 'learning_rate': 5e-05, 'auc_score': 0.7048497456112947, 'ndcg_score': 0.7670273914429264})\n",
        "r4 = dict({'epochs': 5, 'batch_size': 128, 'learning_rate': 1e-05, 'auc_score': 0.6571823622405994, 'ndcg_score': 0.4922818839877926})\n",
        "r5 = dict({'epochs': 5, 'batch_size': 128, 'learning_rate': 2e-05, 'auc_score': 0.6895128519659585, 'ndcg_score': 0.571614567891588})\n",
        "r6 = dict({'epochs': 5, 'batch_size': 128, 'learning_rate': 5e-05, 'auc_score': 0.6857091522218894, 'ndcg_score': 0.8669479898642711})\n",
        "r7 = dict({'epochs': 7, 'batch_size': 64, 'learning_rate': 1e-05, 'auc_score': 0.6927520213221738, 'ndcg_score': 0.7818048722226502})\n",
        "r8 = dict({'epochs': 7, 'batch_size': 64, 'learning_rate': 2e-05, 'auc_score': 0.6930816532624385, 'ndcg_score': 0.6754160255557639})\n",
        "r9 = dict({'epochs': 7, 'batch_size': 64, 'learning_rate': 5e-05, 'auc_score': 0.6971757754038292, 'ndcg_score': 0.8165901947515999})\n",
        "r10 = dict({'epochs': 7, 'batch_size': 128, 'learning_rate': 1e-05, 'auc_score': 0.6823132668420102, 'ndcg_score': 0.7702043899253147})\n",
        "r11 = dict({'epochs': 7, 'batch_size': 128, 'learning_rate': 2e-05, 'auc_score': 0.6955314862707052, 'ndcg_score': 0.47682620352203725})\n",
        "r12 = dict({'epochs': 7, 'batch_size': 128, 'learning_rate': 5e-05, 'auc_score': 0.7027064203794349, 'ndcg_score': 0.7624164915943119})\n",
        "r13 = dict({'epochs': 10, 'batch_size': 64, 'learning_rate': 1e-05, 'auc_score': 0.6903038983874311, 'ndcg_score': 0.9148568823583791})\n",
        "r14 = dict({'epochs': 10, 'batch_size': 64, 'learning_rate': 2e-05, 'auc_score': 0.7002926134290242, 'ndcg_score': 0.715550648768261})\n",
        "r15 = dict({'epochs': 10, 'batch_size': 64, 'learning_rate': 5e-05, 'auc_score': 0.701366753361287, 'ndcg_score': 0.7573821447149967})\n",
        "r16 = dict({'epochs': 10, 'batch_size': 128, 'learning_rate': 1e-05, 'auc_score': 0.6911652792168351, 'ndcg_score': 0.4105719800676482})\n",
        "r17 = dict({'epochs': 10, 'batch_size': 128, 'learning_rate': 2e-05, 'auc_score': 0.692617116370198, 'ndcg_score': 0.9148568823583791})\n",
        "r18 = dict({'epochs': 10, 'batch_size': 128, 'learning_rate': 5e-05, 'auc_score': 0.7058701022043764, 'ndcg_score': 0.6678262889110272})\n",
        "\n",
        "grid_search_results = [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18]\n",
        "for r in grid_search_results:\n",
        "        print(r)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 415
        },
        "id": "1gbELDGyTKEq",
        "outputId": "e2795323-6b88-4487-f216-8207dff70c8b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import matplotlib.cm as cm\n",
        "\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "epochs = []\n",
        "batch_sizes = []\n",
        "learning_rates = []\n",
        "auc_scores = []\n",
        "ndcg_scores = []\n",
        "\n",
        "for r in grid_search_results:\n",
        "  epochs.append(r['epochs'])\n",
        "  batch_sizes.append(r['batch_size'])\n",
        "  learning_rates.append(r['learning_rate'])\n",
        "  auc_scores.append(r['auc_score'])\n",
        "  ndcg_scores.append(r['ndcg_score'])\n",
        "\n",
        "img1 = ax.scatter(epochs, batch_sizes, learning_rates, c=auc_scores, cmap=cm.RdYlGn)  # AUC Scores\n",
        "#img2 = ax.scatter(epochs, batch_sizes, learning_rates, c=ndcg_scores, cmap=cm.Greys) # NDCG Scores\n",
        "ax.set_xlabel(\"Epochs\")\n",
        "ax.set_ylabel(\"Batch Size\")\n",
        "ax.set_zlabel(\"Learning Rate\")\n",
        "fig.colorbar(img1)    # AUC Scores\n",
        "#fig.colorbar(img2)   # NDCG Scores\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mPwdSBGYQLdO"
      },
      "source": [
        "# **Extension 2: Data Enrichment with News Reading Time from Adressa Dataset**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4o9wzI-cTGEy",
        "outputId": "a0ab2706-103d-4259-fed8-a88b25a0c6a5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Fri Jul 14 21:34:34 2023       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 525.105.17   Driver Version: 525.105.17   CUDA Version: 12.0     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   39C    P8     9W /  70W |      0MiB / 15360MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ],
      "source": [
        "!nvidia-smi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zxD-G03Ez6R8"
      },
      "outputs": [],
      "source": [
        "t1 = time()\n",
        "!python addressa_rec_training.py\n",
        "t2 = time()\n",
        "print(f\"\\n\\nStage completed in {str(round((t2-t1)/60, 2))} minutes\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "r1 = dict({'epochs': 5, 'batch_size': 64, 'learning_rate': 2e-05, 'auc_score': 0.5822759366832905, 'ndcg_score': 0.2769434091627734})\n",
        "r2 = dict({'epochs': 5, 'batch_size': 64, 'learning_rate': 5e-05, 'auc_score': 0.5989811269627553, 'ndcg_score': 0.3102832648624573})\n",
        "r3 = dict({'epochs': 5, 'batch_size': 128, 'learning_rate': 2e-05, 'auc_score': 0.6297948602760267, 'ndcg_score': 0.3901456373457898})\n",
        "r4 = dict({'epochs': 5, 'batch_size': 128, 'learning_rate': 5e-05, 'auc_score': 0.6108369298598261, 'ndcg_score': 0.3357573907295277})\n",
        "\n",
        "\n",
        "grid_search_results = [r1, r2, r3, r4]\n",
        "for r in grid_search_results:\n",
        "        print(r)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pk9DSQMasbF-",
        "outputId": "8a260a8c-b730-4a1f-c571-a1e5da6b8fb2"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'epochs': 5, 'batch_size': 64, 'learning_rate': 2e-05, 'auc_score': 0.5822759366832905, 'ndcg_score': 0.2769434091627734}\n",
            "{'epochs': 5, 'batch_size': 64, 'learning_rate': 5e-05, 'auc_score': 0.5989811269627553, 'ndcg_score': 0.3102832648624573}\n",
            "{'epochs': 5, 'batch_size': 128, 'learning_rate': 2e-05, 'auc_score': 0.6297948602760267, 'ndcg_score': 0.3901456373457898}\n",
            "{'epochs': 5, 'batch_size': 128, 'learning_rate': 5e-05, 'auc_score': 0.6108369298598261, 'ndcg_score': 0.3357573907295277}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import matplotlib.cm as cm\n",
        "\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "epochs = []\n",
        "batch_sizes = []\n",
        "learning_rates = []\n",
        "auc_scores = []\n",
        "ndcg_scores = []\n",
        "\n",
        "for r in grid_search_results:\n",
        "  epochs.append(r['epochs'])\n",
        "  batch_sizes.append(r['batch_size'])\n",
        "  learning_rates.append(r['learning_rate'])\n",
        "  auc_scores.append(r['auc_score'])\n",
        "  ndcg_scores.append(r['ndcg_score'])\n",
        "\n",
        "img1 = ax.scatter(epochs, batch_sizes, learning_rates, c=auc_scores, cmap=cm.RdYlGn)  # AUC Scores\n",
        "#img2 = ax.scatter(epochs, batch_sizes, learning_rates, c=ndcg_scores, cmap=cm.Greys) # NDCG Scores\n",
        "ax.set_xlabel(\"Epochs\")\n",
        "ax.set_ylabel(\"Batch Size\")\n",
        "ax.set_zlabel(\"Learning Rate\")\n",
        "fig.colorbar(img1)    # AUC Scores\n",
        "#fig.colorbar(img2)   # NDCG Scores\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 409
        },
        "id": "vDq6y87Ku7Sh",
        "outputId": "17b5db80-8dff-4408-f8b8-1c1f295c56e3"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qHLq7zbQ_-mx"
      },
      "source": [
        "# **3. KRED Base Model execution for user2item news articles recommendation:**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZXidbNt0Rz68",
        "outputId": "1a2f1eff-58ca-4f0b-db2d-8a543b63a1b0"
      },
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Data loaded, ready for training\n",
            "Starting grid search for hyper-parameters optimization:\n",
            "\n",
            "\n",
            "Testing the following configuration:\n",
            "Number of epochs: 5\n",
            "Batch size: 64\n",
            "Learning rate: 2e-05\n",
            "\n",
            "\n",
            "model training\n",
            "all loss: tensor(1705.3806, device='cuda:0', grad_fn=<AddBackward0>)\n",
            "auc score: 0.569792098915223\n"
          ]
        }
      ],
      "source": [
        "t1 = time()\n",
        "!python News_rec_training.py\n",
        "t2 = time()\n",
        "print(f\"\\n\\nStage completed in {str(round((t2-t1)/60, 2))} minutes\")"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "machine_shape": "hm",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}