A Hybrid Latent Variable Neural Network Model for Item Recommendation
Michael R. Smith
Department of Computer Science
Brigham Young University
Provo
UT 86402
msmith@axon.cs.byu.edu
Collaborative filtering is used to recommend items to a user without requiring a knowledge of the item itself and tends to outperform other techniques. However, collaborative filtering suffers from the cold-start problem, which occurs when an item has not yet been rated or a user has not rated any items. Incorporating additional information, such as item or user descriptions, into collaborative filtering can address the cold-start problem. In this paper, we present a neural network model with latent input variables (latent neural network or LNN) as a hybrid collaborative filtering technique that addresses the cold-start problem. LNN outperforms a broad selection of content-based filters (which make recommendations based on item descriptions) and other hybrid approaches while maintaining the accuracy of state-of-the-art collaborative filtering techniques. % We compare LNN with . % We find that incorporating item descriptions decreases the error over using content-based filtering or collaborative filtering in isolation. % Another advantage of LNN is that it only trains a single model using the user-item ratings and the item descriptions as opposed to other content-based filtering techniques which create a separate model for each user. % This helps alleviate the cold-start user problem, which is when there is a user that has not rated any items.
nips2014_MG_1.tex
\documentclass{article} % For LaTeX2e
\usepackage{nips14submit_e,times}
\usepackage{hyperref}
\usepackage{url}
\usepackage{amsmath}
\usepackage{algorithm}
\usepackage{algorithmic}
% \documentstyle[nips14submit_09,times,art10]{article} % For LaTeX 2.09

\newenvironment{singlespacedlist}{
\begin{itemize}{}{}
	\setlength{\itemsep}{0pt}
	\setlength{\parskip}{0pt}
	\setlength{\parsep}{0pt}}{\end{itemize}
%\vskip -2mm
}


\title{A Hybrid Latent Variable Neural Network Model for Item Recommendation}


\author{
Michael R. Smith\\
Department of Computer Science\\
Brigham Young University\\
Provo, UT 86402 \\
\texttt{msmith@axon.cs.byu.edu} \\
\And
Tony Martinez \\
Department of Computer Science \\
Brigham Young University \\
Provo, UT 84602 \\
\texttt{martinez@cs.byu.edu} \\
\And
Michael Gashler \\
Department of Computer Science and Computer Engineering \\
University of Arkansas \\
Fayetteville, AR 72701 \\
\texttt{mgashler@uark.edu} \\
}

% The \author macro works with any number of authors. There are two commands
% used to separate the names and addresses of multiple authors: \And and \AND.
%
% Using \And between authors leaves it to \LaTeX{} to determine where to break
% the lines. Using \AND forces a linebreak at that point. So, if \LaTeX{}
% puts 3 of 4 authors names on the first line, and the last on the second
% line, try using \AND instead of \And before the third author name.

\newcommand{\fix}{\marginpar{FIX}}
\newcommand{\new}{\marginpar{NEW}}

\nipsfinalcopy % Uncomment for camera-ready version

\begin{document}


\maketitle

\begin{abstract}
Collaborative filtering is used to recommend items to a user without requiring a knowledge of the item itself and tends to outperform other techniques.
However, collaborative filtering suffers from the \textit{cold-start} problem, which occurs when an item has not yet been rated or a user has not rated any items.
Incorporating additional information, such as item or user descriptions, into collaborative filtering can address the cold-start problem.
In this paper, we present a neural network model with latent input variables (\textit{latent neural network} or LNN) as a hybrid collaborative filtering technique that addresses the cold-start problem.
LNN outperforms a broad selection of content-based filters (which make recommendations based on item descriptions) and other hybrid approaches while maintaining the accuracy of state-of-the-art collaborative filtering techniques.

% We compare LNN with .
% We find that incorporating item descriptions decreases the error over using content-based filtering or collaborative filtering in isolation.
% Another advantage of LNN is that it only trains a single model using the user-item ratings and the item descriptions as opposed to other content-based filtering techniques which create a separate model for each user.
% This helps alleviate the cold-start user problem, which is when there is a user that has not rated any items.
\end{abstract}

\section{Introduction}
% Problem: cold-start item recommendation
% New items appear constantly. How do we recommend them?
% Previous hybrid solutions are often chained together
Modern technology enables users to access an abundance of information.
This deluge of data makes it difficult to sift through it all to find what is desired.
This problem is of particular concern to companies who are trying sell products (e.g. Amazon or Walmart) or recommend movies (e.g. Netflix).
To lessen the severity of information overload, recommender systems help a user find what he or she is looking for. 
Two commonly used classes of recommender systems are content-based filters and collaborative filters.

Content-based filters (CBF) make recommendations based on item/user descriptions and users' ratings of the items.
Creating item/user descriptions that are predictive of how a user will rate an item, however, is not a trivial process.
On the other hand, collaborative filtering (CF) techniques use correlations between users' ratings to infer the rating of unrated items for a user and make recommendations without having to understand the item or user itself.
CF does not depend on item descriptions and tends to produce higher accuracies than CBF.
However, CF suffers from the \textit{cold-start problem} which occurs when an item cannot be recommended unless it is has been rated before (\textit{first-rater problem}) or when a user has not rated any items (\textit{new-user problem}).
%Talk about the importance of the cold-start problem
This is particularly important in domains where new items are frequently added to a set of items and users are more interested in the new items.
For example, many users are more interested, and likely to purchase, new styles of shoes rather than out-dated styles or many users are more interested in watching newly released movies rather than older movies.
Recommending old items has the potential to drive away customers.
In addition, making inappropriate recommendations for new users who have not built a profile can also drive away users.

One approach for addressing the cold-start problem is using a hybrid recommender system that can leverage the advantages of multiple recommendation systems.
Developing hybrid models is a significant research direction \cite{Claypool1999,Schein2002,Li2003,Su2007,Cremonesi2011,Forbes2011,Lin2013}.
% One way to alleviate the cold-start problem is to use a hybrid recommendation system.
% Hybrid recommendation systems leverage the advantages of content-based filtering and collaborative filtering.
Many hybrid approaches combine a content-based filter with a collaborative filter through methods such as averaging the predicted ratings or combining the top recommendations from both techniques \cite{Burke2002}.
% Somewhat surprisingly, there are not many collaborative filtering models that incorporate item and/or user information when computing the ratings for unrated items.
In this paper, we present a neural network model with latent input variables (\textit{latent neural network} or LNN) as a hybrid recommendation algorithm that addresses the cold-start problem.
LNN uses a matrix of item ratings and item/user descriptions to simultaneously train the weights in a neural network and induce a set of latent input variables for matrix factorization.
Using a neural network allows for flexible architecture configurations to model higher-order dependencies in the data.

LNN is based on the idea of generative backpropagation (GenBP) \cite{hinton:generative_backpropagation} and expands upon unsupervised backpropagation (UBP) \cite{Gashler2014}.
Both GenBP and UBP are neural network methods that induce a set of latent input variables.
The latent input variables form an internal representation of observed values.
When the latent input variables are fewer than the observed variables, both methods are dimensionality reduction techniques.
GenBP adjusts its latent inputs while holding the network weights constant.
It has been used to generate labels for images \cite{coheh:label_images_generative_backprop}, and for natural language \cite{bengio:neural_language_generative_backprop}.
% Although these techniques have been used for labeling images and documents, to our knowledge, they have not been used for the application of imputing missing values.
UBP differs from GenBP in that it trains network weights simultaneously with the latent inputs, instead of training the weights as a pre-processing step.
LNN is a further development of UBP that incorporates input features among the latent input variables.
By incorporating user/item descriptions as input features, LNN is able to address the cold-start problem.
We find that LNN outperforms other content-based filters and hybrid filters on the cold-start problem.
Additionally, LNN outperforms its predecessor (UBP) and maintains an accuracy similar to matrix factorization (which cannot handle the cold-start problem) on non-cold-start recommendations.

% In Section \ref{section:relatedwork} we review related work to the LNN and in dealing with the cold-start problem.
% We then formally describe LNN in Section \ref{section:LNN}.
% The results from our experiments are presented in Section \ref{section:results} followed by our conclusions and directions for future work.

\section{Related Work}
\label{section:relatedwork}
% Recommendation systems
% - CBF and CF
% - Pros and cons
% Hybrid systems to address both
Matrix factorization (MF) has become a popular technique, in part due to its effectiveness with the data used in the NetFlix competition \cite{koren:matrix_factorization, Salakhutdinov2007} and is widely considered a state-of-the-art recommendation technique.
MF is a linear dimensionality reduction technique that factors the rating matrix into two much-smaller matrices.
These smaller matrices can then be combined to predict all of the missing ratings in the original matrix.
% It is equivalent to using linear regression to project the data onto its first few principal components.
% Unfortunately, MF is not well-suited for data that exhibits non-linearities.
It was previously shown that MF could be represented with a neural network model involving one hidden layer and linear activation functions \cite{takacs2009scalable}.
By using non-linear activation functions, unsupervised backpropagation (UBP) may be viewed as a non-linear generalization of MF.
UBP is related to nonlinear PCA (NLPCA) that was used as a means of imputing missing values (a task similar to recommending items) \cite{nlpca}.
UBP utilizes three phases for training to initialize the latent variables, the weights of the model and then to update the weights and latent variables simultaneously.
LNN further builds on UBP and NLPCA by integrating item or user descriptions with the latent input variables.

