bpr_mf.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use MovieLens 1M dataset,     \n",
    "more details can be found at: http://grouplens.org/datasets/movielens/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_u_id: 6040\n",
      "max_i_id: 3952\n"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "import tensorflow as tf\n",
    "import os\n",
    "import random\n",
    "from collections import defaultdict\n",
    "\n",
    "def load_data(data_path):\n",
    "    '''\n",
    "    As for bpr experiment, all ratings are removed.\n",
    "    '''\n",
    "    user_ratings = defaultdict(set)\n",
    "    max_u_id = -1\n",
    "    max_i_id = -1\n",
    "    with open(data_path, 'r') as f:\n",
    "        for line in f.readlines():\n",
    "            u, i, _, _ = line.split(\"::\")\n",
    "            u = int(u)\n",
    "            i = int(i)\n",
    "            user_ratings[u].add(i)\n",
    "            max_u_id = max(u, max_u_id)\n",
    "            max_i_id = max(i, max_i_id)\n",
    "    print \"max_u_id:\", max_u_id\n",
    "    print \"max_i_id:\", max_i_id\n",
    "    return max_u_id, max_i_id, user_ratings\n",
    "    \n",
    "\n",
    "data_path = os.path.join('/home/hadoop/data/movielens', 'ratings.dat')\n",
    "user_count, item_count, user_ratings = load_data(data_path)\n",
    "\n",
    "\n",
    "def generate_test(user_ratings):\n",
    "    '''\n",
    "    for each user, random select one of his(her) rating into test set\n",
    "    '''\n",
    "    user_test = dict()\n",
    "    for u, i_list in user_ratings.items():\n",
    "        user_test[u] = random.sample(user_ratings[u], 1)[0]\n",
    "    return user_test\n",
    "\n",
    "user_ratings_test = generate_test(user_ratings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def generate_train_batch(user_ratings, user_ratings_test, item_count, batch_size=512):\n",
    "    '''\n",
    "    uniform sampling (user, item_rated, item_not_rated)\n",
    "    '''\n",
    "    t = []\n",
    "    for b in xrange(batch_size):\n",
    "        u = random.sample(user_ratings.keys(), 1)[0]\n",
    "        i = random.sample(user_ratings[u], 1)[0]\n",
    "        while i == user_ratings_test[u]:\n",
    "            i = random.sample(user_ratings[u], 1)[0]\n",
    "        \n",
    "        j = random.randint(1, item_count)\n",
    "        while j in user_ratings[u]:\n",
    "            j = random.randint(1, item_count)\n",
    "        t.append([u, i, j])\n",
    "    return numpy.asarray(t)\n",
    "\n",
    "def generate_test_batch(user_ratings, user_ratings_test, item_count):\n",
    "    '''\n",
    "    for an user u and an item i rated by u, \n",
    "    generate pairs (u,i,j) for all item j which u has't rated\n",
    "    it's convinent for computing AUC score for u\n",
    "    '''\n",
    "    for u in user_ratings.keys():\n",
    "        t = []\n",
    "        i = user_ratings_test[u]\n",
    "        for j in xrange(1, item_count+1):\n",
    "            if not (j in user_ratings[u]):\n",
    "                t.append([u, i, j])\n",
    "        yield numpy.asarray(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def bpr_mf(user_count, item_count, hidden_dim):\n",
    "    u = tf.placeholder(tf.int32, [None])\n",
    "    i = tf.placeholder(tf.int32, [None])\n",
    "    j = tf.placeholder(tf.int32, [None])\n",
    "\n",
    "    with tf.device(\"/cpu:0\"):\n",
    "        user_emb_w = tf.get_variable(\"user_emb_w\", [user_count+1, hidden_dim], \n",
    "                            initializer=tf.random_normal_initializer(0, 0.1))\n",
    "        item_emb_w = tf.get_variable(\"item_emb_w\", [item_count+1, hidden_dim], \n",
    "                                initializer=tf.random_normal_initializer(0, 0.1))\n",
    "        item_b = tf.get_variable(\"item_b\", [item_count+1, 1], \n",
    "                                initializer=tf.constant_initializer(0.0))\n",
    "        \n",
    "        u_emb = tf.nn.embedding_lookup(user_emb_w, u)\n",
    "        i_emb = tf.nn.embedding_lookup(item_emb_w, i)\n",
    "        i_b = tf.nn.embedding_lookup(item_b, i)\n",
    "        j_emb = tf.nn.embedding_lookup(item_emb_w, j)\n",
    "        j_b = tf.nn.embedding_lookup(item_b, j)\n",
    "    \n",
    "    # MF predict: u_i > u_j\n",
    "    x = i_b - j_b + tf.reduce_sum(tf.mul(u_emb, (i_emb - j_emb)), 1, keep_dims=True)\n",
    "    \n",
    "    # AUC for one user:\n",
    "    # reasonable iff all (u,i,j) pairs are from the same user\n",
    "    # \n",
    "    # average AUC = mean( auc for each user in test set)\n",
    "    mf_auc = tf.reduce_mean(tf.to_float(x > 0))\n",
    "    \n",
    "    l2_norm = tf.add_n([\n",
    "            tf.reduce_sum(tf.mul(u_emb, u_emb)), \n",
    "            tf.reduce_sum(tf.mul(i_emb, i_emb)),\n",
    "            tf.reduce_sum(tf.mul(j_emb, j_emb))\n",
    "        ])\n",
    "    \n",
    "    regulation_rate = 0.0001\n",
    "    bprloss = regulation_rate * l2_norm - tf.reduce_mean(tf.log(tf.sigmoid(x)))\n",
    "    \n",
    "    train_op = tf.train.GradientDescentOptimizer(0.01).minimize(bprloss)\n",
    "    return u, i, j, mf_auc, bprloss, train_op"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  1\n",
      "bpr_loss:  0.717820626124\n",
      "test_loss:  0.944949 test_auc:  0.635838932041\n",
      "\n",
      "epoch:  2\n",
      "bpr_loss:  0.705865208436\n",
      "test_loss:  0.931426 test_auc:  0.706418683048\n",
      "\n",
      "epoch:  3\n",
      "bpr_loss:  0.694599327731\n",
      "test_loss:  0.918148 test_auc:  0.747514513074\n",
      "\n",
      "epoch:  4\n",
      "bpr_loss:  0.684150013811\n",
      "test_loss:  0.905279 test_auc:  0.774131693715\n",
      "\n",
      "epoch:  5\n",
      "bpr_loss:  0.674296607874\n",
      "test_loss:  0.892612 test_auc:  0.792358162586\n",
      "\n",
      "epoch:  6\n",
      "bpr_loss:  0.66479459452\n",
      "test_loss:  0.880452 test_auc:  0.805371120111\n",
      "\n",
      "epoch:  7\n",
      "bpr_loss:  0.656021738486\n",
      "test_loss:  0.868155 test_auc:  0.815137821843\n",
      "\n",
      "epoch:  8\n",
      "bpr_loss:  0.647756577671\n",
      "test_loss:  0.856277 test_auc:  0.822629666476\n",
      "\n",
      "epoch:  9\n",
      "bpr_loss:  0.639781989999\n",
      "test_loss:  0.84503 test_auc:  0.828591293397\n",
      "\n",
      "epoch:  10\n",
      "bpr_loss:  0.632315899365\n",
      "test_loss:  0.834042 test_auc:  0.833400565847\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with tf.Graph().as_default(), tf.Session() as session:\n",
    "    u, i, j, mf_auc, bprloss, train_op = bpr_mf(user_count, item_count, 20)\n",
    "    session.run(tf.initialize_all_variables())\n",
    "    for epoch in range(1, 11):\n",
    "        _batch_bprloss = 0\n",
    "        for k in range(1, 5000): # uniform samples from training set\n",
    "            uij = generate_train_batch(user_ratings, user_ratings_test, item_count)\n",
    "\n",
    "            _bprloss, _ = session.run([bprloss, train_op], \n",
    "                                feed_dict={u:uij[:,0], i:uij[:,1], j:uij[:,2]})\n",
    "            _batch_bprloss += _bprloss\n",
    "        \n",
    "        print \"epoch: \", epoch\n",
    "        print \"bpr_loss: \", _batch_bprloss / k\n",
    "\n",
    "        user_count = 0\n",
    "        _auc_sum = 0.0\n",
    "\n",
    "        # each batch will return only one user's auc\n",
    "        for t_uij in generate_test_batch(user_ratings, user_ratings_test, item_count):\n",
    "\n",
    "            _auc, _test_bprloss = session.run([mf_auc, bprloss],\n",
    "                                    feed_dict={u:t_uij[:,0], i:t_uij[:,1], j:t_uij[:,2]}\n",
    "                                )\n",
    "            user_count += 1\n",
    "            _auc_sum += _auc\n",
    "        print \"test_loss: \", _test_bprloss, \"test_auc: \", _auc_sum/user_count\n",
    "        print \"\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}