ToR[e]cSys

News

It is happy to know the new package of Tensorflow Recommenders.

ToR[e]cSys is a PyTorch Framework to implement recommendation system algorithms, including but not limited to click-through-rate (CTR) prediction, learning-to-ranking (LTR), and Matrix/Tensor Embedding. The project objective is to develop a ecosystem to experiment, share, reproduce, and deploy in real world in a smooth and easy way (Hope it can be done).

• Installation
• Implemented Models
• Documentation
• Getting Started
• Examples
• Authors
• License

Installation

TBU

Documentation

The complete documentation for ToR[e]cSys is available via ReadTheDocs website.
Thank you for ReadTheDocs! You are the best!

Implemented Models

1. Subsampling

2. Negative Sampling

3. Click through Rate (CTR) Model

4. Embedding Model

5. Learning-to-Rank (LTR) Model

Getting Started

There are several ways using ToR[e]cSys to develop a Recommendation System. Before talking about them, we first need to discuss about components of ToR[e]cSys.

A model in ToR[e]cSys is constructed by two parts mainly: inputs and model, and they will be wrapped into a sequential module (torecsys.models.sequential) to be trained by Trainer (torecsys.trainer.Trainer). \

For inputs module (torecsys.inputs), it will handle most kinds of inputs in recommendation system, like categorical features, images, etc, with several kinds of methods, including token embedding, pre-trained image models, etc.

For models module (torecsys.models), it will implement some famous models in recommendation system, like Factorization Machine family. I hope I can make the library rich. To construct a model in the module, in addition to the modules implemented in PyTorch, I will also implement some layers in torecsys.layers which are called by models usually.

After the explanation of ToR[e]cSys, let's move on to the Getting Started. We can use ToR[e]cSys in the following ways:

1. Run by command-line (In development)

torecsys build --inputs_config='{}'
--model_config='{"method":"FM", "embed_size": 8, "num_fields": 2}'
--regularizer_config='{"weight_decay": 0.1}'
--criterion_config='{"method": "MSELoss"}'
--optimizer_config='{"method": "SGD", "lr": "0.01"}'
... ```

2. Run by class method

import torecsys as trs

build trainer by class method

trainer = trs.trainer.Trainer()
.bind_objective("CTR")
.set_inputs()
.set_model(method="FM", embed_size=8, num_fields=2)
.set_sequential()
.set_regularizer(weight_decay=0.1)
.build_criterion(method="MSELoss")
.build_optimizer(method="SGD", lr="0.01")
.build_loader(name="train", ...)
.build_loader(name="eval", ...)
.set_target_fields("labels")
.set_max_num_epochs(10)
.use_cuda()

start to fit the model

trainer.fit() ```

3. Run like PyTorch Module

import torch import torch.nn as nn import torecsys as trs

some codes here

inputs = trs.inputs.InputsWrapper(schema=schema) model = trs.models.FactorizationMachineModel(embed_size=8, num_fields=2)

for i in range(epochs): optimizer.zero_grad() outputs = model(**inputs(batches)) loss = criterion(outputs, labels) loss.backward() optimizer.step() ```

(In development) You can anyone you like to train a Recommender System and serve it in the following ways:

1. Run by command-line

   > torecsys serve --load_from='{}'

2. Run by class method

import torecsys as trs

serving = trs.serving.Model()
.load_from(filepath=filepath) .run() ```

3. Serve it yourself

from flask import Flask, request import torecsys as trs

model = trs.serving.Model()
.load_from(filepath=filepath)

@app.route("/predict") def predict(): args = request.json inference = model.predict(args) return inference, 200

if name == "main": app.run() ```

For further details, please refer to the example in repository or read the documentation. Hope you enjoy~

Examples

TBU

Sample Codes

TBU

Sample of Experiments

TBU

Authors

• Jasper Li - Developer

License

ToR[e]cSys is MIT-style licensed, as found in the LICENSE file.