Pure collaborative filtering (CF) techniques are not able to handle the cold-start problem for items or users.
As a result, several hybrid methods have been developed that incorporate item and/or user descriptions into collaborative filtering approaches.
The most common, as surveyed by Burke \cite{Burke2002}, involves using separate CBF and CF techniques and then combining their outputs (i.e. weighted average, combining the output from both techniques, or switching depending on the context) or using the output from one technique as input to another.
Content-boosted collaborative filtering \cite{Melville2004} uses CBF to fill in the missing values in the ratings matrix and then the dense ratings matrix is passed to a collaborative filtering method (in their implementation, a neighbor based CF).
Other work addresses the cold-start problem by build user/item descriptions for later use in a recommendation system \cite{Zhou2011}.
% LNN is a hybrid recommendation system that incorporates item \textit{or} user descriptions in a single model.

\section{Latent Neural Network}
\label{section:LNN}
In this section, we formally describe \textit{latent neural networks} (LNN).
At a high-level, a LNN is a neural network with latent input variables induced using generative backpropagation.
Put simply, generative backpropagation calculates the gradient of the latent inputs with respect to the error and updates them in a manner similar to how the weights are updated in the backpropagation algorithm.

\subsection{Preliminaries}
In order to formally describe LNNs, we define the following terms.
% The relationships between these terms are illustrated graphically in Figure~\ref{fig_ubp}.

\begin{singlespacedlist}
% \begin{itemize}
	\item Let $\mathbf{X}$ be a given $m\times n$ sparse user/item rating matrix, where $m$ is the number of items and $n$ is the number of users.
	\item Let $\mathbf{A}$ be an $m\times a$ matrix, representing the given portion of the item profiles.
	\item Let $\mathbf{V}$ be an $m\times t$ matrix, representing the latent portion of the item profiles.
	\item If $x_{rc}$ is the rating for item $r$ by user $c$ in $\mathbf{X}$, then $\hat{x}_{rc}$ is the predicted rating when $\mathbf{a}_r\in\mathbf{A}$ and $\mathbf{v}_r\in\mathbf{V}$ are concatenated into a single vector $\mathbf{q}_r$ and then fed forward into the LNN.
	\item Let $w_{ij}$ be the weight that feeds from unit $i$ to unit $j$ in the LNN.
	\item For each network unit $i$ on hidden layer $j$, let $\beta_{ji}$ be the net input into the unit, $\alpha_{ji}$ be the output or activation value of the unit, and $\delta_{ji}$ be an error term associated with the unit.
% 	\item Let $f$ be the activation function used in every unit, and let $f'(\beta_{j,i})$ be the derivative of $f$ with respect to $\beta_{j,i}$. In our implementation, we use the logistic function for $f$.
	\item Let $l$ be the number of hidden layers in the LNN.
	\item Let $\mathbf{g}$ be a vector representing the gradient with respect to the weights of the LNN, such that $g_{ij}$ is the component of the gradient that is used to refine $w_{ij}$.
	\item Let $\mathbf{h}$ be a vector representing the gradient with respect to the latent inputs of the LNN, such that $h_i$ is the component of the gradient that is used to refine $v_{ri}\in\mathbf{v}_r$.
% \end{itemize}
\end{singlespacedlist}
We use item descriptions, but user descriptions could easily be used by transposing the $\mathbf{X}$ and using user descriptions instead of item descriptions.

% Using backpropagation to compute $\mathbf{g}$, the gradient with respect to the weights, is a common operation for training MLPs \cite{rumelhart:backpropagation,werbos:backpropagation}.
As using generative backpropagation to compute the gradient with respect to the latent inputs, $\mathbf{h}$, is less commonly used, we provide a derivation of it here.
We compute each $h_i\in\mathbf{h}$ from the presentation of a single element $x_{rc}\in\mathbf{X}$ 
% It could also be derived from the presentation of a full row (which is typically called ``on-line training"), or from the presentation of all of $\mathbf{X}$ (``batch training"), but 
since we assume that $\mathbf{X}$ is typically high-dimensional and sparse.
It is significantly more efficient to train with the presentation of each known element individually.
We begin by defining an error signal for an individual element, $E_{rc}=(x_{rc}-\hat{x}_{rc})^2$, and then express the gradient as the partial derivative of this error signal with respect to each latent input (the non-latent inputs in $\mathbf{A}$ do not change): % as given in Equation~\ref{eq_begin}.
%
\begin{equation}
%	h_i=\frac{\partial \frac{1}{2}\delta_c^2}{\partial v_{r,i}}=\frac{\partial \frac{1}{2}(x_{r,c}-\hat{x}_{r,c})^2}{\partial v_{r,i}}
	h_i=\frac{\partial E_{rc}}{\partial v_{ri}}.
% 	h_i=\frac{\partial \frac{1}{2}(x_{r,c}-\hat{x}_{r,c})^2}{\partial v_{r,i}}.
	\label{eq_begin}
\end{equation}
%
The intrinsic input $v_{ri}$ affects the value of $E_{rc}$ through the net value of a unit ($\beta_{ji}$) and further through the output of a unit ($\alpha_{ji}$).
Using the chain rule, Equation \ref{eq_begin} becomes:
%
\begin{equation}
	h_i=\frac{\partial E_{rc}}{\partial \alpha_{0c}}\frac{\partial \alpha_{0c}}{\partial \beta_{0c}}\frac{\partial \beta_{0c}}{\partial v_{ri}}
\end{equation}
%
where $\alpha_{0c}$ and $\beta_{0c}$ represent, respectively, the output values and the net input values of the output nodes (the $0^{th}$ layer).
The backpropagation algorithm calculates $\frac{\partial E_{rc}}{\partial \alpha_{0c}}\frac{\partial \alpha_{0c}}{\partial \beta_{0c}}$ (which is $\frac{\partial E_{rc}}{\partial \beta_{j,i}}$ for a network unit) as the error term $\delta_{ji}$ associated with a network unit.
Thus, to calculate $h_i$, the only additional calculation to the backpropagation algorithm that needs to be made is $\frac{\partial \beta_{jc}}{\partial v_{ri}}$.
For a single layer perceptron (0 hidden layers):
$$\frac{\partial \beta_{0c}}{\partial v_{ri}} = \frac{\partial}{\partial v_{ri}} \sum_t w_{tc}\: v_{rt}$$ 
which is non-zero only when $t$ equals $i$ and is equal to $w_{ic}$ since the error is being calculated with respect to a single element in $\mathbf{X}$.
When there are no hidden layers ($l=0$) and using the error from a single element $x_{rc}$:
%
\begin{equation}
	h_i=-w_{ic} \delta_c.
	\label{eq_no_hidden}
\end{equation}
%
If there is at least one hidden layer ($l > 0$), then,
$$\frac{\partial \beta_{0c}}{\partial v_{ri}} = \frac{\partial \beta_{0c}}{\partial\boldsymbol{\alpha}_1} \frac{\partial \boldsymbol{\alpha}_1}{\partial \boldsymbol{\beta}_1}\dots\frac{\partial \boldsymbol{\alpha}_l}{\partial \boldsymbol{\beta}_l}\frac{\partial \boldsymbol{\beta}_l}{\partial v_{ri}},$$
where $\boldsymbol{\alpha}_k$ and $\boldsymbol{\beta}_k$ are vectors that represent the output values and the net values for the units in the $k^\text{th}$ hidden layer.
As part of the error term for the units in the $l^\text{th}$ layer, backpropagation calculates $\frac{\partial \beta_{0,c}}{\partial\alpha_1} \frac{\partial \alpha_1}{\partial \beta_1}\dots\frac{\partial \alpha_l}{\partial \beta_l}$ as the error term associated with each network unit.
Thus, the only additional calculation for $h_i$ is:
$$\frac{\partial \boldsymbol{\beta}_{l}}{\partial v_{ri}} = \frac{\partial}{\partial v_{ri}} \sum_j \sum_t w_{jt}\: v_{rt}.$$
As before, $\frac{\partial \boldsymbol{\beta}_{l}}{\partial v_{ri}}$ is non-zero only when $t$ equals $i$.
For networks with at least one hidden layer:
% 
\begin{equation}
	h_i=-\sum_j w_{ij} \delta_j.
	\label{eq_with_hidden}
\end{equation}
% 
Equation~\ref{eq_with_hidden} is a strict generalization of Equation~\ref{eq_no_hidden}.
Equation~\ref{eq_no_hidden} only considers the one output unit, $c$, for which a known target value is being presented, whereas
Equation~\ref{eq_with_hidden} sums over each unit, $j$, into which the intrinsic value $v_{ri}$ feeds.

