FuxiCTR and the model framework it leaves to you

Eight numbered demos fix the input contract for a run

The public entry points are the eight numbered scripts under demo/, and their numbering follows what the library reads from disk. `example1_build_dataset_to_parquet.py` writes a dataset out, `example2_DeepFM_with_parquet_input.py` reads it straight back, `example3_DeepFM_with_npz_input.py` switches to the numpy container, and `example4_DeepFM_with_csv_input.py` falls back one step further to delimited text. Four more probe the edges: pretrained embeddings loaded as frozen weights, a DIN model fed a sequence feature, a customized preprocessing hook, and DCN handed an embedding feature directly.

That ordering is the interface contract in practice. Parquet leads because `pyarrow` and `polars` sit in both dependency lists, while npz and csv read as compatibility paths rather than the default. Nothing in the README explains how the three formats map onto one feature schema, so a reader has to reconstruct it from the file names, and `demo/config/` is listed as a directory without a single file name or key inside it being printed.

The model zoo counts from LR at WWW'07 to DeepFM at ICDM'17

The Model Zoo table is the catalogue: one row per publication, carrying the venue year, the paper, a per-model directory under model_zoo/, a benchmark link and a framework column. Row 1 is LR for WWW'07, then FM for ICDM'10, DSSM for CIKM'13, CCPM for CIKM'15, FFM and DNN for RecSys'16, Wide&Deep for DLRS'16, PNN for ICDM'16, DeepCrossing for KDD'16, HOFM for NIPS'16 and DeepFM for ICDM'17. Several rows flag a vendor beside the paper, marking LR, DSSM and DeepCrossing as Microsoft work, FFM as Criteo, and DNN and Wide&Deep as Google.

The framework column deserves a close look. Every visible row is marked torch, and only DNN and Wide&Deep carry a second entry for tf. The claim that the library extends across both Pytorch and Tensorflow therefore rests on two architectures in the catalogue, while the remaining rows are a single-framework list. A reader planning a TensorFlow run picks a model from that short column first and discovers the rest later.

The PyPI manifest installs neither Torch nor TensorFlow

This is the widest gap between the badges and the package. The README header carries three version badges, python-3.10+, torch-2.5+ and tensorflow-2.21+, and the feature list says the library extends to new models across both Pytorch and Tensorflow. Read setup.py and the picture changes:

    install_requires=["pandas", "pyyaml>=6.0.1", "scikit-learn",
                      "numpy", "h5py", "tqdm", "pyarrow", "polars", 
                      "ray[data]>=2.52.0", "pydantic"],

No torch, no tensorflow. The badge markup carries its own evidence of how the list drifted: the tensorflow-2.21+ image carries alt text reading Pytorch version, a copy of the line above it. The keywords in setup.py are 'ctr prediction', 'recommender systems', 'ctr', 'cvr' and 'pytorch', so tensorflow is absent there as well. The single pinned floor that hints at infrastructure, ray[data]>=2.52.0, attaches to distributed data processing rather than to a model backend, and the tuning claim names no tuner and no flag to pair it with.

scipy sits in requirements.txt and vanishes from install_requires

Two files describe two different installations. requirements.txt is the longer list, adding scipy to the packages named in setup.py while keeping the same floors of pyyaml>=6.0.1 and ray[data]>=2.52.0. Someone working from the published wheel gets no scipy, and someone installing the checkout list gets it, so the same code can fail on an import for reasons that have nothing to do with the model.

The package boundary is drawn in a second place:

    packages=setuptools.find_packages(
        exclude=["model_zoo", "tests", "data", "docs", "demo"]),

Because model_zoo, tests, data, docs and demo are excluded, the per-model directories and the eight demo scripts are not importable after an install from PyPI. The Apache-2.0 licence, the last push on 2026-09-14 and the absence of any GitHub releases are all visible in the tree itself: setup.py carries the Apache Software License classifier, LICENSE sits at the top level, and download_url points readers at the tags page regardless.

Starting a checkout with no install command printed

