210709_NCF.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "210709_NCF.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPpDslZ9qys8ETpP+NJEZ1l",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/witheunjin/What-Did-I-Study-Today/blob/main/210709_NCF.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kntE3ffXZ7zI"
      },
      "source": [
        "# Section 1: interact_status"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rS9BeC6PHp-h",
        "outputId": "f4342cc5-f5cb-4c16-df0b-80935055a98d"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import random\n",
        "\n",
        "data = [[1,11,2,13142],[1,12,5,24132],[2,21,3,35123],[2,22,4,22121],[2,23,1,23111],[3,31,2,11312],[3,32,1,13412]]\n",
        "df = pd.DataFrame(data)\n",
        "df.columns = ['userId', 'movieId', 'rating', 'timestamp']\n",
        "print(\"[Data]\")\n",
        "print(df)\n",
        "print('\\n')\n",
        "item_pool = set(df['movieId'].unique())\n",
        "\n",
        "#NCF-PT_ejlee\n",
        "interact_status = df.groupby('userId')['movieId'].apply(set).reset_index().rename (columns = {'movieId': 'interacted_items'})\n",
        "print(\"[Interact_status: A]\")\n",
        "print(interact_status)\n",
        "print('\\n')\n",
        "print(\"[Interact_status: B]\")\n",
        "interact_status['negative_items'] = interact_status['interacted_items'].apply(lambda x: item_pool - x)\n",
        "print(interact_status)\n",
        "print('\\n')\n",
        "print(\"[Interact_status: C]\")\n",
        "interact_status['negative_samples'] = interact_status['negative_items'].apply(lambda x: random.sample(x, 3))\n",
        "print(interact_status)\n"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[Data]\n",
            "   userId  movieId  rating  timestamp\n",
            "0       1       11       2      13142\n",
            "1       1       12       5      24132\n",
            "2       2       21       3      35123\n",
            "3       2       22       4      22121\n",
            "4       2       23       1      23111\n",
            "5       3       31       2      11312\n",
            "6       3       32       1      13412\n",
            "\n",
            "\n",
            "[Interact_status: A]\n",
            "   userId interacted_items\n",
            "0       1         {11, 12}\n",
            "1       2     {21, 22, 23}\n",
            "2       3         {32, 31}\n",
            "\n",
            "\n",
            "[Interact_status: B]\n",
            "   userId interacted_items        negative_items\n",
            "0       1         {11, 12}  {32, 21, 22, 23, 31}\n",
            "1       2     {21, 22, 23}      {32, 11, 12, 31}\n",
            "2       3         {32, 31}  {11, 12, 21, 22, 23}\n",
            "\n",
            "\n",
            "[Interact_status: C]\n",
            "   userId interacted_items        negative_items negative_samples\n",
            "0       1         {11, 12}  {32, 21, 22, 23, 31}     [31, 22, 23]\n",
            "1       2     {21, 22, 23}      {32, 11, 12, 31}     [32, 31, 11]\n",
            "2       3         {32, 31}  {11, 12, 21, 22, 23}     [22, 21, 11]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LTurMwNYXB9r"
      },
      "source": [
        "interated_items: 시청한 영화리스트\n",
        "\n",
        "negative_items: 시청하지 않은 영화리스트\n",
        "\n",
        "실제는 99개의 샘플링을 하지만, 여기서는 예시 데이터가 적기 때문에 3개만 샘플링 -> negative_samples\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BE_FfiyyaMsv"
      },
      "source": [
        "# Section 2: train\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NHobU8B5Xbpm",
        "outputId": "9a815bf2-729c-410a-f3a4-91827205c7a4"
      },
      "source": [
        "df['rank_latest'] = df.groupby(['userId'])['timestamp'].rank(method='first', ascending=False)\n",
        "print(df)\n",
        "print('\\n')\n",
        "print(\"[Train Data]\")\n",
        "train = df[df['rank_latest']>1]\n",
        "print(train)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "   userId  movieId  rating  timestamp  rank_latest\n",
            "0       1       11       2      13142          2.0\n",
            "1       1       12       5      24132          1.0\n",
            "2       2       21       3      35123          1.0\n",
            "3       2       22       4      22121          3.0\n",
            "4       2       23       1      23111          2.0\n",
            "5       3       31       2      11312          2.0\n",
            "6       3       32       1      13412          1.0\n",
            "\n",
            "\n",
            "[Train Data]\n",
            "   userId  movieId  rating  timestamp  rank_latest\n",
            "0       1       11       2      13142          2.0\n",
            "3       2       22       4      22121          3.0\n",
            "4       2       23       1      23111          2.0\n",
            "5       3       31       2      11312          2.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-IJX31TZXs_e"
      },
      "source": [
        "1. userId로 group화한 후 timestamp 기준으로 랭킹\n",
        "\n",
        "2. rank_latest 값이 1보다 크면 train 데이터로 분류 (else, test data)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fWsUKkxFaRYc"
      },
      "source": [
        "# Section 3: train_rating"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9-n_CA8_X-5d",
        "outputId": "e3248b6c-31e8-4bdf-c678-fb2ccb262c00"
      },
      "source": [
        "train_rating = pd.merge(train,interact_status[['userId','negative_items']], on='userId')\n",
        "print(\"[Train + Interact_status]\")\n",
        "print(train_rating)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[Train + Interact_status]\n",
            "   userId  movieId  rating  timestamp  rank_latest        negative_items\n",
            "0       1       11       2      13142          2.0  {32, 21, 22, 23, 31}\n",
            "1       2       22       4      22121          3.0      {32, 11, 12, 31}\n",
            "2       2       23       1      23111          2.0      {32, 11, 12, 31}\n",
            "3       3       31       2      11312          2.0  {11, 12, 21, 22, 23}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EneHu8k1YEnx"
      },
      "source": [
        "`train data`와 `interact_status`를 합침 = `train_rating`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nr3yfZeJaYiX"
      },
      "source": [
        "# Section 4: Sampling (num_negatives)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UmFRGNOtYOkX",
        "outputId": "d1476c9e-1d67-4ddd-d14d-a4c011f45da3"
      },
      "source": [
        "train_rating['negatives'] = train_rating['negative_items'].apply(lambda x: random.sample(x, 4))\n",
        "print(train_rating)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "   userId  movieId  rating  ...  rank_latest        negative_items         negatives\n",
            "0       1       11       2  ...          2.0  {32, 21, 22, 23, 31}  [31, 32, 23, 21]\n",
            "1       2       22       4  ...          3.0      {32, 11, 12, 31}  [12, 11, 31, 32]\n",
            "2       2       23       1  ...          2.0      {32, 11, 12, 31}  [11, 31, 32, 12]\n",
            "3       3       31       2  ...          2.0  {11, 12, 21, 22, 23}  [23, 12, 22, 21]\n",
            "\n",
            "[4 rows x 7 columns]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ZwhXjqIZQuY"
      },
      "source": [
        "train_rating 에서 num_negative(here, 4)만큼 negative sample 뽑음"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JFqfEXoecJu2"
      },
      "source": [
        "# Section 5: Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YJDJRcd2cFmL",
        "outputId": "bf57d590-ad8e-46ad-ff7c-5a5deedca87d"
      },
      "source": [
        "for row in train_rating.itertuples(index=False):\n",
        "  print(row)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Pandas(userId=1, movieId=11, rating=2, timestamp=13142, rank_latest=2.0, negative_items={32, 21, 22, 23, 31}, negatives=[31, 32, 23, 21])\n",
            "Pandas(userId=2, movieId=22, rating=4, timestamp=22121, rank_latest=3.0, negative_items={32, 11, 12, 31}, negatives=[12, 11, 31, 32])\n",
            "Pandas(userId=2, movieId=23, rating=1, timestamp=23111, rank_latest=2.0, negative_items={32, 11, 12, 31}, negatives=[11, 31, 32, 12])\n",
            "Pandas(userId=3, movieId=31, rating=2, timestamp=11312, rank_latest=2.0, negative_items={11, 12, 21, 22, 23}, negatives=[23, 12, 22, 21])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5E5kmp0hcPYj",
        "outputId": "6c3afb0b-f5bb-4d4e-a63b-f7a5efe00295"
      },
      "source": [
        "users, items, ratings = [], [], []\n",
        "for row in train_rating.itertuples():\n",
        "  users.append(int(row.userId))\n",
        "  items.append(int(row.movieId))\n",
        "  ratings.append(int(float(row.rating)))\n",
        "  for i in range(4):\n",
        "    users.append(int(row.userId))\n",
        "    items.append(int(row.negatives[i]))\n",
        "    ratings.append(float(0))\n",
        "print('[RESULT]')\n",
        "print('users: {}'.format(users))\n",
        "print('items: {}'.format(items))\n",
        "print('ratings: {}'.format(ratings))"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[RESULT]\n",
            "users: [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3]\n",
            "items: [11, 31, 32, 23, 21, 22, 12, 11, 31, 32, 23, 11, 31, 32, 12, 31, 23, 12, 22, 21]\n",
            "ratings: [2, 0.0, 0.0, 0.0, 0.0, 4, 0.0, 0.0, 0.0, 0.0, 1, 0.0, 0.0, 0.0, 0.0, 2, 0.0, 0.0, 0.0, 0.0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W4Oaj2AkWrPQ"
      },
      "source": [
        "import torch\n",
        "from torch.utils.data import DataLoader, Dataset\n",
        "\n",
        "class UserItemRatingDataset(Dataset):\n",
        "  def __init__(self, user_tensor, item_tensor, target_tensor):\n",
        "    self.user_tensor = user_tensor\n",
        "    self.item_tensor = item_tensor\n",
        "    self.target_tensor = target_tensor\n",
        "  def __getitem__(self, index):\n",
        "    return self.user_tensor[index], self.item_tensor[index], self.target_tensor[index]\n",
        "  def __len__(self):\n",
        "    return self.user_tensor.size(0)"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fOostUysYb74",
        "outputId": "a5852c2d-b281-4c5d-8e73-c803d1203f13"
      },
      "source": [
        "dataset = UserItemRatingDataset(user_tensor = torch.LongTensor(users), \n",
        "                                item_tensor = torch.LongTensor(items), \n",
        "                                target_tensor = torch.FloatTensor(ratings))\n",
        "#shuffle = True\n",
        "for batch_id, batch in enumerate(DataLoader(dataset, batch_size=1, shuffle=False)):\n",
        "  user, item, rating = batch[0], batch[1], batch[2]\n",
        "  print('user: {}, item: {}, rating: {}'.format(user,item,rating))"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "user: tensor([1]), item: tensor([11]), rating: tensor([2.])\n",
            "user: tensor([1]), item: tensor([31]), rating: tensor([0.])\n",
            "user: tensor([1]), item: tensor([32]), rating: tensor([0.])\n",
            "user: tensor([1]), item: tensor([23]), rating: tensor([0.])\n",
            "user: tensor([1]), item: tensor([21]), rating: tensor([0.])\n",
            "user: tensor([2]), item: tensor([22]), rating: tensor([4.])\n",
            "user: tensor([2]), item: tensor([12]), rating: tensor([0.])\n",
            "user: tensor([2]), item: tensor([11]), rating: tensor([0.])\n",
            "user: tensor([2]), item: tensor([31]), rating: tensor([0.])\n",
            "user: tensor([2]), item: tensor([32]), rating: tensor([0.])\n",
            "user: tensor([2]), item: tensor([23]), rating: tensor([1.])\n",
            "user: tensor([2]), item: tensor([11]), rating: tensor([0.])\n",
            "user: tensor([2]), item: tensor([31]), rating: tensor([0.])\n",
            "user: tensor([2]), item: tensor([32]), rating: tensor([0.])\n",
            "user: tensor([2]), item: tensor([12]), rating: tensor([0.])\n",
            "user: tensor([3]), item: tensor([31]), rating: tensor([2.])\n",
            "user: tensor([3]), item: tensor([23]), rating: tensor([0.])\n",
            "user: tensor([3]), item: tensor([12]), rating: tensor([0.])\n",
            "user: tensor([3]), item: tensor([22]), rating: tensor([0.])\n",
            "user: tensor([3]), item: tensor([21]), rating: tensor([0.])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ma5GCwVtYdpS",
        "outputId": "133dc018-e6a0-4aa3-fee2-1222438d4e32"
      },
      "source": [
        "#shuffle = True\n",
        "for batch_id, batch in enumerate(DataLoader(dataset, batch_size=3, shuffle=False)):\n",
        "  user, item, rating = batch[0], batch[1], batch[2]\n",
        "  print('user: {}, item: {}, rating: {}'.format(user,item,rating))"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "user: tensor([1, 1, 1]), item: tensor([11, 31, 32]), rating: tensor([2., 0., 0.])\n",
            "user: tensor([1, 1, 2]), item: tensor([23, 21, 22]), rating: tensor([0., 0., 4.])\n",
            "user: tensor([2, 2, 2]), item: tensor([12, 11, 31]), rating: tensor([0., 0., 0.])\n",
            "user: tensor([2, 2, 2]), item: tensor([32, 23, 11]), rating: tensor([0., 1., 0.])\n",
            "user: tensor([2, 2, 2]), item: tensor([31, 32, 12]), rating: tensor([0., 0., 0.])\n",
            "user: tensor([3, 3, 3]), item: tensor([31, 23, 12]), rating: tensor([2., 0., 0.])\n",
            "user: tensor([3, 3]), item: tensor([22, 21]), rating: tensor([0., 0.])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jvXriZgVa0Ru",
        "outputId": "64b1aeba-4dbd-4ca8-903d-cca66670c51f"
      },
      "source": [
        "for batch_id, batch in enumerate(DataLoader(dataset, batch_size=3, shuffle=True)):\n",
        "  user, item, rating = batch[0], batch[1], batch[2]\n",
        "  print('user: {}, item: {}, rating: {}'.format(user,item,rating))"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "user: tensor([1, 2, 2]), item: tensor([21, 11, 22]), rating: tensor([0., 0., 4.])\n",
            "user: tensor([2, 2, 1]), item: tensor([12, 11, 23]), rating: tensor([0., 0., 0.])\n",
            "user: tensor([1, 3, 2]), item: tensor([31, 31, 23]), rating: tensor([0., 2., 1.])\n",
            "user: tensor([2, 2, 1]), item: tensor([32, 31, 11]), rating: tensor([0., 0., 2.])\n",
            "user: tensor([2, 2, 3]), item: tensor([31, 12, 22]), rating: tensor([0., 0., 0.])\n",
            "user: tensor([1, 3, 2]), item: tensor([32, 21, 32]), rating: tensor([0., 0., 0.])\n",
            "user: tensor([3, 3]), item: tensor([12, 23]), rating: tensor([0., 0.])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SO5QMOHoOd62"
      },
      "source": [
        "# NCF\n",
        "## NCF_official\n",
        "```python3\n",
        "for epoch in xrange(num_epochs):\n",
        "  t1 = time()\n",
        "  user_input, item_input, labels = get_train_instances(train, num_negatives)\n",
        "  #Training\n",
        "  hist = model.fit([np.array(user_input), np.array(item_input)], np.array(labels), batch_size = batch_size, nb_epoch = 1, verbose = 0, shuffle = True)\n",
        "```\n",
        "\n",
        "## NCF-PT_ejlee\n",
        "#### train_an_epoch\n",
        "```python3\n",
        "def train_an_epoch(self, train_loader, epoch_id):\n",
        "    assert hasattr(self, 'model'), 'Please specify the exact model !'\n",
        "    self.model.train()\n",
        "    total_loss = 0\n",
        "    for batch_id, batch in enumerate(train_loader):\n",
        "        assert isinstance(batch[0], torch.LongTensor)\n",
        "        user, item, rating = batch[0], batch[1], batch[2]\n",
        "        rating = rating.float()\n",
        "        loss = self.train_single_batch(user, item, rating)\n",
        "        print('[Training Epoch {}] Batch {}, Loss {}'.format(epoch_id, batch_id, loss))\n",
        "        total_loss += loss\n",
        "    self._writer.add_scalar('model/loss', total_loss, epoch_id)\n",
        "```\n",
        "### train_single_batch\n",
        "```python3\n",
        "def train_single_batch(self, users, items, ratings):\n",
        "    assert hasattr(self, 'model'), 'Please specify the exact model !'\n",
        "    if self.config['use_cuda'] is True:\n",
        "        users, items, ratings = users.cuda(), items.cuda(), ratings.cuda()\n",
        "    self.opt.zero_grad()\n",
        "    ratings_pred = self.model(users, items)\n",
        "    loss = self.crit(ratings_pred.view(-1), ratings)\n",
        "    loss.backward()\n",
        "    self.opt.step()\n",
        "    loss = loss.item()\n",
        "    return loss\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wLVFfISbSXZj"
      },
      "source": [
        "# NGCF\n",
        "## NGCF-PT_ejlee\n",
        "### train\n",
        "```python3\n",
        "def train(model, data_generator, optimizer):\n",
        "    model.train()\n",
        "    n_batch = data_generator.n_train // data_generator.batch_size + 1\n",
        "    running_loss=0\n",
        "    for _ in range(n_batch):\n",
        "        u, i, j = data_generator.sample()\n",
        "        optimizer.zero_grad()\n",
        "        loss = model(u,i,j)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item()\n",
        "    return running_loss\n",
        "```\n",
        "### data_generator.sample()\n",
        "```\n",
        "users = rd.sample(exist_users, batch_size)\n",
        "pos_items = rd.sample((Movies watched by 'u'), batch_size)\n",
        "neg_items = rd.sample((Movies unwatched by 'u'), batch_size)\n",
        "```\n",
        "Example\n",
        "- users: `[1,3]`\n",
        "- pos_items: `[[12,16],[32,37]]`\n",
        "- neg_items: `[[27,58], [45,59]]`\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wRxqTUvxUW3a"
      },
      "source": [
        "# NCF vs NGCF\n",
        "\n",
        "user 1개에 대해서 \n",
        "\n",
        "NCF (num_negatives=4)\n",
        "- users : `[1,1,1,1,1]`\n",
        "- items : `[11,31,22,25,37]`\n",
        "- ratings : `[2,0,0,0,0]`\n",
        "```\n",
        "self.model(users,items)\n",
        "```\n",
        "> batch_size = 3일 때, \n",
        "> `user 3 item 3 rating(label) 3`\n",
        "> \n",
        "> `user: tensor([1, 2, 2]), item: tensor([21, 11, 22]), rating: tensor([0., 0., 4.])`\n",
        "\n",
        "\n",
        "NGCF (batch_size = 3)\n",
        "- users : `[1,2,3]`\n",
        "- pos_items : `[[11,12,16],[21,24,28],[31,33,32]]`\n",
        "- neg_items : `[[32,37,41],[11,14,31],[21,24,28]]`\n",
        "```\n",
        "model(users, pos_items, neg_items)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yJ8lN9UuXiqh"
      },
      "source": [
        "# Solution\n",
        "\n",
        " "
      ]
    }
  ]
}