\subsection{Three-Phase Training}
To integrate generative backpropagation into the training process, LNN uses three phases to train $\mathbf{V}$ and $\mathbf{W}$:
1) the first phase computes an initial estimate for the intrinsic vectors, $\mathbf{V}$,
2) the second phase computes an initial estimate for the network weights, $\mathbf{W}$, and
3) the third phase refines them both together.
All three phases train using stochastic gradient descent. %, which we derive from the classic backpropagation algorithm.
% We now briefly give an intuitive justification for this approach.
% In our initial experimentation, we used the simpler approach of training in a single phase.
% We observed that early during training, the intrinsic point vectors, $\mathbf{v}_i\in\mathbf{V}$, tended to separate into clusters.
% The points in each cluster appeared to be unrelated, as if they were arbitrarily assigned to one of the clusters by their random initialization.
% As training continued, the MLP effectively created a separate mapping for each cluster in the intrinsic representation to the corresponding values in $\mathbf{X}$.
% This effectively places an unnecessary burden on the MLP, because it must learn a separate mapping from each cluster that forms in $\mathbf{V}$ to the expected target values.
In phase 1, the intrinsic vectors are induced while there are no hidden layers to form nonlinear separations among them.
Likewise, phase 2 gives the weights a chance to converge without having to train against moving inputs.
These two preprocessing phases initialize the system (consisting of both intrinsic vectors and weights) to a good initial starting point, such that gradient descent is more likely to find a local optimum of higher quality.
Empirical results comparing three-phase and single-phase training show that three-phase training produces more accurate results than single-phase training, which only refines $\mathbf{V}$ and $\mathbf{W}$ together (see \cite{Gashler2014}).

\begin{algorithm}[tb]
	\caption{LNN($\mathbf{A},\mathbf{X}, \eta', \eta'', \gamma, \lambda$)}
	\label{alg_ubp}
	\begin{algorithmic}[1]
		\STATE Initialize each element in $\mathbf{V}$ with small random values
		\STATE Let $\mathbf{T}$ be the weights of a single-layer perceptron
		\STATE Initialize each element in $\mathbf{T}$ with small random values
% 		\STATE $\eta' \leftarrow 0.01$; $\eta'' \leftarrow 0.0001$; $\gamma \leftarrow 0.00001$; $\lambda \leftarrow 0.0001$
		\STATE $\eta \leftarrow \eta'$; $s'\leftarrow\infty$% \hspace{2in}\emph{Phase 1: Compute initial estimate for $\mathbf{V}$.}
		\WHILE {$\eta > \eta''$}
			\STATE $s\leftarrow$ train\_epoch($\mathbf{A}$,$\mathbf{X},\mathbf{T},\lambda,\textbf{true},0$)
			\STATE {\bf if} $1-s/s'<\gamma$ {\bf then} $\eta \leftarrow \eta / 2$
			\STATE $s'\leftarrow s$
		\ENDWHILE
		\STATE Let $\mathbf{W}$ be the weights of a multi-layer perceptron with $l$ hidden layers, $l \ge 0$
		\STATE Initialize each element in $\mathbf{W}$ with small random values
		\STATE $\eta \leftarrow \eta'$; $s'\leftarrow\infty$% \hspace{2in}\emph{Phase 2: Compute initial estimate for $\mathbf{W}$.}
		\WHILE {$\eta > \eta''$}
			\STATE $s\leftarrow$ train\_epoch($\mathbf{A}$,$\mathbf{X},\mathbf{W},\lambda,\textbf{false},l$)
			\STATE {\bf if} $1-s/s'<\gamma$ {\bf then} $\eta \leftarrow \eta / 2$
			\STATE $s'\leftarrow s$
		\ENDWHILE
		\STATE $\eta \leftarrow \eta'$; $s'\leftarrow\infty$% \hspace{2in}\emph{Phase 3: Refine $\mathbf{V}$ and $\mathbf{W}$ together.}
		\WHILE {$\eta > \eta''$}
			\STATE $s\leftarrow$ train\_epoch($\mathbf{A}$,$\mathbf{X},\mathbf{W},0,\textbf{true},l$)
			\STATE {\bf if} $1-s/s'<\gamma$ {\bf then} $\eta \leftarrow \eta / 2$
			\STATE $s'\leftarrow s$
		\ENDWHILE
		\STATE {\bf return} $\{\mathbf{V},\mathbf{W}\}$
	\end{algorithmic}
\end{algorithm}

Pseudo-code for the LNN algorithm, which trains $\mathbf{V}$ and $\mathbf{W}$ in three phases, is given in Algorithm~\ref{alg_ubp}.
LNN calls the train\_epoch function (shown in Algorithm~\ref{alg_refine}) which performs a single epoch of training.
A detailed description of LNN follows.

Matrices containing the known data values, $\mathbf{X}$, and the item descriptions, $\mathbf{A}$, are passed into LNN along with the parameters $\eta', \eta'', \gamma, \lambda$ (defined below).
LNN returns $\mathbf{V}$ and $\mathbf{W}$.
% $\mathbf{V}$ is a matrix such that each row, $\mathbf{v}_i$, is a low-dimensional representation of the corresponding row, $\mathbf{x}_i$.
$\mathbf{W}$ is a set or ragged matrix containing weight values for an MLP that maps from each $\mathbf{v}_i$ to an approximation of $\mathbf{x}_i\in\mathbf{X}$.
% $\mathbf{v}_i$ may be forward-propagated into this MLP to estimate values for any missing elements in $\mathbf{x}_i$.

{\bf Lines~1-9} perform the first phase of training, which computes an initial estimate for $\mathbf{V}$.
{\bf Lines~1-4} initialize the model variables.
$\mathbf{T}$ represents the weights of a single-layer perceptron and the elements in $\mathbf{T}$ and $\mathbf{V}$ are initialized with small random values.
Our implementation draws values from a Normal distribution with a mean of 0 and a deviation of 0.01.
The single-layer perceptron is a temporary model that is only used in phase 1 to for the initial training of $\mathbf{V}$.
$\eta$ is the learning rate and $s'$ is used to store the previous error score.
As no error has been measured yet, it is initialized to $\infty$.
% 
% {\bf Line~4} sets some heuristic values that we used to detect convergence.
%  that is used during the first two phases to ensure that the weights do not become excessively saturated before the final phase of training.
% No regularization is used in the final phase of training because we want the MLP to ultimately fit the data as closely as possible.
% (Overfit can still be mitigated by limiting the number of hidden units used in the MLP.)
% We used the default heuristic values specified on this line in all of our experiments because tuning them seemed to have little impact on the final results.
% We believe that these values are well-suited for most problems, but could possibly be tuned if necessary.
% 
% {\bf Line~4} sets the learning rate, $\eta$, to the initial value.
% The value $s'$ is used to store the previous error score.
% As no error has yet been measured, it is initialized to $\infty$.
% 
{\bf Lines~5-9} train $\mathbf{V}$ and $\mathbf{T}$ until convergence is detected.
$\mathbf{T}$ may then be discarded.
We note that many techniques could be used to detect convergence.
Our implementation %, uses the approach of dividing half of the training data for a validation set.
decays the learning rate whenever predictions fail to improve by a sufficient amount.
% This simple approch always stops, and it yielded better empirical results than a few other variations that we tried.
Convergence is detected when the learning rate $\eta$ falls below $\eta''$.
$\gamma$ specifies the amount of improvement that is expected after each epoch, or else the learning rate is decayed.
$\lambda$ is the regularization term used in train\_epoch.

{\bf Lines~10-17} perform the second phase of training.
This phase differs from the first phase in two ways: 1) a multilayer perceptron is used instead of a temporary single-layer perceptron, and 2) $\mathbf{V}$ is held constant during this phase.

{\bf Lines~18-23} perform the third phase of training.
In this phase, the same multilayer perceptron that is used in phase 2 is used again, but $\mathbf{V}$ and $\mathbf{W}$ are both refined together.
Also, no regularization is used in the third phase.

\subsection{Stochastic gradient descent}

