TensorRec

A TensorFlow recommendation algorithm framework in Python.

What is TensorRec?

TensorRec is a Python recommendation system that allows you to quickly develop recommendation algorithms and customize them using TensorFlow.

TensorRec lets you to customize your recommendation system's embedding functions and loss functions while TensorRec handles the data manipulation and scoring to generate recommendations.

A TensorRec system consumes three pieces of data: user_features, item_features, and interactions. It uses this data to learn to make and rank recommendations.

For more information, and for an outline of this project, please read this blog post.

TODO

Immediate plans for development of TensorRec include:

Documentation of TensorRec class and methods
Implementation of WARP loss, or an alternate pairwise loss solution
Implementation of more evaluation methods (AUC, F score, etc)
Integration of publicly available data sets (MovieLens, etc)

Example: Input data

The following examples show what user/item features and interactions would look like in a TensorRec system meant to recommend business consulting projects (items) to consultants (users).

The data is represented in matrices. TensorRec can consume these matrices as any scipy.sparse matrix.

User features:

Item features:

Interactions:

Images from Medium

Example: Basic usage

import numpy as np
import tensorrec

# Build the model with default parameters
model = tensorrec.TensorRec()

# Generate some dummy data
interactions, user_features, item_features = tensorrec.util.generate_dummy_data(num_users=100,
                                                                                num_items=150,
                                                                                interaction_density=.05)

# Fit the model for 5 epochs
model.fit(interactions, user_features, item_features, epochs=5, verbose=True)

# Predict scores for user 75 on items 100, 101, and 102
predictions = model.predict(user_ids=[75, 75, 75],
                            item_ids=[100, 101, 102],
                            user_features=user_features,
                            item_features=item_features)

# Calculate and print the recall at 10
r_at_k = tensorrec.eval.recall_at_k(model, interactions,
                                    k=10,
                                    user_features=user_features,
                                    item_features=item_features)
print(np.mean(r_at_k))

Example: Defining custom representation function

import tensorflow as tf
import tensorrec

# Define a custom representation function graph
def tanh_representation_graph(tf_features, n_components, n_features, node_name_ending):
    """
    This representation function embeds the user/item features by passing them through a single tanh layer.
    :param tf_features: tf.SparseTensor
    The user/item features as a SparseTensor of dimensions [n_users/items, n_features]
    :param n_components: int
    The dimensionality of the resulting representation.
    :param n_features: int
    The number of features in tf_features
    :param node_name_ending: String
    Either 'user' or 'item'
    :return:
    A tuple of (tf.Tensor, list) where the first value is the resulting representation in n_components
    dimensions and the second value is a list containing all tf.Variables which should be subject to
    regularization.
    """
    tf_tanh_weights = tf.Variable(tf.random_normal([n_features, n_components],
                                                   stddev=.5),
                                  name='tanh_weights_%s' % node_name_ending)

    tf_repr = tf.nn.tanh(tf.sparse_tensor_dense_matmul(tf_features, tf_tanh_weights))

    # Return repr layer and variables
    return tf_repr, [tf_tanh_weights]

# Build a model with the custom representation function
model = tensorrec.TensorRec(user_repr_graph=tanh_representation_graph,
                            item_repr_graph=tanh_representation_graph)

Example: Defining custom loss function

import tensorflow as tf
import tensorrec

# Define a custom loss function graph
def simple_error_graph(tf_prediction, tf_y, **kwargs):
    """
    This loss function returns the absolute simple error between the predictions and the interactions.
    :param tf_prediction: tf.Tensor
    The recommendation scores as a Tensor of shape [n_samples, 1]
    :param tf_y: tf.Tensor
    The sample interactions corresponding to tf_prediction as a Tensor of shape [n_samples, 1]
    :param kwargs:
    Other TensorFlow nodes (not yet implemented)
    :return:
    A tf.Tensor containing the learning loss.
    """
    return tf.reduce_mean(tf.abs(tf_y - tf_prediction))

# Build a model with the custom loss function
model = tensorrec.TensorRec(loss_graph=simple_error_graph)

zhumeilian/tensorrec