zeekay
531fc57003
Brand-only sweep. Touches READMEs, docs, package metadata, comments,
notebook markdown, requirements.txt files; does NOT yet touch Python
`concrete.*` imports (those are module-level dependencies requiring the
phase-2 Python module port from `concrete` → `torus`).
Substitutions applied:
Concrete ML → TorusML
concrete-ml → torus-ml
Concrete-ML → Torus-ML
concrete_ml → torus_ml
zama-ai/concrete-ml → luxfhe/ml-sdk
zama-ai/concrete → luxfhe/torus
github.com/zama-ai → github.com/luxfhe
docs.zama.ai/concrete-ml → docs.luxfhe.com/ml-sdk
docs.zama.ai/concrete → docs.luxfhe.com/torus
Zama Concrete ML → Lux TorusML
Zama Concrete → Lux Torus
Zama tfhe-rs / Zama TFHE-rs → Lux-FHE
tfhe-rs / TFHE-rs → Lux-FHE
Zama fhEVM / fhEVM → TorusEVM
Concrete framework → Torus framework
Concrete compiler → Torus compiler
Concrete by Zama → Torus by Lux
the Zama team → the Lux Industries team
Zama's → Lux Industries'
(Zama) → (Lux)
CoFHE / Fhenix → (removed)
LICENSE: original Zama copyright RETAINED per BSD-3-Clause-Clear §1-§2
requirements; Lux Industries modifications copyright added. Per §3 no
name of ZAMA used to endorse the derived work — product marketed
exclusively as TorusML.
README image URLs migrated to github.com/luxfhe/ml-sdk/assets to break
the dependency on Zama's CDN.
Hit count: 350 → 295. Residual hits are Python `from concrete.fhe import`
imports referencing the upstream Zama `concrete` PyPI package; these
require module-level port (phase 2):
Phase 2 plan:
1. Fork zama-ai/concrete (the Python compiler) to luxfhe/torus
2. Rename Python module `concrete` → `torus`; PyPI publish as `torus-fhe`
3. Update ml-sdk imports from `concrete.fhe` → `torus.fhe`, etc.
4. Wire `torus.compiler` GPU dispatch through `luxcpp/gpu` vtbl
(lux-private/gpu-kernels for CUDA/Metal/WebGPU/FPGA targets)
5. Port concrete-cuda + concrete-mlir kernels to
lux-private/gpu-kernels/{cuda,metal,wgsl}/ckks/ (matrix-vector
mul, rescale, rotate, bootstrap for TorusML inference)
Phase 3 plan (kernels):
- CKKS/BGV/BFV GPU kernels in lux-private/gpu-kernels/
(currently only TFHE PBS / keyswitch / blind-rotate exist)
- FPGA bitstreams in lux-private/fpga/ (currently scaffold only)
Phase 1 = docs/branding sweep. PR not opened; user reviews and merges.
3.2 KiB
Serializing Built-In Models
This document explains how to serialize build-in models in TorusML.
Introduction
Serialization allows you to dump a fitted and compiled model into a JSON string or file. You can then load the estimator back using the JSON object.
Saving Models
All built-in models provide the following methods:
dumps: Dumps the model as a string.dump: Dumps the model into a file.
For example, a logistic regression model can be dumped in a string as follows:
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from concrete.ml.sklearn import LogisticRegression
# Create the data for classification:
X, y = make_classification()
# Retrieve train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4)
# Instantiate, train and compile the model
model = LogisticRegression()
model.fit(X_train, y_train)
model.compile(X_train)
# Run the inference in FHE
y_pred_fhe = model.predict(X_test, fhe="execute")
# Dump the model in a string
dumped_model_str = model.dumps()
Similarly, it can be dumped into a file:
from pathlib import Path
dumped_model_path = Path("logistic_regression_model.json")
# Any kind of file-like object can be used
with dumped_model_path.open("w") as f:
# Dump the model in a file
model.dump(f)
Alternatively, TorusML provides two equivalent global functions:
from concrete.ml.common.serialization.dumpers import dump, dumps
# Dump the model in a string
dumped_model_str = dumps(model)
# Any kind of file-like object can be used
with dumped_model_path.open("w") as f:
# Dump the model in a file
dump(model, f)
{% hint style="warning" %}
Some parameters used for instantiating Quantized Neural Network models are not supported for serialization. In particular, you cannot serialize a model that was instantiated using callable objects for the train_split and predict_nonlinearity parameters or with callbacks being enabled.
{% endhint %}
Loading Models
You can load a built-in model using the following functions:
loads: Loads the model from a string.load: Loads the model from a file.
{% hint style="warning" %} A loaded model must be compiled once again to execute the inference in FHE or with simulation because the underlying FHE circuit is currently not serialized. This recompilation is not required when FHE mode is disabled. {% endhint %}
The same logistic regression model can be loaded as follows:
import numpy
from concrete.ml.common.serialization.loaders import load, loads
# Load the model from a string
loaded_model = loads(dumped_model_str)
# Any kind of file-like object can be used
with dumped_model_path.open("r") as f:
# Load the model from a file
loaded_model = load(f)
# Compile the model
loaded_model.compile(X_train)
# Run the inference in FHE using the loaded model
y_pred_fhe_loaded = loaded_model.predict(X_test, fhe="execute")
print("Predictions are equal:", numpy.array_equal(y_pred_fhe, y_pred_fhe_loaded))
# Output:
# Predictions are equal: True