Enum Command 

pub enum Command {
    Convert {
        model: String,
        task: TaskArg,
        output: Option<PathBuf>,
        dtype: DtypeArg,
        model_dir: PathBuf,
        token: Option<String>,
        redownload: bool,
    },
    InspectTensors {
        path: PathBuf,
    },
    Upload {
        repo: String,
        token: String,
        root: PathBuf,
    },
    Infer {
        gguf: PathBuf,
        config: PathBuf,
    },
    EnsemblePredict {
        gguf: PathBuf,
        config: PathBuf,
        threads: Option<usize>,
        batch_size: Option<usize>,
    },
    Delete {
        model: String,
        task: TaskArg,
        model_dir: PathBuf,
        output: Option<PathBuf>,
    },
}

Variants

Convert

Download one TabFM variant from HuggingFace and convert to GGUF.

The first conversion downloads the model and writes a canonical F32 GGUF alongside it, deleting the (large) downloaded weight file afterward. Later conversions (any –dtype) recast from that cached F32 GGUF instead of re-downloading — pass –redownload to force a fresh download anyway (e.g. the repo was updated).

Fields

model: String

task: TaskArg

Which HF subfolder / weight variant to convert.

output: Option<PathBuf>

dtype: DtypeArg

model_dir: PathBuf

token: Option<String>

redownload: bool

Force a fresh download even if a cached F32 GGUF already exists.

InspectTensors

Print all tensor names in a local checkpoint file (safetensors, PyTorch pickle, GGUF, or npy/npz — format auto-detected).

Fields

path: PathBuf

Upload

Upload source + GGUF files to HuggingFace Hub.

Fields

repo: String

token: String

root: PathBuf

Directory tree to upload. Defaults to the current directory.

Infer

Run TabFM classification/regression from a GGUF file.

Reads a JSON request from stdin: {“x”: [[…]], “y”: […], “train_size”: N, “cat_mask”: […], “d”: N} x is [T][H] (rows x padded feature columns), y is [T] labels (any finite placeholder at test-row positions is fine), train_size is how many leading rows are training rows, cat_mask (optional, default all-false) marks categorical columns, d (optional, default H) is the actual unpadded feature count. Outputs JSON: {“task”: …, “logits”|“predictions”: [[…]], “probabilities”: [[…]]?}

Fields

gguf: PathBuf

config: PathBuf

EnsemblePredict

Full sklearn-wrapper-equivalent pipeline: feature scaling, categorical encoding, and n_estimators-member ensembling (bit-compatible with the real TabFMClassifier/ TabFMRegressor’s default RNG) on top of the raw model.

Reads a JSON request from stdin: {“x_train”: [[…]], “y_train”: […], “x_test”: [[…]], “cat_mask”: […], “n_estimators”: 32, “norm_methods”: [“none”,“power”], “class_shift”: true, “outlier_threshold”: 4.0, “softmax_temperature”: 0.9, “average_logits”: true, “random_state”: 42, “binary_calibration_method”: null|“platt”, “multiclass_calibration_method”: null|“vector”, “num_folds_for_cv”: 5, “enable_nnls”: false, “nnls_beta”: 0.75, “calibration_lambda”: 0.01} x_train/x_test cells may be numbers or strings (categorical columns, per cat_mask, are ordinal-encoded internally). Calibration/NNLS are off by default (matching the sklearn wrapper) and, when enabled, are fit natively via an out-of-fold procedure on x_train — no separate “fit” step needed. Outputs JSON: classification -> {“task”:“classification”,“probabilities”:[[…]],“predicted_labels”:[…],“classes”:[…]}; regression -> {“task”:“regression”,“predictions”:[…]}.

Fields

gguf: PathBuf

config: PathBuf

threads: Option<usize>

Worker threads for the ensemble-member/OOF-fold parallel loops (default: rayon’s own default, i.e. all logical cores, or the RAYON_NUM_THREADS env var if set). On some machines more threads than ~physical-core-count can hurt wall time (contention with Accelerate/BLAS’s own internal matmul threading) — benchmark your deployment if tuning for latency.

batch_size: Option<usize>

Members per batched forward pass (default: all n_estimators in one batch — BLAS is generally more efficient on one large matmul than many small ones). Smaller values trade that off against more rayon-parallel chunks; benchmark for a given table size/machine if tuning. Can also be set via the JSON body’s "batch_size" field.

Delete

Delete cached model files for this model.

Removes the canonical F32 GGUF and config cache at <model_dir>/[<variant>-]<owner>__<name>/ created by convert. By default only the cache is removed; pass --output <path> to also delete a converted GGUF file (e.g. gguf/...).

Fields

model: String

HuggingFace repo id (must match the convert –model you used).

task: TaskArg

Which variant to delete (must match convert –task).

model_dir: PathBuf

Directory where the cache was written (must match convert –model-dir).

output: Option<PathBuf>

Also delete this output GGUF file if it exists.

Trait Implementations

impl FromArgMatches for Command

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Command

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand