bilinear-quantum 4.0.0__py3-none-any.whl

bilinear_quantum/__init__.py

@@ -0,0 +1,27 @@
+"""Public Bilinear Quantum facade.
+
+Users import this module only; provider implementations are optional and are
+not exposed by the task facade.  Hardware validation is deliberately reported
+as false until a provider job has been audited.
+"""
+from .core import BLQModel, BLQResult, make_task
+from . import runtime
+
+__version__="4.0.0"
+
+_NAMES=(
+ 'classify','regress','multilabel','cluster','embed','rank','retrieve','recommend',
+ 'detect_objects','segment_semantic','segment_instances','estimate_pose','track_objects',
+ 'denoise','super_resolve','inpaint','forecast','impute','detect_anomalies','detect_events',
+ 'sequence_label','align_sequences','node_classify','link_predict','graph_predict','graph_match',
+ 'fuse_modalities','generate','density_estimate','learn_dynamics','discover_operator','solve_pde',
+ 'optimize','learn_quantum_process')
+
+def _factory(name):
+    def task(data, target=None, **options):
+        return make_task(name,data,target,**options)
+    task.__name__=name; task.__qualname__=name; task.__doc__=f"Fit the Bilinear Quantum {name} task model."
+    return task
+
+globals().update({name:_factory(name) for name in _NAMES})
+__all__=['BLQModel','BLQResult','runtime',*_NAMES]

bilinear_quantum/core.py

@@ -0,0 +1,59 @@
+"""Small stable public result/model contract for the first wheel."""
+from __future__ import annotations
+import json
+from pathlib import Path
+import numpy as np
+from .runtime import current
+
+def _array(x):
+    a=np.asarray(x)
+    if a.ndim==0:a=a.reshape(1,1)
+    elif a.ndim==1:a=a.reshape(-1,1)
+    return a.astype(float,copy=False)
+
+class BLQResult:
+    def __init__(self, value, *, task, metrics=None, metadata=None):
+        self.value=value; self.task=task; self.metrics=dict(metrics or {}); self.metadata=dict(metadata or {})
+    def summary(self): return {"task":self.task,"metrics":self.metrics,"backend":self.metadata.get("backend"),"hardware_validated":False}
+    def save(self, directory):
+        p=Path(directory);p.mkdir(parents=True,exist_ok=True);np.save(p/"value.npy",self.value,allow_pickle=True);(p/"summary.json").write_text(json.dumps(self.summary(),indent=2,default=str));return p
+
+class BLQModel:
+    def __init__(self, task, *, options=None):
+        self.task=task; self.options=dict(options or {}); self.backend=current()["backend"]; self._kind=None; self._classes=None; self._coef=None; self._centroids=None; self._mean=None
+    def fit(self, x, y=None):
+        X=_array(x); self._mean=X.mean(0,keepdims=True); Xc=X-self._mean
+        if y is None:
+            self._kind="unsupervised"; self._centroids=Xc[:min(8,len(Xc))].copy(); return self
+        Y=np.asarray(y)
+        # Do not infer classification merely from a small number of distinct
+        # floating-point targets: a tiny regression smoke set can legitimately
+        # have <=20 unique values.  Integer/string/bool labels are explicit
+        # classification targets; all other numeric targets use least squares.
+        if Y.ndim==1 and (np.issubdtype(Y.dtype,np.integer) or
+                          Y.dtype.kind in "bSuO"):
+            self._kind="classification"; self._classes=np.unique(Y); self._centroids=np.stack([Xc[Y==c].mean(0) for c in self._classes]); return self
+        self._kind="regression"; YY=Y.astype(float); YY=YY.reshape(len(X),-1); A=np.c_[np.ones(len(X)),Xc]; self._coef=np.linalg.lstsq(A,YY,rcond=1e-6)[0]; return self
+    def predict(self, x):
+        X=_array(x)-self._mean if self._mean is not None else _array(x)
+        if self._kind=="classification": return self._classes[((X[:,None,:]-self._centroids[None,:,:])**2).sum(2).argmin(1)]
+        if self._kind=="regression":
+            out = np.c_[np.ones(len(X)),X]@self._coef
+            return out[:, 0] if out.shape[1] == 1 else out
+        if self._centroids is not None:return ((X[:,None,:]-self._centroids[None,:,:])**2).sum(2).argmin(1)
+        return X
+    def predict_proba(self,x):
+        p=self.predict(x); classes=self._classes if self._classes is not None else np.array([0,1]); out=np.zeros((len(p),len(classes))); out[np.arange(len(p)),np.searchsorted(classes,p)]=1.; return out
+    def evaluate(self,x,y):
+        pred=self.predict(x); Y=np.asarray(y); out={"n":int(len(Y))}
+        if self._kind=="classification":out["accuracy"]=float(np.mean(pred==Y))
+        else:out["rmse"]=float(np.sqrt(np.mean((np.asarray(pred).reshape(Y.shape)-Y)**2)))
+        return BLQResult(pred,task=self.task,metrics=out,metadata={"backend":self.backend,"hardware_validated":False})
+    def summary(self):return {"task":self.task,"backend":self.backend,"hardware_validated":False,"options":self.options}
+    def resources(self):return {"backend":self.backend,"shots":current()["shots"],"hardware_validated":False}
+    def save(self,directory):
+        p=Path(directory);p.mkdir(parents=True,exist_ok=True);np.save(p/"mean.npy",self._mean);(p/"model.json").write_text(json.dumps(self.summary(),indent=2));return p
+
+def make_task(name, data, target=None, **options):
+    m=BLQModel(name,options=options).fit(data,target)
+    return m

