Python binding of multi-core LIBLINEAR

Warnings

• breaking The Python import path for high-level utilities changed after version 2.43. Using 'from liblinearutil import *' will fail in newer versions.
  Fix: Update imports to 'from liblinear.liblinearutil import *'.
• gotcha Careless handling of model instances obtained through low-level C interfaces can lead to memory leaks or segmentation faults.
  Fix: When working with low-level interfaces (from `liblinear.liblinear`), ensure proper memory management. For high-level use (from `liblinear.liblinearutil`), this is generally handled internally.
• gotcha Results from multi-core operations (i.e., when using the '-m' option) may be slightly different when run with a varying number of threads due to the nature of parallel computations.
  Fix: This is expected behavior and typically results in very similar final objective values. For reproducibility across different thread counts, consider fixing the number of threads or acknowledging potential minor variations.
• gotcha The `pip install .` or `python setup.py install` commands from the source directory can fail if not executed with specific instructions.
  Fix: It is recommended to use `pip install liblinear-multicore` for standard installation. If installing from source, consult the official README for specific build instructions, usually involving `pip install -e .` or `pip install --user -e .`.
• gotcha If the optimization algorithm fails to converge (e.g., in scikit-learn's LogisticRegression with liblinear solver), you might encounter `ConvergenceWarning`.
  Fix: Consider normalizing your training data (e.g., using `StandardScaler`), tuning regularization parameters (e.g., `C`), or as a last resort, increasing `max_iter`. Setting `dual=False` might also help if the number of features is much larger than the number of samples.

Install

• pip install liblinear-multicore Latest stable release
• pip install -U liblinear-multicore Upgrade to latest version

Imports

• * (high-level utilities)

  from liblinear.liblinearutil import *

  The import path changed after version 2.43. The old path 'from liblinearutil import *' is incorrect for newer versions.
• * (low-level C interfaces)

  from liblinear.liblinear import *

  For advanced users directly calling C interfaces via ctypes.

Quickstart

This quickstart demonstrates how to train a linear classification model using `liblinear-multicore` with a custom number of threads. It covers creating problem and parameter objects, training the model, making predictions, evaluating results, and saving/loading models. Data can be provided in LIBSVM format or as Python lists/dictionaries/NumPy arrays/SciPy sparse matrices. The `-m` option in the parameter string specifies the number of threads for parallelization.

from liblinear.liblinearutil import *

# Example data (LIBSVM format or Python list/dict/ndarray)
y = [1, -1, 1, -1]
x = [{1:1, 3:1}, {1:-1, 3:-1}, {1:1, 3:1}, {1:-1, 3:-1}]

# Create problem and parameter instances
# Use '-m nr_thread' option for multi-core training, e.g., '-m 4' for 4 threads
prob = problem(y, x)
param = parameter('-s 0 -c 4 -m 4') # -s 0: L2-regularized L2-loss SVM (dual), -c 4: cost parameter, -m 4: 4 threads

# Train the model
m = train(prob, param)

# Make predictions
p_labels, p_metrics, p_values = predict(y, x, m)

# Print results (example for classification)
ACC, MSE, SCC = evaluations(y, p_labels)
print(f"Accuracy = {ACC[0]:.2f}%")

# Save and load model
save_model('model_file', m)
loaded_m = load_model('model_file')