\begin{algorithm}[tb]
	\caption{train\_epoch($\mathbf{A}$,$\mathbf{X},\mathbf{W},\lambda,p,l$)}
	\label{alg_refine}
	\begin{algorithmic}[1]
		\FOR {{\bf each} known $x_{rc}\in\mathbf{X}$ in random order}
			\STATE $\mathbf{q}_r \leftarrow (\mathbf{v}_r, \mathbf{a}_r)$
			\STATE Compute $\alpha_c$ by forward-propagating $\mathbf{q}_r$ into a multilayer perceptron with weights $\mathbf{W}$
			\STATE $\delta_c\leftarrow (x_{rc}-\alpha_c)f'(\beta_c)$
			\FOR {{\bf each} hidden unit $i$ feeding into output unit $c$}
				\STATE $\delta_i\leftarrow w_{ic} \delta_c f'(\beta_i)$
			\ENDFOR
			\FOR {{\bf each} hidden unit $j$ in an earlier hidden layer (in backward order)}
				\STATE $\delta_j\leftarrow \sum_k w_{jk} \delta_k f'(\beta_j)$
			\ENDFOR
			\FOR {{\bf each} $w_{ij}\in\mathbf{W}$}
				\STATE $g_{ij}\leftarrow -\delta_j \alpha_i$
			\ENDFOR
			\STATE $\mathbf{W} \leftarrow \mathbf{W} - \eta (\mathbf{g} + \lambda\mathbf{W})$
			\IF {$p=\textbf{true}$}
				\FOR {$i$ {\bf from} $0$ {\bf to} $t-1$}
					\STATE {\bf if} $l=0$ {\bf then} $h_i\leftarrow -w_{ic} \delta_c$\\ {\bf else} $h_i\leftarrow -\sum_j w_{ij} \delta_j$
				\ENDFOR
				\STATE $\mathbf{v}_r \leftarrow \mathbf{v}_r - \eta (\mathbf{h} + \lambda\mathbf{v}_r)$
			\ENDIF
		\ENDFOR
		\STATE $s\leftarrow$ measure RMSE with $\mathbf{X}$
		\STATE {\bf return} $s$
	\end{algorithmic}
\end{algorithm}

For completeness, we describe train\_epoch given in Algorithm~\ref{alg_refine}, which performs a single epoch of training by stochastic gradient descent.
This algorithm is very similar to an epoch of traditional backpropagation, except that it presents each element individually, instead of presenting each vector, and it conditionally refines the latent variables, $\mathbf{V}$, as well as the weights, $\mathbf{W}$.

{\bf Line~1} presents each known element $x_{rc}\in\mathbf{X}$ in random order.
{\bf Line~2} concatenates $\mathbf{v}_r$ with the corresponding item description $\mathbf{a}_r$.
{\bf Line~3} computes a predicted value for the presented element given the current $\mathbf{v}_r$.
Note that efficient implementations of line 3 should only propagate values into output unit $r$.
{\bf Lines~4-10} compute an error term for output unit $r$, and each hidden unit in the network.
The activation of the other output units is not computed, so the error on those units is 0.
{\bf Lines~11-14} refine $\mathbf{W}$ by gradient descent.
{\bf Line 15} specifies that $\mathbf{V}$ should only be refined during phases 1 and 3.
{\bf Lines~16-19} refine $\mathbf{V}$ by gradient descent.
{\bf Line~22} computes the root-mean-squared-error of the MLP for each known element in $\mathbf{X}$.

% In order to enable UBP to process nominal (categorical) attributes, we convert such values to a vector representing a membership weight in each category.
% For example, a given value of ``cat" from the value set \{``mouse",``cat",``dog"\} is represented with the vector in  $\langle 0, 1, 0 \rangle$.
% Unknown values in this attribute are converted to 3 unknown real values, requiring the algorithm to make 3 predictions.
% After missing values are imputed, we convert the data back to its original form by finding the mode of each categorical distribution.
% For example, the predicted vector $\langle 0.4, 0.25, 0.35 \rangle$ would be converted to a prediction of ``mouse".

% Doing both allows a model to trade-off between CBF and CF based on the number of items rated.
% - Run these experiments
% What about a new user?
% - Put the value of the latent variable as UNKNOWN

\section{Experimental Results}
\label{section:results}
% Describe the experimental methodology
In this section we present the results from our experiments.
We examine LNN using the MovieLens\footnote{\url{http://www.grouplens.org}} data set from the HetRec2011 workshop \cite{RecSys2011}.
We use this data set because it provides descriptions for the movies in addition to the ratings matrix.
There are few data sets that provide user/item descriptions in addition to the ratings matrix (e.g. the Netflix data only contains user ratings).
Some data sets provide unstructured data such as twitter information or a set of friends on last.fm from which input variables could be created.
As this paper focuses on the performance of LNN rather than feature creation from unstructured data, we chose to use the MovieLens data set.
Also, running state-of-the-art recommendation systems can take a long time -- it was reported that running Bayesian probabilistic MF took 188 hours on the Netflix data \cite{Salakhutdinov2008}.
Using a smaller data set allows for a more extensive evaluation and facilitates cross-validation.
The MovieLens data set contains 2113 users and 10197 movies with 855598 ratings.
On average, there are 405 ratings per user and 84 ratings per movie.
% We randomly remove 20\% of the ratings for testing and train on the remaining 80\%.
% The training ratings matrix has a 97\% sparsity level.
For item descriptions, we use the genre(s) of the movie as a set of binary variables indicating if a movie belongs to one of the 19 genres.
% In addition, we also include the year that the movie was released, and the audience and critic scores from the Rotten Tomatoes movie review system.
% To examine the effect of the number of item features, we consider using item descriptions of only the movie genres and a combination of the genres with the Rotten Tomatoes scores.

% As we use item descriptions, we transpose the rating matrix for LNN to produce latent variables for each item rather than for each user.
We use LNN with and without three phase training.
This is equivalent to a hybrid UBP and hybrid NLPCA technique.
LNN with three phase training is denoted as LNN$_\text{3PT}$.
We compare LNN with several other recommendation systems:
1) content-boosted collaborative filtering (CBCF),
2) content-based filtering (CBF),
3) nonlinear principle component analysis (NLPCA),
4) unsupervised backpropagation (UBP), and
5) matrix factorization (MF).
For each recommendation system, we test several parameter settings.
CBF uses a single learning algorithm to learn the rating preferences of a user.
We experiment using na\"{i}ve Bayes (as is commonly used \cite{Melville2004}), linear regression, a decision tree, and a neural network trained with backpropagation.
The same learning algorithms are also used for CBCF and the number of neighbors ranges from 1 to 64.
For MF, the number of latent variables ranges from 2 to 32 and the regularization term from 0.001 to 0.1.
In addition to the values used for MF for the number of latent variables and the regularization term, the number of nodes in the hidden layer ranges from 0 to 32 for UBP, NLPCA, LNN, and LNN$_\text{3PT}$.
For each experiment, we randomly select 20\% of the ratings as a test set.
We then using 10\% of the training set as a validation set for parameter selection.
Using the selected parameters, we test on the test set and using 10-fold cross-validation.
% We first describe the data that we used for testing and then present the results from training.
% We then examine the performance of the recommendation systems with respect to the sparsity of the data and the cold-start problem.


% \subsection{Description of the Data}


\subsection{Results}
The results comparing LNN with the other recommendation approaches are shown in Table \ref{table:results}.
We report the mean absolute error (MAE) for each approach.
The bold values represent the lowest means within 0.002.
The algorithms that use latent variables are significantly lower than those that do not (CBCF and CBF), thus demonstrating the predictive power of using latent variables for item recommendation.
Latent inputs also allows one to bypass feature engineering -- often a difficult process.

\begin{table}[t]
% todo: the following caption is very vague. What dataset did you use? What should I take away from this--that MF is better?
\caption{The MAE from the investigated recommendation systems on the validation set and the test set.}
% ``genres'' refers to only using the movie genres as item description and ``ratings'' refers to using movie genres and the rotten tomatoes ratings as item descriptions.}
\label{table:results}
\centering
\begin{tabular}{l|cccc|ccc}
 & CBCF & CBF & LNN & LNN$_\text{3PT}$ & MF & NLPCA & UBP \\
\hline
Validation & 0.7709 & 0.8781 & \textbf{0.5885} & \textbf{0.5877} & \textbf{0.5886} & 0.6058 & 0.5942\\
Test & 0.7767 & 0.8831 & \textbf{0.5795} & 0.5810 & \textbf{0.5779} & 0.5971 & 0.5942 \\
% \hline
% \multicolumn{8}{c}{10-fold cross validation}\\
% \hline
10CV & 0.7754 & 0.8695 & \textbf{0.5781} & \textbf{0.5778} & \textbf{0.5760} & 0.5915 & 0.5915 \\
% 100k &  & 1.0472 & 0.7410 & 0.7326 & 0.7832 & 0.7445 & 0.7445 \\
% 1M &  & 0.9983 & 0.6870 & 0.6841 & 0.6670 &  &  \\
% 10M100K &  & 0.9603 &  &  & 0.6084 &  & \\
\end{tabular}

% \begin{tabular}{l|cc|cc}
%  & \multicolumn{2}{c|}{Validation MAE} & \multicolumn{2}{c}{Test MAE}\\
% Alg & genres & ratings & genres & ratings \\
% \hline
% CBCF & 0.7709 & 0.7798 & 0.7767 &  \\
% CB & 0.8781 & 1.0978 & 0.8831 &  1.0819 \\
% LNN\_nopre & 0.5885 & 0.7072 & 0.5795 & 0.7031 \\
% LNN$_\text{3PT}$ & \textbf{0.5877} & 0.7069 & 0.5810 & 0.7052 \\
% \hline
% MF & \multicolumn{2}{c|}{0.5886} & \multicolumn{2}{c}{\textbf{0.5779}} \\
% NLPCA & \multicolumn{2}{c|}{0.6018} & \multicolumn{2}{c}{0.5942} \\
% UBP & \multicolumn{2}{c|}{0.6018} & \multicolumn{2}{c}{0.5942} \\
% \end{tabular}
\end{table}

