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.
Project description
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
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
Model Name | Research Paper | Year |
---|---|---|
Word2Vec | Omer Levy et al, 2015. Improving Distributional Similarity with Lessons Learned from Word Embeddings | 2015 |
2. Negative Sampling
Model Name | Research Paper | Year |
---|---|---|
TBU |
3. Click through Rate (CTR) Model
4. Embedding Model
Model Name | Research Paper | Year |
---|---|---|
Matrix Factorization | / | / |
Starspace | Ledell Wu et al, 2017 StarSpace: Embed All The Things! | 2017 |
5. Learning-to-Rank (LTR) Model
Model Name | Research Paper | Year |
---|---|---|
Personalized Re-ranking Model | Changhua Pei et al, 2019. Personalized Re-ranking for Recommendation | 2019 |
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:
-
Run by command-line (In development)
</code></pre> </li> </ol> <blockquote> <p>torecsys build --inputs_config='{}' <br /> --model_config='{"method":"FM", "embed_size": 8, "num_fields": 2}' <br /> --regularizer_config='{"weight_decay": 0.1}' <br /> --criterion_config='{"method": "MSELoss"}' <br /> --optimizer_config='{"method": "SGD", "lr": "0.01"}' <br /> ... ```</p> </blockquote> <ol start="2"> <li> <p>Run by class method</p> <pre lang="python"><code>
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_targets_name("labels")
.set_max_num_epochs(10)
.use_cuda()
start to fit the model
trainer.fit() ```
-
Run like PyTorch Module
</code></pre> </li> </ol> <p>import torch import torch.nn as nn import torecsys as trs</p> <h1>some codes here</h1> <p>inputs = trs.inputs.InputsWrapper(schema=schema) model = trs.models.FactorizationMachineModel(embed_size=8, num_fields=2)</p> <p>for i in range(epochs): optimizer.zero_grad() outputs = model(**inputs(batches)) loss = criterion(outputs, labels) loss.backward() optimizer.step() ```</p> <p>(In development) You can anyone you like to train a Recommender System and serve it in the following ways:</p> <ol> <li> <p>Run by command-line</p> <pre lang="bash"><code>> torecsys serve --load_from='{}'
-
Run by class method
</code></pre> </li> </ol> <p>import torecsys as trs</p> <p>serving = trs.serving.Model() <br /> .load_from(filepath=filepath) .run() ```</p> <ol start="3"> <li> <p>Serve it yourself</p> <pre lang="python"><code>
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.
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.