BoltzmannMachine.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boltzmann Machines\n",
    "relevant links  \n",
    "https://www.cs.toronto.edu/~hinton/csc321/readings/boltz321.pdf  \n",
    "https://www.cs.toronto.edu/~hinton/absps/guideTR.pdf  \n",
    "http://yann.lecun.com/exdb/publis/pdf/lecun-06.pdf  \n",
    "https://en.wikipedia.org/wiki/Boltzmann_distribution  \n",
    "https://towardsdatascience.com/deep-learning-meets-physics-restricted-boltzmann-machines-part-i-6df5c4918c15  \n",
    "https://skymind.ai/wiki/restricted-boltzmann-machine  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "use movie ratings dataset  \n",
    "https://grouplens.org/datasets/movielens/  \n",
    "http://files.grouplens.org/datasets/movielens/ml-1m-README.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.parallel\n",
    "import torch.optim as optim\n",
    "import torch.utils.data\n",
    "from torch.autograd import Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RBM(object):\n",
    "    \"\"\"\n",
    "        Description:\n",
    "            RBM based neural network\n",
    "        \n",
    "        functions:\n",
    "            __init__(self, num_visible, num_hidden)\n",
    "            sample_hidden(self, visible)\n",
    "            sample_visible(self, hidden)\n",
    "        \n",
    "        variables:\n",
    "            num_visible (nodes)\n",
    "            num_hidden (nodes)\n",
    "            \n",
    "    \"\"\"\n",
    "    def __init__(self, num_visible, num_hidden):\n",
    "        \"\"\"\n",
    "            Description:\n",
    "                initialize weights and bias\n",
    "            \n",
    "            Parameters:\n",
    "                num_visible: number of visible nodes\n",
    "                num_hidden:  number of hidden nodes\n",
    "                \n",
    "            Returns:\n",
    "                None\n",
    "        \"\"\"\n",
    "        self.weights = torch.randn(num_hidden, num_visible)\n",
    "        self.alpha   = torch.randn(1, num_hidden)\n",
    "        self.beta    = torch.randn(1, num_visible)\n",
    "        \n",
    "    def sample_hidden(self, visible):\n",
    "        \"\"\"\n",
    "            Description:\n",
    "                calculates the probability the hidden node will\n",
    "                be activated\n",
    "            \n",
    "            Parameters:\n",
    "                visible: <vector> set of visible node values\n",
    "                \n",
    "            Returns:\n",
    "                P_hidden: <vector> probability of the hidden\n",
    "                    nodes being activated \n",
    "                D_hidden: <vector> sampled distribution (0s & 1s)\n",
    "                \n",
    "        \"\"\"\n",
    "        weight   = torch.mm(visible, self.weights.t())\n",
    "        activate = weight + self.alpha.expand_as(weight)\n",
    "        P_hidden = torch.sigmoid(activate)\n",
    "        D_hidden = torch.bernoulli(P_hidden)\n",
    "        \n",
    "        return P_hidden, D_hidden\n",
    "        \n",
    "    def sample_visible(self, hidden):\n",
    "        \"\"\"\n",
    "            Description:\n",
    "                calculates the probability the visible node will\n",
    "                be activated\n",
    "            \n",
    "            Parameters:\n",
    "                hidden: <vector> set of hidden node values\n",
    "                \n",
    "            Returns:\n",
    "                P_visible: <vector> probability of the visible\n",
    "                    nodes being activated \n",
    "                D_visible: <vector> sampled distribution (0s & 1s)\n",
    "        \"\"\"\n",
    "        weight    = torch.mm(hidden, self.weights)\n",
    "        activate  = weight + self.beta.expand_as(weight)\n",
    "        P_visible = torch.sigmoid(activate)\n",
    "        D_visible = torch.bernoulli(P_visible)\n",
    "        \n",
    "        return P_visible, D_visible\n",
    "    \n",
    "    def train(self, input_nodes, P_input_nodes, k_nodes, P_k_nodes):\n",
    "        \"\"\"\n",
    "            Description:\n",
    "                Implemented contrastive divergence to approximate the \n",
    "                log likelihood gradients\n",
    "                \n",
    "            Parameters:\n",
    "                input_nodes:   <vector>\n",
    "                P_input_nodes: <vector>\n",
    "                k_nodes:       <vector>\n",
    "                P_k_nodes:     <vector>\n",
    "                \n",
    "            Returns:\n",
    "        \"\"\"\n",
    "        self.weights += (torch.mm(input_nodes.t(), P_input_nodes) - torch.mm(k_nodes.t(), P_k_nodes)).t()\n",
    "        self.beta    += torch.sum((input_nodes - k_nodes), 0) # trick keeps in proper dimension\n",
    "        self.alpha   += torch.sum((P_input_nodes - P_k_nodes))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "get the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Animation|Children's|Comedy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children's|Fantasy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Grumpier Old Men (1995)</td>\n",
       "      <td>Comedy|Romance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Waiting to Exhale (1995)</td>\n",
       "      <td>Comedy|Drama</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Father of the Bride Part II (1995)</td>\n",
       "      <td>Comedy</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0                                   1                             2\n",
       "0  1                    Toy Story (1995)   Animation|Children's|Comedy\n",
       "1  2                      Jumanji (1995)  Adventure|Children's|Fantasy\n",
       "2  3             Grumpier Old Men (1995)                Comedy|Romance\n",
       "3  4            Waiting to Exhale (1995)                  Comedy|Drama\n",
       "4  5  Father of the Bride Part II (1995)                        Comedy"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movies = pd.read_csv('datasets/ml-1m/movies.dat', sep='::', header=None, engine='python', encoding='latin-1')\n",
    "# MovieID::Title::Genres\n",
    "movies.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>F</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "      <td>48067</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>M</td>\n",
       "      <td>56</td>\n",
       "      <td>16</td>\n",
       "      <td>70072</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>M</td>\n",
       "      <td>25</td>\n",
       "      <td>15</td>\n",
       "      <td>55117</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>M</td>\n",
       "      <td>45</td>\n",
       "      <td>7</td>\n",
       "      <td>02460</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>M</td>\n",
       "      <td>25</td>\n",
       "      <td>20</td>\n",
       "      <td>55455</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0  1   2   3      4\n",
       "0  1  F   1  10  48067\n",
       "1  2  M  56  16  70072\n",
       "2  3  M  25  15  55117\n",
       "3  4  M  45   7  02460\n",
       "4  5  M  25  20  55455"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "users = pd.read_csv('datasets/ml-1m/users.dat', sep='::', header=None, engine='python', encoding='latin-1')\n",
    "# UserID::Gender::Age::Occupation::Zip-code\n",
    "users.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1193</td>\n",
       "      <td>5</td>\n",
       "      <td>978300760</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>661</td>\n",
       "      <td>3</td>\n",
       "      <td>978302109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>914</td>\n",
       "      <td>3</td>\n",
       "      <td>978301968</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>3408</td>\n",
       "      <td>4</td>\n",
       "      <td>978300275</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>2355</td>\n",
       "      <td>5</td>\n",
       "      <td>978824291</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0     1  2          3\n",
       "0  1  1193  5  978300760\n",
       "1  1   661  3  978302109\n",
       "2  1   914  3  978301968\n",
       "3  1  3408  4  978300275\n",
       "4  1  2355  5  978824291"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratings = pd.read_csv('datasets/ml-1m/ratings.dat', sep='::', header=None, engine='python', encoding='latin-1')\n",
    "# UserID::MovieID::Rating::Timestamp\n",
    "ratings.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "train-test set prep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[        1,        10,         3, 875693118],\n",
       "       [        1,        12,         5, 878542960],\n",
       "       [        1,        14,         5, 874965706],\n",
       "       [        1,        17,         3, 875073198],\n",
       "       [        1,        20,         4, 887431883]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train = pd.read_csv('datasets/ml-100k/u1.base', delimiter='\\t')\n",
    "X_test  = pd.read_csv('datasets/ml-100k/u1.test', delimiter='\\t')\n",
    "\n",
    "X_train = np.array(X_train, dtype='int')\n",
    "X_test  = np.array(X_test, dtype='int')\n",
    "\n",
    "# UserID::MovieID::Rating::Timestamp\n",
    "X_test[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "user_count:   943\n",
      "movie_count:  1682\n"
     ]
    }
   ],
   "source": [
    "user_count  = int(max(max(X_train[:,0]), max(X_test[:,0])))\n",
    "movie_count = int(max(max(X_train[:,1]), max(X_test[:,1])))\n",
    "print(\"user_count:  \", user_count)\n",
    "print(\"movie_count: \", movie_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "transform data into matrix with users in rows and movies in columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert(X, M, N):\n",
    "    \"\"\"\n",
    "        converts into list of list for pytorch input\n",
    "               : { movie 1, movie 2, ... , movie N}\n",
    "        {\n",
    "         user 1    rating   rating         rating\n",
    "         user 2    rating   rating         rating\n",
    "         ...\n",
    "         user M    rating   rating         rating\n",
    "         }\n",
    "    \"\"\"\n",
    "    X_new = []\n",
    "    \n",
    "    for user_id in range(1, M+1):\n",
    "        movies  = X[:,1][X[:,0] == user_id]\n",
    "        ratings = X[:,2][X[:,0] == user_id]\n",
    "        \n",
    "        user_ratings = np.ones(N)*-1\n",
    "        user_ratings[movies-1] = ratings\n",
    "        X_new.append(list(user_ratings))\n",
    "    \n",
    "    return X_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = convert(X_train, user_count, movie_count)\n",
    "X_test  = convert(X_test, user_count, movie_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create torch tensors  \n",
    "convert ratings into binary 1:like 0:dislike"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_trainT = torch.FloatTensor(X_train)\n",
    "X_testT  = torch.FloatTensor(X_test)\n",
    "\n",
    "X_trainT[X_trainT == 1] = 0\n",
    "X_trainT[X_trainT == 2] = 0\n",
    "X_trainT[X_trainT >= 3] = 1\n",
    "\n",
    "X_testT[X_testT == 1] = 0\n",
    "X_testT[X_testT == 2] = 0\n",
    "X_testT[X_testT >= 3] = 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the RBM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_visible = movie_count\n",
    "num_hidden  = 96\n",
    "batch_size  = 72\n",
    "num_epochs  = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1\tloss: tensor(0.3067)\n",
      "epoch: 2\tloss: tensor(0.2506)\n",
      "epoch: 3\tloss: tensor(0.2496)\n",
      "epoch: 4\tloss: tensor(0.2485)\n",
      "epoch: 5\tloss: tensor(0.2493)\n",
      "epoch: 6\tloss: tensor(0.2468)\n",
      "epoch: 7\tloss: tensor(0.2472)\n",
      "epoch: 8\tloss: tensor(0.2462)\n",
      "epoch: 9\tloss: tensor(0.2489)\n",
      "epoch: 10\tloss: tensor(0.2468)\n"
     ]
    }
   ],
   "source": [
    "rbm = RBM(num_visible, num_hidden)\n",
    "\n",
    "for epoch in range(1, num_epochs+1):\n",
    "    loss = 0\n",
    "    cntr = 0.0\n",
    "    \n",
    "    for user_id in range(0, user_count - batch_size, batch_size):\n",
    "        input_nodes = X_trainT[user_id:user_id+batch_size]\n",
    "        k_nodes     = X_trainT[user_id:user_id+batch_size]\n",
    "        P_input,_   = rbm.sample_hidden(input_nodes)\n",
    "        \n",
    "        for k in range(10): # gibbs sampling\n",
    "            _,k_hidden = rbm.sample_hidden(k_nodes)\n",
    "            _,k_nodes  = rbm.sample_visible(k_hidden)\n",
    "            \n",
    "            k_nodes[input_nodes<0] = -1\n",
    "            \n",
    "        P_nodes,_ = rbm.sample_hidden(k_nodes)\n",
    "        rbm.train(input_nodes, P_input, k_nodes, P_nodes)\n",
    "        loss += torch.mean(torch.abs(input_nodes[input_nodes>=0] - k_nodes[input_nodes>=0]))\n",
    "        cntr += 1.0\n",
    "    \n",
    "    print(\"epoch: \" + str(epoch) + \"\\tloss: \" + str(loss/cntr))\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test the RBM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: tensor(0.2522)\n"
     ]
    }
   ],
   "source": [
    "loss = 0\n",
    "cntr = 0.0\n",
    "\n",
    "for user_id in range(user_count):\n",
    "    input_nodes = X_trainT[user_id:user_id+1]\n",
    "    test_nodes  = X_testT[user_id:user_id+1]\n",
    "    if(len(test_nodes[test_nodes>=0]) > 0):\n",
    "        _,test_hidden = rbm.sample_hidden(input_nodes)\n",
    "        _,input_nodes = rbm.sample_visible(test_hidden)\n",
    "\n",
    "        loss += torch.mean(torch.abs(test_nodes[test_nodes>=0] - input_nodes[test_nodes>=0]))\n",
    "        cntr += 1.0\n",
    "\n",
    "print(\"loss: \" + str(loss/cntr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}