The addition of the item descriptions to NLPCA and UBP (LNN and LNN$_\text{3PT}$) improves the performance compared to only using the latent variables.
The performance of LNN and LNN$_\text{3PT}$ is similar to matrix factorization, which is widely considered state-of-the-art in recommendation systems when comparing MAE.
The power of LNN and LNN$_\text{3PT}$ comes when faced with the cold-start problem which we address in the following section.
As was discussed previously, MF and other pure collaborative filtering techniques are not able to address the cold-start problem despite being able to perform very well on items that have been rated previously a certain number of times.
(They also suffer from the gray sheep problem which occurs when an item has only been rated a small number of times.)
LNN and LNN$_\text{3PT}$ are capable of addressing the cold-start problem \textit{while} still obtaining similar performance to matrix factorization.

% \begin{table}[t]
% \caption{Sample table title}
% \label{sample-table}
% \begin{center}
% \begin{tabular}{ll}
% \multicolumn{1}{c}{\bf PART}  &\multicolumn{1}{c}{\bf DESCRIPTION}
% \\ \hline \\
% Dendrite         &Input terminal \\
% Axon             &Output terminal \\
% Soma             &Cell body (contains cell nucleus) \\
% \end{tabular}
% \end{center}
% \end{table}

% 
% \subsection{The Sparsity Problem}
% To examine the effects of the sparsity of the ratings matrix, we varied the sparsity level of the ratings matrix by randomly sampling from the training ratings matrix.
% We sampled to produce sparsity levels of 99\%, 98.5\%, 98\%, and 97.5\%.
% For each sparsity level, we sampled 3 times and present the averaged results.
% Again, we found the best parameter settings using cross-validation.

\subsection{Cold Start Problem}
To examine the cold-start problem, we remove the ratings for the top 10 most rated movies individually and collectively.
The number of removed ratings for a single movie ranged from 1263 to 1670 and 15,131 ratings were removed for all top 10.
The recommendation systems were trained using the remaining ratings using the parameter setting found in the previous experiments.
For LNN, predicting a new item poses an additional challenge since the latent variables for the new items have not been induced. % by the LNN.
We find that using 0 values for the latent inputs often produced worse results than CBF.
A CBF creates a model for each user based on item descriptions and corresponding user ratings.
LNN, on the other hand, produces a single model which is beneficial when using all of the ratings because the mutual information between users and items can be shared.
The shared information is contained in the latent variables.
The quality of the latent variables depends on the number of ratings that a user has given and/or an item has received.

\begin{algorithm}[tb]
	\caption{new\_item\_prediction($\mathbf{a}_{newItem}$)}
	\label{alg_prediction}
	\begin{algorithmic}[1]
		\STATE Let $count$ be a map containing the count of how many times each rating was predicted
		\STATE Initialize each element in $count$ to 0
               \STATE $numNeighbors \leftarrow 100$; $distThresh \leftarrow 0$
		\STATE $neighbors \leftarrow$ getNeighbors($\mathbf{a}_{newItem}$, $numNeighbors$)
		\FOR {$i$ {\bf from} 0 {\bf to} $numNeighbors - 1$}
			\STATE $numRatings \leftarrow$ count number of ratings for $neighbors[i]$
			\IF {$numRatings > 50$ \&\& $distance(neighbors[i]) > distsThresh$}
				\STATE $\mathbf{q}_{new} \leftarrow (\mathbf{v}_{neighbors[i]}, \mathbf{a}_{newItem})$
				\STATE $prediction \leftarrow $ rounded prediction of $\mathbf{q}_{new}$
				\STATE $counts[prediction] += numRatings$
			\ENDIF
		\ENDFOR
		\STATE {\bf return} maxIndex($counts$)
	\end{algorithmic}
\end{algorithm}

To compensate for the lack of latent variables for the new items, we utilize the new\_item\_prediction function that takes a vector $\mathbf{a}_{newItem}$ representing the description of the new item and is outlined in Algorithm 3.
At a high level, new\_item\_prediction uses $\mathbf{a}_{newItem}$ to find its nearest neighbors.
The induced latent input variables for each neighbor are concatenated with $\mathbf{a}_{newItem}$ and fed into a trained LNN to predict a rating for the new item.
The weighted mode of the predicted ratings of the new item is then returned.
The rating from each neighbor is weighted according to how many times it has been rated.
By weighting, we mean when selecting the mode from a set of numbers, the predicted rating is added $r$ times to the set where $r$ is the number times that the neighbor item has been rated.
We chose to use the mode rather than the mean because the mode is more robust to outliers and achieves better empirical results on the validation sets in our experimentation.
We next describe new\_item\_prediction in more detail.

{\bf Lines~1-2} initializes a counter that keeps track of how many times a rating has been predicted for the new item and initializes all values to 0.
{\bf Line~3} initializes the number of nearest neighbors to search for to 100 and sets the distance threshold to 0.
We chose 100 neighbors because it was generally more than enough neighbors to produce good results.
As we used binary item descriptions of movie genres, we only considered using the latent variables from items that have the same genre(s) (has a distance of 0).
These values come into play in {\bf line 7} where an item is not used if its distance is greater than $distThresh$ (in this case 0), and if an item has not been rated at least 50 times.
The value of 50 was chosen based on the evaluation of a content-based predictor \cite{Mitchell1997ML}.
The number of times that an item has been rated helps to determine the quality of the induced latent variables for an item and provides a confidence level for latent variables.
{\bf Line~4} finds the closest neighbors and inserts their indexes into an array.
{\bf Lines~5-10} count the number of times that each rating is predicted weighted by the number of times that the item has been rated.
We use a linear rating such that the prediction for an item that has been rated 100 times will count for 100 ratings of that predicted value.
This helps to discount items that have only been rated a few times and whose latent variables may not be set to good values.
{\bf Line~13} returns the index (rating) that has the max count (i.e. the mode).

% To experiment with recommending new items, we removed the top 10 most rated items from the data set individually and collectively.
% We then trained using the the data set with ratings for the movie(s) removed and tested on the removed ratings.
The results for recommending new items using new\_item\_prediction are provided in Table \ref{table:newItems}.
The values at the top of the table correspond to the movie id in the MovieLens data set.
The bold values represent the lowest MAE value obtained.
No single recommendation system produces the lowest MAE all of the items, suggesting that some recommendation systems are better than others for a given user and/or item as has been suggested previously \cite{Lee2012}.
LNN and LNN$_\text{3PT}$ each score the lowest MAE for several movies individually.
With the exception of movie 2571, LNN and LNN$_\text{3PT}$ produce the lowest MAE for all of the movies when they have not been previously rated.
When holding out all 10 items, LNN$_\text{3PT}$ produces the lowest MAE value.
This shows the importance of using latent variables.
CBCF uses CBF to create a dense matrix (except for the ratings corresponding to the active user) and then uses a collaborative filtering technique on the dense matrix to recommend items to the user.
Thus, more emphasis is given to the CBF which generally produces poorer item recommendations than a collaborative filtering approach.
LNN, on the other hand, utilizes the latent variables and their predictive power.

\begin{table}[t]
\caption{The MAE for the top 10 most rated movies (individually and combined) when held out of the training set.}
\label{table:newItems}
\centering
\setlength{\tabcolsep}{4.65pt}
\begin{tabular}{l|cccccccccc|c}
alg & 2571 & 2858 & 2959 & 296 & 318 & 356 & 480 & 4993 & 5952 & 7153 & top10 \\
\hline
CBCF & \textbf{0.889} & 0.898 & 0.875 & 0.742 & 0.929 & 0.760 & 0.720 & 0.755 & 1.053 & 0.981 & 0.896 \\
CBF & 0.957 & 0.905 & 0.920 & 0.870 & 0.965 & 0.866 & 0.766 & 0.790 & 1.121 & 1.041 & 0.972 \\
LNN & 1.175 & \textbf{0.689} & 0.894 & \textbf{0.666} & \textbf{0.789} & \textbf{0.593} & 0.552 & \textbf{0.558} & 0.577 & \textbf{0.523} & 0.859 \\
LNN$_\text{3PT}$ & 1.189 & \textbf{0.690} & 0.906 & 0.680 & 0.810 & \textbf{0.595} & \textbf{0.541} & 0.587 & \textbf{0.566} & \textbf{0.521} & \textbf{0.847} \\
% LNN & 1.175 & \textbf{0.689} & 0.937 & 0.938 & 0.919 & \textbf{0.756} & \textbf{0.639} & \textbf{0.868} & 0.836 & \textbf{0.873} & \textbf{0.857} \\
% LNN$_\text{3PT}$ & 1.89 & 0.817 & \textbf{0.690} & 0.937 & \textbf{0.917} & 0.759 & 0.639 & 0.869 & \textbf{0.835} & 0.874 & \textbf{0.857} \\
\end{tabular}
\end{table}


