LIBFFM - field-aware factorization machines - in Rust

Andrew Kane

Last update: Jan 8, 2022

Related tags

Miscellaneous libffm-rust

Overview

LIBFFM Rust

LIBFFM - field-aware factorization machines - in Rust

Getting Started

LIBFFM Rust is available as a Rust library and a command line tool.

Rust library
Command line tool

Rust Library

Installation

Add this line to your application’s Cargo.toml under [dependencies]:

libffm = "0.1"

How to Use

Prep your data in LIBFFM format

0 0:0:1 1:1:1
1 0:2:1 1:3:1

Train a model

let model = libffm::Model::train("train.ffm").unwrap();

Use a validation set and early stopping to prevent overfitting

let model = libffm::Model::params()
    .auto_stop(true)
    .train_eval("train.ffm", "valid.ffm")
    .unwrap();

Make predictions

let (predictions, loss) = model.predict("test.ffm").unwrap();

Save the model to a file

model.save("model.bin").unwrap();

Load the model from a file

let model = libffm::Model::load("model.bin").unwrap();

Training Options

let model = libffm::Model::params()
    .learning_rate(0.2)      // learning rate
    .lambda(0.00002)         // regularization parameter
    .iterations(15)          // number of iterations
    .factors(4)              // number of latent factors
    .quiet(false)            // quiet mode (no output)
    .normalization(true)     // use instance-wise normalization
    .auto_stop(false)        // stop at the iteration that achieves the best validation loss
    .on_disk(false)          // on-disk training
    .train("train.ffm");     // train or train_eval

Command Line Tool

Installation

Run:

cargo install libffm --features cli

How to Use

Prep your data in LIBFFM format

0 0:0:1 1:1:1
1 0:2:1 1:3:1

Train a model

ffm-train train.ffm model.bin

Use a validation set and early stopping to prevent overfitting

ffm-train -p valid.ffm --auto-stop train.ffm model.bin

Make predictions

ffm-predict test.ffm model.bin output.txt

Training Options

FLAGS:
        --auto-stop    Stop at the iteration that achieves the best validation loss (must be used with -p)
        --in-memory    Enable in-memory training
        --no-norm      Disable instance-wise normalization
        --quiet        Quiet mode (no output)

OPTIONS:
    -r 
   
                   Set learning rate [default: 0.2]
    -k 
    
                 Set number of latent factors [default: 4]
    -t 
     
               Set number of iterations [default: 15]
    -l 
      
                   Set regularization parameter [default: 0.00002]
    -s 
       
         Set number of threads [default: 1] -p 
        
          Set path to the validation set

Credits

This library was ported from the LIBFFM C++ library and is available under the same license.

History

View the changelog

Contributing

Everyone is encouraged to help improve this project. Here are a few ways you can help:

Report bugs
Fix bugs and submit pull requests
Write, clarify, or fix documentation
Suggest or add new features

To get started with development:

git clone https://github.com/ankane/libffm-rust.git
cd libffm-rust
cargo test
cargo run --bin ffm-train --features cli
cargo run --bin ffm-predict --features cli

🐀 Building a federated alternative to reddit in rust

Lemmy A link aggregator / Reddit clone for the fediverse. Join Lemmy · Documentation · Report Bug · Request Feature · Releases · Code of Conduct About

7.2k Jan 3, 2023

Applied offensive security with Rust

Black Hat Rust - Early Access Deep dive into offensive security with the Rust programming language Buy the book now! Summary Whether in movies or main

2.2k Jan 2, 2023

Rholang runtime in rust

Rholang Runtime A rholang runtime written in Rust.

17 Sep 23, 2022

Easy-to-use optional function arguments for Rust

OptArgs uses const generics to ensure compile-time correctness. I've taken the liberty of expanding and humanizing the macros in the reference examples.

37 Nov 18, 2022

A language server for lua written in rust

lua-analyzer lua-analyzer is a lsp server for lua. This is mostly for me to learn the lsp protocol and language analysis so suggestions are helpful. T

61 Dec 11, 2022

Rust library that can be reset if you think it's slow

GoodbyeKT Rust library that can be reset if you think it's slow

39 Jun 16, 2022

Cargo - The Rust package manager

Cargo downloads your Rust project’s dependencies and compiles your project.

9.5k Jan 4, 2023

A copypastable guide to implementing simple derive macros in Rust.

A copypastable guide to implementing simple derive macros in Rust. The goal Let's say we have a trait with a getter trait MyTrait {

131 Dec 27, 2022

Rust ABI safe code generator

CGlue offers an easy way to ABI (application binary interface) safety. Just a few annotations and your trait is ready to go!

142 Jan 2, 2023

Comments

Decouple IO train/predict
Hi @ankane. I was looking for some Rust based FM / FFM and I found your crate. Good job! It looks quite clean. I would like to test it on my problem. However I would like to skip serialization of my data before I call train/predict. If someone is using Rust and your crate as a library it could be easier to maybe pass the data itself than save it to disk first - which could be a lengthy process. In general it is almost always a good idea to decouple input and output from the actual algorithm.

I propose to change the signatures of the methods to something like this

pub fn train(&mut self, x: Vec<Vec<Node>>, y: Vec<f32>) // of course using references instead of Vec would be probably a good idea pub fn predict(&self, x: Vec<Vec<Node>>) pub fn train_from_file(...) pub fn predict_from_file(...)

Actually... when I think about it more it perhaps is more complicated than I thought because there should be some Iterator implemented to read the data from the disk. So in fact the signature for x would be more like

train(..., data: I) where I: IntoIterator<Item = (&[Node], &f32)>

And then there should be an Iterator implemented for file based data.

If you are ok with such a change I could contribute this. Let me know your thoughts.
opened by pjankiewicz 2