Begin with the packaging metadata, since the README prints no installation command of its own. Its badges point at the PyPI project page for fuxictr, and setup.py is the only place the distribution name, the Python floor and the version are written down. python_requires reads >=3.10, which agrees with the python-3.10+ badge, and the version is 2.3.10:

setuptools.setup(
    name="fuxictr",
    version="2.3.10",
    python_requires=">=3.10",

Four lines of setup() tell you what PyPI will hand you and what interpreter refuses to run it. A checkout carries its own list, and scipy is in it:

pyyaml>=6.0.1
scikit-learn
numpy
scipy
pandas
h5py
tqdm
pyarrow
polars
ray[data]>=2.52.0
pydantic

Neither list names a deep learning backend, so the first run starts by choosing PyTorch or TensorFlow and installing it outside this package. After that, `demo/example2_DeepFM_with_parquet_input.py` is the shortest route to a trained model, and `demo/config/` is where the settings for that run are meant to live.

Benchmark links resolve into reczoo/BARS, not this tree

Every Benchmark cell in the Model Zoo leaves the repository. Each row points at a path inside the companion project reczoo/BARS under ranking/ctr/, with the model name repeated at the end of the URL, so the DeepFM row resolves to a directory this checkout does not contain. Code stays here under model_zoo/, and the benchmark configurations sit there. That split is the practical difference between FuxiCTR and its own benchmarking layer, and it is the one relationship the README never spells out in a sentence.

The consequence for anyone reproducing a number is concrete. The library installs from PyPI on its own, but a benchmark run needs a second checkout of reczoo/BARS to supply the configurations, and the repository description points at https://fuxictr.github.io for documentation rather than at a local copy of them. Read the Model Zoo as an index into two projects rather than as a self-contained gallery of results.

Seventeen top-level entries and one importable package

The repository root shows how much is packaged and how much is research scaffolding:

.gitattributes
.github/
.gitignore
CHANGELOG.md
CITATION
CONTRIBUTORS.md
LICENSE
README.md
data/
demo/
docs/
fuxictr/
model_zoo/
requirements.txt
scripts/
setup.py
tests/

Only fuxictr/ is collected by find_packages. data/ holds datasets, docs/ documentation, scripts/ helper code and tests/ checks, while CITATION and CONTRIBUTORS.md carry citation metadata for a paper-oriented audience, which matches the classifiers listing Science/Research and Education among the intended audiences. Everything except the one package is reachable in a checkout and absent from an install.

That split also frames the configuration gap. The feature list says models can be tuned automatically through easy configurations, yet no configuration key, no file name inside `demo/config/` and no tuner command is printed anywhere in the README. A directory name is the whole documented surface behind the library's central claim, and anyone automating a sweep has to write those settings from scratch.

Where FuxiCTR stops short of an online ranker

The shape of the dependency list puts a firm boundary on the use case. h5py, pyarrow, polars, pandas and scikit-learn all speak to local files, the demos read parquet, npz or csv from disk, and training happens there. There is no serving directory in the tree, no export routine in the demos, and no HTTP or RPC package in install_requires, so a latency or throughput question inside a live ranking path falls outside what this library offers. What it does offer is a wide catalogue of published architectures behind a single dataset format, which fits a benchmark table or a controlled comparison and does not fit a request path.

One more constraint deserves stating. Among the rows printed in the README, the newest publication is DeepFM for ICDM'17, while the package version in setup.py is 2.3.10, a gap of several years between the newest architecture on display and the number on the wheel. The table gives no way to tell which side has moved, so treat the catalogue as the architecture history it records rather than as a map of current practice.

Editorial conclusion

FuxiCTR earns a place in a research loop where several published CTR architectures get compared on one dataset format, since the numbered demos and the per-model directories make that repetition cheap. It does not cover the parts of the stack it leaves out: a PyPI install names no deep learning backend, the benchmark configurations live in reczoo/BARS rather than in this tree, and no configuration key for the tuning claim is printed anywhere. Check those three things before the first training run, not after.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. README
4. reczoo/FuxiCTR on GitHub