\subsection{Efficiency}
The efficiency of LNN is not precise as is the case for most neural network models since it is based on the number of iterations until convergence.
In our experiments, LNN always converges regardless of the parameter settings.
However, some parameter settings did require longer to reach convergence than others.
The average time in seconds required to run each algorithm using the parameter settings found in the previous experiments is shown in Table \ref{table:time}.
The additional complexity of LNN requires more time to train.
However, it has the benefit that a new model will not have to be induced in order recommend new or unrated items as is the case with MF, NLPCA, and UBP.
% (The optimal parameter settings for NLPCA and UBP both had no hidden layers, thus, producing shorter training times.)
For recommending new items in LNN, LNN uses a k-d tree for the nearest neighbor search which has $log(n)$ search and insert complexities.

\begin{table}[t]
\caption{The time (in seconds) taken to run each algorithm.}
\label{table:time}
\centering
\begin{tabular}{l| ccccccc}
 & CBCF & CBF & LNN & LNN$_\text{3PT}$ & MF & NLPCA & UBP \\
\hline
train & 2278.2 & 9.1 & 43.4 & 60.2 & 4.8 & 5.8 & 5.8 \\
Ave 10CV & 2432.7 & 9.6 & 53.9 & 193.4 & 7.6 & 8.5 & 10.0 \\
% 100k &  & 1.4 & 7.5 & 8.9 & 0.7 & 0.5 & 0.6\\
% 1M &  & 17.2 & 79.2 & 207.2 & 6.3 & \\
% 10M100K &  & 181.0 &  &  & 93.2 & \\
\end{tabular}
\end{table}


\section{Conclusions and Future Work}
In this paper, we presented a neural network with latent input variables capable of recommending unrated items to users or items to new users which we call a \textit{latent neural network} (LNN).
The latent variables and input variables allow information and correlations among the rated items to be represented while also incorporating the item descriptions in the recommendation.
Thus, LNN is a hybrid recommendation algorithm that leverages the advantages of collaborative filtering and content based filtering.

Empirically, a LNN is able to achieve similar results to state-of-the-art collaborative filtering techniques such as matrix factorization while \textit{also} addressing the cold-start problem.
Compared with other hybrid filters and content-based filtering, LNN achieves much lower error when recommending previously unrated items.
As LNN achieves similar error rates to the state-of-the-art filtering techniques and can make recommendations for previously unrated items, LNN does not \textit{have} to be retrained once new items are rated in order to recommend them.

As LNN is built on a neural network, it is capable of modeling higher-order dependencies and non-linearities in the data.
However, the data in the MovieLens data set and many similar data sets is well suited to using linear models such as matrix factorization.
This may be due in part to the fact many of the data sets are inherently sparse and nonlinear models could overfit them and reduce their generalization.
% We suspect that on denser matrices, the nonlinear capabilities of LNN would be more apparent.
As a direction of future work, we are examining how to better incorporate the non-linear component of LNN.
% 
% Addressing the gray sheep problem using the weighting of some other items until an item has been rated more times and the latent variables take on better values is a direction of future work.
We are also looking at integrating \textit{both} user and item descriptions with latent input variables to address the new user problem \textit{and} the new item problem in a single model. 

