libftrl-python - GitLite

KO | EN

gitlite — search

#javascript #python #hacktoberfest #typescript #android #machine-learning #rust #deep-learning #macos #kubernetes #awesome-list #security #mcp #openai

libftrl-python

(★ 124)

FTRL-Proximal with python bindings

File Explorer

Download Latest Version (.zip)

- __init__.py
- ftrl.py
- ftrl.cpp
- ftrl.h
.gitignore
build_wheel.sh
CMakeLists.txt
README.md
setup.py

# Installation Guide

1. Get the code

git clone https://github.com/alexeygrigorev/libftrl-python

Downloads the entire project code from GitHub to your computer.

cd libftrl-python

Moves into the project folder you just downloaded.

2. CMake

Medium Recommended

Prerequisites

Git Needed to download the project code from GitHub.
CMake The tool used to generate build configuration.
C/C++ 컴파일러 Windows needs Visual Studio (Community edition, free), macOS needs Xcode Command Line Tools, Linux needs the gcc/g++ package.

cmake . && make

Type this command into your terminal and run it.

mkdir cmake && cd cmake

Type this command into your terminal and run it.

wget https://cmake.org/files/v3.10/cmake-3.10.0-Linux-x86_64.sh

Type this command into your terminal and run it.

bash cmake-3.10.0-Linux-x86_64.sh --skip-license

Type this command into your terminal and run it.

✅ Check that an executable was created inside the build folder, then run it directly (e.g. ./build/app_name).

Pulled directly from this repo's README.

3. Python

Easy

Prerequisites

Git Needed to download the project code from GitHub.
Python 3 On Windows, be sure to check 'Add Python to PATH' during installation.

pip install .

Installs the package published on PyPI directly — no need to clone the source.

python <실행할 파일명>.py # README에서 정확한 실행 파일명을 확인하세요

Runs the Python script (or module).

✅ If it runs without errors and prints output in the terminal, it worked.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# FTRL-Proximal

This is an implementation of the FTRL-Proximal algorithm in C with python bindings. FTRL-Proximal is an algorithm for online learning which is quite successful in solving sparse problems. The implementation is based on the algorithm from the ["Ad Click Prediction: a View from the Trenches"](https://research.google.com/pubs/pub41159.html) paper.

Some of the features:

* Uses Open MP to parallelize training, and hence is very fast
* The python code can operate directly on scipy CSR matrices

## Pre-requisites

Dependensies:

* It needs: `numpy`, `scipy` and open mp
* If you use anaconda, it already has  `numpy`, `scipy`
* to install `GOMP_4.0` for anaconda, use `conda install libgcc`

## Building

cmake . && make
    mv libftrl.so ftrl/
    python setup.py install

If you don't have `cmake`, it's easy to install:

mkdir cmake && cd cmake
    wget https://cmake.org/files/v3.10/cmake-3.10.0-Linux-x86_64.sh
    bash cmake-3.10.0-Linux-x86_64.sh --skip-license
    export CMAKE_HOME=`pwd`
    export PATH=$PATH:$CMAKE_HOME/bin

## Example

import numpy as np
    import scipy.sparse as sp

from sklearn.metrics import roc_auc_score

import ftrl

X = [
        [1, 1, 0, 0, 0],
        [1, 1, 1, 0, 0],
        [0, 1, 1, 1, 0],
        [0, 0, 1, 1, 1],
        [0, 0, 0, 1, 1],   
    ]

X = sp.csr_matrix(X)
    y = np.array([1, 1, 1, 0, 0], dtype='float32')
    
    model = ftrl.FtrlProximal(alpha=1, beta=1, l1=10, l2=0)

# make 10 passes over the data
    for i in range(10):
        model.fit(X, y)
        y_pred = model.predict(X)
        auc = roc_auc_score(y, y_pred)
        print('%02d: %.5f' % (i + 1, auc))

We can also use it to solve the regression problem:

from sklearn.metrics import mean_squared_error

y = np.array([1, 2, 3, 4, 5], dtype='float32')

model = ftrl.FtrlProximal(alpha=0.5, beta=1, l1=0, l2=0, model_type='regression')

# make 10 passes over the data
    for i in range(10):
        model.fit(X, y)
        y_pred = model.predict(X)
        mse = mean_squared_error(y, y_pred)
        print('%02d: %.5f' % (i + 1, mse))

## Use case

This library was used for the [Criteo Ad Placement Challenge](https://www.crowdai.org/challenges/nips-17-workshop-criteo-ad-placement-challenge/leaderboards) and showed very competitive performance. You can have a look at the solution here: https://github.com/alexeygrigorev/nips-ad-placement-challenge

In particular, it performed significantly faster than sklearn's Logistic Regression (a wrapper for LIBLINEAR):

- sklearn: 1.2 hours to train, auc=0.734
- libftrl-python: 2 minutes to train, auc=0.734