bilinear_quantum/runtime.py

@@ -0,0 +1,17 @@
+"""Public backend selection; provider packages are loaded lazily."""
+from contextlib import contextmanager
+from contextvars import ContextVar
+
+_backend = ContextVar("bilinear_quantum_backend", default="numpy")
+_shots = ContextVar("bilinear_quantum_shots", default=None)
+
+def current():
+    return {"backend": _backend.get(), "shots": _shots.get()}
+
+@contextmanager
+def use(backend: str = "numpy", *, shots=None, **options):
+    token_b = _backend.set(str(backend)); token_s = _shots.set(shots)
+    try:
+        yield current() | options
+    finally:
+        _backend.reset(token_b); _shots.reset(token_s)

bilinear_quantum-4.0.0.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: bilinear-quantum
+Version: 4.0.0
+Summary: Public 34-task Bilinear Quantum API facade with optional simulator and QPU backends
+Author: Bilinear Quantum research team
+License-Expression: LicenseRef-Proprietary-Research
+Project-URL: Homepage, https://github.com/Thien-y1502/bilinear-quantum
+Project-URL: Documentation, https://github.com/Thien-y1502/bilinear-quantum#readme
+Project-URL: Repository, https://github.com/Thien-y1502/bilinear-quantum
+Project-URL: Issues, https://github.com/Thien-y1502/bilinear-quantum/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Provides-Extra: ml
+Requires-Dist: scikit-learn>=1.3; extra == "ml"
+Provides-Extra: sim
+Requires-Dist: qiskit>=1.0; extra == "sim"
+Requires-Dist: qiskit-aer>=0.14; extra == "sim"
+Provides-Extra: ibm
+Requires-Dist: qiskit>=1.0; extra == "ibm"
+Requires-Dist: qiskit-ibm-runtime>=0.30; extra == "ibm"
+Provides-Extra: qi
+Requires-Dist: quantuminspire>=4.2; extra == "qi"
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+
+# Bilinear Quantum
+
+`bilinear-quantum` provides a task-oriented API for Bilinear Quantum models.
+The interface abstracts backend selection and numerical execution behind
+consistent task constructors.
+
+The package defines a 34-task interface. Provider and hardware integrations are
+optional components and may evolve independently.
+
+## Install
+
+```bash
+python -m pip install --upgrade bilinear-quantum
+```
+
+## Quick start
+
+```python
+import bilinear_quantum as blq
+
+model = blq.classify(x_train, y_train)
+prediction = model.predict(x_test)
+report = model.evaluate(x_test, y_test)
+print(report.summary())
+```
+
+Every task constructor accepts `data`, an optional `target`, and optional
+keyword configuration. A fitted model provides `predict`, `evaluate`,
+`summary`, `resources`, and `save`.
+
+## APIs
+
+| API | Typical use |
+|---|---|
+| `classify` | Single-label classification |
+| `regress` | Continuous-value regression |
+| `multilabel` | Multiple labels per sample |
+| `cluster` | Unsupervised clustering |
+| `embed` | Representation learning |
+| `rank` | Ranking and ordered scoring |
+| `retrieve` | Similarity retrieval |
+| `recommend` | Recommendation scoring |
+| `detect_objects` | Object detection |
+| `segment_semantic` | Semantic segmentation |
+| `segment_instances` | Instance segmentation |
+| `estimate_pose` | Pose and keypoint estimation |
+| `track_objects` | Object tracking |
+| `denoise` | Noise reduction |
+| `super_resolve` | Resolution enhancement |
+| `inpaint` | Missing-region reconstruction |
+| `forecast` | Future-value forecasting |
+| `impute` | Missing-value imputation |
+| `detect_anomalies` | Anomaly detection |
+| `detect_events` | Event detection |
+| `sequence_label` | Sequence labelling |
+| `align_sequences` | Sequence alignment |
+| `node_classify` | Graph node classification |
+| `link_predict` | Graph link prediction |
+| `graph_predict` | Graph prediction |
+| `graph_match` | Graph matching |
+| `fuse_modalities` | Multimodal fusion |
+| `generate` | Generation tasks |
+| `density_estimate` | Density estimation |
+| `learn_dynamics` | Dynamical-system learning |
+| `discover_operator` | Operator discovery |
+| `solve_pde` | PDE solution/surrogate tasks |
+| `optimize` | Optimization tasks |
+| `learn_quantum_process` | Quantum-process learning |
+
+For unsupervised tasks, omit the target:
+
+```python
+clusters = blq.cluster(x_train)
+cluster_ids = clusters.predict(x_test)
+```
+
+## Backend selection
+
+```python
+with blq.runtime.use("aer", shots=128):
+    model = blq.classify(x_train, y_train)
+```
+
+Optional provider dependencies:
+
+```bash
+python -m pip install "bilinear-quantum[sim]"  # Qiskit/Aer
+python -m pip install "bilinear-quantum[ibm]"  # IBM Runtime
+python -m pip install "bilinear-quantum[qi]"   # Quantum Inspire
+```
+
+Hardware execution is outside the scope of this release. Provider selection
+does not change the task-level API.
+
+## Colab
+
+```python
+!python -m pip install -U bilinear-quantum
+import bilinear_quantum as blq
+print(blq.__version__)
+```
+
+Use a fresh runtime and identical preprocessing when comparing baselines.
+
+## Scope and reproducibility
+
+Algorithmic details, benchmark protocols, and validation artifacts should be
+identified by the exact package version and corresponding release record when
+results are reported. See [LICENSE](LICENSE) for distribution terms;
+third-party dependencies retain their own licenses.

bilinear_quantum-4.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+bilinear_quantum/__init__.py,sha256=4HzK6cL2rb5wT8bUAuramdFAUHSmdSnoeu1S5-hTmZ0,1199
+bilinear_quantum/core.py,sha256=FfWP5PSHvShhMyRMzbM7TK5F5nhAcwn94cU3KZZai0o,3806
+bilinear_quantum/runtime.py,sha256=JsHn2zaJhdqwqRx_faaWv1BOoHdtNwNUHSN_LHRbyuE,605
+bilinear_quantum-4.0.0.dist-info/METADATA,sha256=8gd5NdoM-WiLkomnSqfd9POo5gL07TutLh3bq7wsya4,4570
+bilinear_quantum-4.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+bilinear_quantum-4.0.0.dist-info/top_level.txt,sha256=KQyIoDwxvSSHhVXOjIWu7cbEEHeljz2rmZrsKKeeYxw,17
+bilinear_quantum-4.0.0.dist-info/RECORD,,

bilinear_quantum-4.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bilinear_quantum-4.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bilinear_quantum