% NIPS requires electronic submissions.  The electronic submission site is  
% \begin{center}
%    \url{http://papers.nips.cc}
% \end{center}
% 
% Please read carefully the
% instructions below, and follow them faithfully.
% \subsection{Style}
% 
% Papers to be submitted to NIPS 2014 must be prepared according to the
% instructions presented here. Papers may be only up to eight pages long,
% including figures. Since 2009 an additional ninth page \textit{containing only
% cited references} is allowed. Papers that exceed nine pages will not be
% reviewed, or in any other way considered for presentation at the conference.
% %This is a strict upper bound. 
% 
% Please note that this year we have introduced automatic line number generation
% into the style file (for \LaTeXe and Word versions). This is to help reviewers
% refer to specific lines of the paper when they make their comments. Please do
% NOT refer to these line numbers in your paper as they will be removed from the
% style file for the final version of accepted papers.
% 
% The margins in 2014 are the same as since 2007, which allow for $\approx 15\%$
% more words in the paper compared to earlier years. We are also again using 
% double-blind reviewing. Both of these require the use of new style files.
% 
% Authors are required to use the NIPS \LaTeX{} style files obtainable at the
% NIPS website as indicated below. Please make sure you use the current files and
% not previous versions. Tweaking the style files may be grounds for rejection.
% 
% %% \subsection{Double-blind reviewing}
% 
% %% This year we are doing double-blind reviewing: the reviewers will not know 
% %% who the authors of the paper are. For submission, the NIPS style file will 
% %% automatically anonymize the author list at the beginning of the paper.
% 
% %% Please write your paper in such a way to preserve anonymity. Refer to
% %% previous work by the author(s) in the third person, rather than first
% %% person. Do not provide Web links to supporting material at an identifiable
% %% web site.
% 
% %%\subsection{Electronic submission}
% %%
% %% \textbf{THE SUBMISSION DEADLINE IS MAY 31st, 2014. SUBMISSIONS MUST BE LOGGED BY
% %% 23:00, MAY 31st, 2014, UNIVERSAL TIME}
% 
% %% You must enter your submission in the electronic submission form available at
% %% the NIPS website listed above. You will be asked to enter paper title, name of
% %% all authors, keyword(s), and data about the contact
% %% author (name, full address, telephone, fax, and email). You will need to
% %% upload an electronic (postscript or pdf) version of your paper.
% 
% %% You can upload more than one version of your paper, until the
% %% submission deadline. We strongly recommended uploading your paper in
% %% advance of the deadline, so you can avoid last-minute server congestion.
% %%
% %% Note that your submission is only valid if you get an e-mail
% %% confirmation from the server. If you do not get such an e-mail, please
% %% try uploading again. 
% 
% 
% \subsection{Retrieval of style files}
% 
% The style files for NIPS and other conference information are available on the World Wide Web at
% \begin{center}
%    \url{http://www.nips.cc/}
% \end{center}
% The file \verb+nips2014.pdf+ contains these 
% instructions and illustrates the
% various formatting requirements your NIPS paper must satisfy. \LaTeX{}
% users can choose between two style files:
% \verb+nips11submit_09.sty+ (to be used with \LaTeX{} version 2.09) and
% \verb+nips11submit_e.sty+ (to be used with \LaTeX{}2e). The file
% \verb+nips2014.tex+ may be used as a ``shell'' for writing your paper. All you
% have to do is replace the author, title, abstract, and text of the paper with
% your own. The file
% \verb+nips2014.rtf+ is provided as a shell for MS Word users.
% 
% The formatting instructions contained in these style files are summarized in
% sections \ref{gen_inst}, \ref{headings}, and \ref{others} below.
% 
% %% \subsection{Keywords for paper submission}
% %% Your NIPS paper can be submitted with any of the following keywords (more than one keyword is possible for each paper):
% 
% %% \begin{verbatim}
% %% Bioinformatics
% %% Biological Vision
% %% Brain Imaging and Brain Computer Interfacing
% %% Clustering
% %% Cognitive Science
% %% Control and Reinforcement Learning
% %% Dimensionality Reduction and Manifolds
% %% Feature Selection
% %% Gaussian Processes
% %% Graphical Models
% %% Hardware Technologies
% %% Kernels
% %% Learning Theory
% %% Machine Vision
% %% Margins and Boosting
% %% Neural Networks
% %% Neuroscience
% %% Other Algorithms and Architectures
% %% Other Applications
% %% Semi-supervised Learning
% %% Speech and Signal Processing
% %% Text and Language Applications
% 
% %% \end{verbatim}
% 
% \section{General formatting instructions}
% \label{gen_inst}
% 
% The text must be confined within a rectangle 5.5~inches (33~picas) wide and
% 9~inches (54~picas) long. The left margin is 1.5~inch (9~picas).
% Use 10~point type with a vertical spacing of 11~points. Times New Roman is the
% preferred typeface throughout. Paragraphs are separated by 1/2~line space,
% with no indentation.
% 
% Paper title is 17~point, initial caps/lower case, bold, centered between
% 2~horizontal rules. Top rule is 4~points thick and bottom rule is 1~point
% thick. Allow 1/4~inch space above and below title to rules. All pages should
% start at 1~inch (6~picas) from the top of the page.
% 
% %The version of the paper submitted for review should have ``Anonymous Author(s)'' as the author of the paper.
% 
% For the final version, authors' names are
% set in boldface, and each name is centered above the corresponding
% address. The lead author's name is to be listed first (left-most), and
% the co-authors' names (if different address) are set to follow. If
% there is only one co-author, list both author and co-author side by side.
% 
% Please pay special attention to the instructions in section \ref{others}
% regarding figures, tables, acknowledgments, and references.
% 
% \section{Headings: first level}
% \label{headings}
% 
% First level headings are lower case (except for first word and proper nouns),
% flush left, bold and in point size 12. One line space before the first level
% heading and 1/2~line space after the first level heading.
% 
% \subsection{Headings: second level}
% 
% Second level headings are lower case (except for first word and proper nouns),
% flush left, bold and in point size 10. One line space before the second level
% heading and 1/2~line space after the second level heading.
% 
% \subsubsection{Headings: third level}
% 
% Third level headings are lower case (except for first word and proper nouns),
% flush left, bold and in point size 10. One line space before the third level
% heading and 1/2~line space after the third level heading.
% 
% \section{Citations, figures, tables, references}
% \label{others}
% 
% These instructions apply to everyone, regardless of the formatter being used.
% 
% \subsection{Citations within the text}
% 
% Citations within the text should be numbered consecutively. The corresponding
% number is to appear enclosed in square brackets, such as [1] or [2]-[5]. The
% corresponding references are to be listed in the same order at the end of the
% paper, in the \textbf{References} section. (Note: the standard
% \textsc{Bib\TeX} style \texttt{unsrt} produces this.) As to the format of the
% references themselves, any style is acceptable as long as it is used
% consistently.
% 
% As submission is double blind, refer to your own published work in the 
% third person. That is, use ``In the previous work of Jones et al.\ [4]'',
% not ``In our previous work [4]''. If you cite your other papers that
% are not widely available (e.g.\ a journal paper under review), use
% anonymous author names in the citation, e.g.\ an author of the
% form ``A.\ Anonymous''. 
% 
% 
% \subsection{Footnotes}
% 
% Indicate footnotes with a number\footnote{Sample of the first footnote} in the
% text. Place the footnotes at the bottom of the page on which they appear.
% Precede the footnote with a horizontal rule of 2~inches
% (12~picas).\footnote{Sample of the second footnote}
% 
% \subsection{Figures}
% 
% All artwork must be neat, clean, and legible. Lines should be dark
% enough for purposes of reproduction; art work should not be
% hand-drawn. The figure number and caption always appear after the
% figure. Place one line space before the figure caption, and one line
% space after the figure. The figure caption is lower case (except for
% first word and proper nouns); figures are numbered consecutively.
% 
% Make sure the figure caption does not get separated from the figure.
% Leave sufficient space to avoid splitting the figure and figure caption.
% 
% You may use color figures. 
% However, it is best for the
% figure captions and the paper body to make sense if the paper is printed
% either in black/white or in color.
% \begin{figure}[h]
% \begin{center}
% %\framebox[4.0in]{$\;$}
% \fbox{\rule[-.5cm]{0cm}{4cm} \rule[-.5cm]{4cm}{0cm}}
% \end{center}
% \caption{Sample figure caption.}
% \end{figure}
% 
% \subsection{Tables}
% 
% All tables must be centered, neat, clean and legible. Do not use hand-drawn
% tables. The table number and title always appear before the table. See
% Table~\ref{sample-table}.
% 
% Place one line space before the table title, one line space after the table
% title, and one line space after the table. The table title must be lower case
% (except for first word and proper nouns); tables are numbered consecutively.
% 
% \begin{table}[t]
% \caption{Sample table title}
% \label{sample-table}
% \begin{center}
% \begin{tabular}{ll}
% \multicolumn{1}{c}{\bf PART}  &\multicolumn{1}{c}{\bf DESCRIPTION}
% \\ \hline \\
% Dendrite         &Input terminal \\
% Axon             &Output terminal \\
% Soma             &Cell body (contains cell nucleus) \\
% \end{tabular}
% \end{center}
% \end{table}
% 
% \section{Final instructions}
% Do not change any aspects of the formatting parameters in the style files.
% In particular, do not modify the width or length of the rectangle the text
% should fit into, and do not change font sizes (except perhaps in the
% \textbf{References} section; see below). Please note that pages should be
% numbered.
% 
% \section{Preparing PostScript or PDF files}
% 
% Please prepare PostScript or PDF files with paper size ``US Letter'', and
% not, for example, ``A4''. The -t
% letter option on dvips will produce US Letter files.
% 
% Fonts were the main cause of problems in the past years. Your PDF file must
% only contain Type 1 or Embedded TrueType fonts. Here are a few instructions
% to achieve this.
% 
% \begin{itemize}
% 
% \item You can check which fonts a PDF files uses.  In Acrobat Reader,
% select the menu Files$>$Document Properties$>$Fonts and select Show All Fonts. You can
% also use the program \verb+pdffonts+ which comes with \verb+xpdf+ and is
% available out-of-the-box on most Linux machines.
% 
% \item The IEEE has recommendations for generating PDF files whose fonts
% are also acceptable for NIPS. Please see
% \url{http://www.emfield.org/icuwb2010/downloads/IEEE-PDF-SpecV32.pdf}
% 
% \item LaTeX users:
% 
% \begin{itemize}
% 
% \item Consider directly generating PDF files using \verb+pdflatex+
% (especially if you are a MiKTeX user). 
% PDF figures must be substituted for EPS figures, however.
% 
% \item Otherwise, please generate your PostScript and PDF files with the following commands:
% \begin{verbatim} 
% dvips mypaper.dvi -t letter -Ppdf -G0 -o mypaper.ps
% ps2pdf mypaper.ps mypaper.pdf
% \end{verbatim}
% 
% Check that the PDF files only contains Type 1 fonts. 
% %For the final version, please send us both the Postscript file and
% %the PDF file. 
% 
% \item xfig "patterned" shapes are implemented with 
% bitmap fonts.  Use "solid" shapes instead. 
% \item The \verb+\bbold+ package almost always uses bitmap
% fonts.  You can try the equivalent AMS Fonts with command
% \begin{verbatim}
% \usepackage[psamsfonts]{amssymb}
% \end{verbatim}
%  or use the following workaround for reals, natural and complex: 
% \begin{verbatim}
% \newcommand{\RR}{I\!\!R} %real numbers
% \newcommand{\Nat}{I\!\!N} %natural numbers 
% \newcommand{\CC}{I\!\!\!\!C} %complex numbers
% \end{verbatim}
% 
% \item Sometimes the problematic fonts are used in figures
% included in LaTeX files. The ghostscript program \verb+eps2eps+ is the simplest
% way to clean such figures. For black and white figures, slightly better
% results can be achieved with program \verb+potrace+.
% \end{itemize}
% \item MSWord and Windows users (via PDF file):
% \begin{itemize}
% \item Install the Microsoft Save as PDF Office 2007 Add-in from
% \url{http://www.microsoft.com/downloads/details.aspx?displaylang=en\&familyid=4d951911-3e7e-4ae6-b059-a2e79ed87041}
% \item Select ``Save or Publish to PDF'' from the Office or File menu
% \end{itemize}
% \item MSWord and Mac OS X users (via PDF file):
% \begin{itemize}
% \item From the print menu, click the PDF drop-down box, and select ``Save
% as PDF...''
% \end{itemize}
% \item MSWord and Windows users (via PS file):
% \begin{itemize}
% \item To create a new printer
% on your computer, install the AdobePS printer driver and the Adobe Distiller PPD file from
% \url{http://www.adobe.com/support/downloads/detail.jsp?ftpID=204} {\it Note:} You must reboot your PC after installing the
% AdobePS driver for it to take effect.
% \item To produce the ps file, select ``Print'' from the MS app, choose
% the installed AdobePS printer, click on ``Properties'', click on ``Advanced.''
% \item Set ``TrueType Font'' to be ``Download as Softfont''
% \item Open the ``PostScript Options'' folder
% \item Select ``PostScript Output Option'' to be ``Optimize for Portability''
% \item Select ``TrueType Font Download Option'' to be ``Outline''
% \item Select ``Send PostScript Error Handler'' to be ``No''
% \item Click ``OK'' three times, print your file.
% \item Now, use Adobe Acrobat Distiller or ps2pdf to create a PDF file from
% the PS file. In Acrobat, check the option ``Embed all fonts'' if
% applicable.
% \end{itemize}
% 
% \end{itemize}
% If your file contains Type 3 fonts or non embedded TrueType fonts, we will
% ask you to fix it. 
% 
% \subsection{Margins in LaTeX}
%  
% Most of the margin problems come from figures positioned by hand using
% \verb+\special+ or other commands. We suggest using the command
% \verb+\includegraphics+
% from the graphicx package. Always specify the figure width as a multiple of
% the line width as in the example below using .eps graphics
% \begin{verbatim}
%    \usepackage[dvips]{graphicx} ... 
%    \includegraphics[width=0.8\linewidth]{myfile.eps} 
% \end{verbatim}
% or % Apr 2009 addition
% \begin{verbatim}
%    \usepackage[pdftex]{graphicx} ... 
%    \includegraphics[width=0.8\linewidth]{myfile.pdf} 
% \end{verbatim}
% for .pdf graphics. 
% See section 4.4 in the graphics bundle documentation (\url{http://www.ctan.org/tex-archive/macros/latex/required/graphics/grfguide.ps}) 
%  
% A number of width problems arise when LaTeX cannot properly hyphenate a
% line. Please give LaTeX hyphenation hints using the \verb+\-+ command.
% 
% 
% \subsubsection*{Acknowledgments}
% 
% Use unnumbered third level headings for the acknowledgments. All
% acknowledgments go at the end of the paper. Do not include 
% acknowledgments in the anonymized submission, only in the 
% final paper. 

\bibliographystyle{abbrv}
\begin{small}
\bibliography{/home/msmith/Research/bibliography}
\end{small}

% \subsubsection*{References}
% 
% References follow the acknowledgments. Use unnumbered third level heading for
% the references. Any choice of citation style is acceptable as long as you are
% consistent. It is permissible to reduce the font size to `small' (9-point) 
% when listing the references. {\bf Remember that this year you can use
% a ninth page as long as it contains \emph{only} cited references.}
% 
% \small{
% [1] Alexander, J.A. \& Mozer, M.C. (1995) Template-based algorithms
% for connectionist rule extraction. In G. Tesauro, D. S. Touretzky
% and T.K. Leen (eds.), {\it Advances in Neural Information Processing
% Systems 7}, pp. 609-616. Cambridge, MA: MIT Press.
% 
% [2] Bower, J.M. \& Beeman, D. (1995) {\it The Book of GENESIS: Exploring
% Realistic Neural Models with the GEneral NEural SImulation System.}
% New York: TELOS/Springer-Verlag.
% 
% [3] Hasselmo, M.E., Schnell, E. \& Barkai, E. (1995) Dynamics of learning
% and recall at excitatory recurrent synapses and cholinergic modulation
% in rat hippocampal region CA3. {\it Journal of Neuroscience}
% {\bf 15}(7):5249-5262.
% }

\end{document}

nips2014_MG_1.bbl
\begin{thebibliography}{10}

\bibitem{bengio:neural_language_generative_backprop}
Y.~Bengio, H.~Schwenk, J.~Sen{\'e}cal, F.~Morin, and J.~Gauvain.
\newblock Neural probabilistic language models.
\newblock In {\em Innovations in Machine Learning}, pages 137--186. Springer,
  2006.

\bibitem{Burke2002}
R.~D. Burke.
\newblock Hybrid recommender systems: Survey and experiments.
\newblock {\em User Modeling and User-Adapted Interaction}, 12(4):331--370,
  2002.

\bibitem{RecSys2011}
I.~Cantador, P.~Brusilovsky, and T.~Kuflik.
\newblock 2{nd} workshop on information heterogeneity and fusion in recommender
  systems (hetrec 2011).
\newblock In {\em Proceedings of the 5th ACM conference on Recommender
  systems}, RecSys 2011, New York, NY, USA, 2011. ACM.

\bibitem{Claypool1999}
M.~Claypool, A.~Gokhale, T.~Miranda, P.~Murnikov, D.~Netes, and M.~Sartin.
\newblock Combining content-based and collaborative filters in an online
  newspaper.
\newblock In {\em Proceedings of the ACM SIGIR '99 Workshop on Recommender
  Systems: Algorithms and Evaluation}, Berkeley, California, 1999. ACM.

\bibitem{coheh:label_images_generative_backprop}
D.~Coheh and J.~Shawe-Taylor.
\newblock Daugman's gabor transform as a simple generative back propagation
  network.
\newblock {\em Electronics Letters}, 26(16):1241--1243, 1990.

\bibitem{Cremonesi2011}
P.~Cremonesi, R.~Turrin, and F.~Airoldi.
\newblock Hybrid algorithms for recommending new items.
\newblock In {\em Proceedings of the 2Nd International Workshop on Information
  Heterogeneity and Fusion in Recommender Systems}, HetRec '11, pages 33--40,
  New York, NY, USA, 2011. ACM.

\bibitem{Forbes2011}
P.~Forbes and M.~Zhu.
\newblock Content-boosted matrix factorization for recommender systems:
  experiments with recipe recommendation.
\newblock In B.~Mobasher, R.~D. Burke, D.~Jannach, and G.~Adomavicius, editors,
  {\em RecSys}, pages 261--264. ACM, 2011.

\bibitem{Gashler2014}
M.~S. Gashler, M.~R. Smith, R.~Morris, and T.~Martinez.
\newblock Missing value imputation with unsupervised backpropagation.
\newblock {\em Computational Intelligence}, page To Appear, 2014.

\bibitem{hinton:generative_backpropagation}
G.~E. Hinton.
\newblock Generative back-propagation.
\newblock In {\em Abstracts 1st INNS}, 1988.

\bibitem{koren:matrix_factorization}
Y.~Koren, R.~Bell, and C.~Volinsky.
\newblock {Matrix factorization techniques for recommender systems}.
\newblock {\em Computer}, 42(8):30--37, 2009.

\bibitem{Lee2012}
J.~Lee, M.~Sun, G.~Lebanon, and S.~jean Kim.
\newblock Automatic feature induction for stagewise collaborative filtering.
\newblock In F.~Pereira, C.~Burges, L.~Bottou, and K.~Weinberger, editors, {\em
  Advances in Neural Information Processing Systems 25}, pages 314--322. Curran
  Associates, Inc., 2012.

\bibitem{Li2003}
Q.~Li and B.~M. Kim.
\newblock Clustering approach for hybrid recommender system.
\newblock In {\em Web Intelligence}, pages 33--38. IEEE Computer Society, 2003.

\bibitem{Lin2013}
J.~Lin, K.~Sugiyama, M.-Y. Kan, and T.-S. Chua.
\newblock Addressing cold-start in app recommendation: latent user models
  constructed from twitter followers.
\newblock In {\em Proceedings of the 36th International ACM SIGIR Conference on
  Research and Development in Information Retrieval}, SIGIR '13, pages
  283--292, New York, NY, USA, 2013. ACM.

\bibitem{Melville2004}
P.~Melville, N.~Shah, L.~Mihalkova, and R.~J. Mooney.
\newblock Experiments on ensembles with missing and noisy data.
\newblock In {\em Multiple Classifier Systems}, volume 3077 of {\em Lecture
  Notes in Computer Science}, pages 293--302, 2004.

\bibitem{Mitchell1997ML}
T.~M. Mitchell.
\newblock {\em Machine Learning}, volume~1.
\newblock McGraw-Hill New York, 1997.

\bibitem{Salakhutdinov2007}
R.~Salakhutdinov and A.~Mnih.
\newblock Probabilistic matrix factorization.
\newblock In J.~C. Platt, D.~Koller, Y.~Singer, and S.~T. Roweis, editors, {\em
  Advances in Neural Information Processing Systems 20}. Curran Associates,
  Inc., 2007.

\bibitem{Salakhutdinov2008}
R.~Salakhutdinov and A.~Mnih.
\newblock Bayesian probabilistic matrix factorization using {M}arkov chain
  {M}onte {C}arlo.
\newblock In {\em Proceedings of the 25th International Conference on Machine
  Learning}, 2008.

\bibitem{Schein2002}
A.~I. Schein, A.~Popescul, L.~H. Ungar, and D.~M. Pennock.
\newblock Methods and metrics for cold-start recommendations.
\newblock In {\em Proceedings of the 25th Annual International ACM SIGIR
  Conference on Research and Development in Information Retrieval}, SIGIR '02,
  pages 253--260, New York, NY, USA, 2002. ACM.

\bibitem{nlpca}
M.~Scholz, F.~Kaplan, C.~L. Guy, J.~Kopka, and J.~Selbig.
\newblock Non-linear pca: a missing data approach.
\newblock {\em Bioinformatics}, 21(20):3887--3895, 2005.

\bibitem{Su2007}
X.~Su, R.~Greiner, T.~M. Khoshgoftaar, and X.~Zhu.
\newblock Hybrid collaborative filtering algorithms using a mixture of experts.
\newblock In {\em Web Intelligence}, pages 645--649. IEEE Computer Society,
  2007.

\bibitem{takacs2009scalable}
G.~Tak{\'a}cs, I.~Pil{\'a}szy, B.~N{\'e}meth, and D.~Tikk.
\newblock Scalable collaborative filtering approaches for large recommender
  systems.
\newblock {\em The Journal of Machine Learning Research}, 10:623--656, 2009.

\bibitem{Zhou2011}
K.~Zhou, S.-H. Yang, and H.~Zha.
\newblock Functional matrix factorizations for cold-start recommendation.
\newblock In {\em Proceeding of the 34th International ACM SIGIR Conference on
  Research and Development in Information Retrieval, SIGIR '11}, pages
  315--324, 2011.

\end{thebibliography}
