outerproduct 0.2.2__tar.gz → 0.2.3__tar.gz

{outerproduct-0.2.2 → outerproduct-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: outerproduct
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python SDK for the OuterProduct API
 Project-URL: Documentation, https://docs.outerproduct.com
 Project-URL: Homepage, https://outerproduct.com

{outerproduct-0.2.2 → outerproduct-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "outerproduct"
-version = "0.2.2"
+version = "0.2.3"
 description = "Python SDK for the OuterProduct API"
 readme = "README.md"
 requires-python = ">=3.12"

{outerproduct-0.2.2 → outerproduct-0.2.3}/src/outerproduct/reasoning/pattern_tracker.py

@@ -1,13 +1,6 @@
-"""PatternTracker — aggregate a :class:`ReasoningModel`'s local-rule
-explanations into a small, frozen set of labeled filter patterns.
-
-The fit dispatches to a one-shot Modal CPU function on the API server: it
-loads the cloudpickled ReasoningModel, materializes X from the supplied
-:class:`~outerproduct.dataset.Dataset` (inline / pre-uploaded /
-connector-backed — same routing as :func:`outerproduct.reasoning.fit`),
-runs ``predict`` + ``explain_prediction`` + ``build_patterns`` end-to-end,
-and persists the result. The SDK polls a single GET endpoint and returns
-the populated :class:`PatternTracker`.
+"""PatternTracker — aggregate a :class:`ReasoningModel`'s explanations on
+a target prediction band into a small, frozen set of labeled filter
+patterns.
 
 Quickstart
 ----------
@@ -17,7 +10,7 @@ Quickstart
 
     op.init(api_key="...")
     ds = op.FileUploadConnector().upload("data.csv")
-    rm = op.reasoning.fit(ds)
+    rm = op.reasoning.fit(ds, label_column="churn", task_type="binclass")
     pt = op.reasoning.pattern_tracker.fit(rm, ds, target_range=(0.5, None))
 
     pt.patterns           # tuple[FilterPattern, ...]
@@ -44,12 +37,10 @@ if TYPE_CHECKING:
 
 @dataclass(frozen=True)
 class Predicate:
-    """One literal of a conjunctive filter: ``feature <op> value``.
+    """One literal of a filter: ``feature <op> value``.
 
-    Mirrors the server-side
-    ``outerproduct_reasoning.internal.local_rules.Predicate``. ``op`` is
-    ``"<="`` or ``">="`` for continuous features (numeric ``value``) or
-    ``"=="`` for categoricals.
+    ``op`` is ``"<="`` or ``">="`` for continuous features (numeric
+    ``value``) or ``"=="`` for categoricals.
     """
 
     feature: str
@@ -70,7 +61,7 @@ class Predicate:
 
 @dataclass(frozen=True)
 class FilterPattern:
-    """One executable conjunctive filter with coverage stats and a label."""
+    """One executable filter with coverage stats and a label."""
 
     predicates: tuple[Predicate, ...]
     label: str
@@ -183,66 +174,36 @@ def fit(
     dataset: Dataset,
     *,
     target_range: tuple[float | None, float | None],
-    mode: str = "discovery",
     max_patterns: int = 25,
-    coverage_target: float = 0.95,
-    min_pattern_support: float = 0.005,
-    min_precision: float = 0.5,
-    max_pattern_size: int = 3,
-    threshold_n_bins: int = 10,
-    ensure_coverage: bool = True,
-    min_wracc: float = 0.0,
-    diversity_threshold: float = 0.5,
-    drop_redundant: bool = True,
-    child_overlap_threshold: float = 0.9,
-    explained_lift_threshold: float = 1.1,
-    rule_kwargs: dict[str, Any] | None = None,
     non_blocking: bool = False,
     poll_interval: float = 2.0,
     poll_timeout: float = 3600.0,
 ) -> "PatternTracker | PatternTrackerJob":
-    """Fit a :class:`PatternTracker` against ``reasoning_model`` over
-    ``dataset``'s rows.
+    """Fit a :class:`PatternTracker` against ``reasoning_model`` on
+    ``dataset``.
 
     Parameters
     ----------
     reasoning_model : :class:`~outerproduct.model.ReasoningModel`
-        The model whose rejected rows define the aggregation target.
+        The model whose target-band rows drive the aggregation.
     dataset : :class:`~outerproduct.dataset.Dataset`
-        The data to score and aggregate. Inline / pre-uploaded /
-        connector-backed datasets are all supported (same routing as
-        :func:`outerproduct.reasoning.fit`).
+        Data to score and aggregate over.
     target_range : (lo, hi) tuple
-        Inclusive prediction band that defines "rejected" rows. Either
-        side may be ``None`` for an open bound; at least one must be set.
+        Inclusive prediction band that defines the target cohort.
+        Either side may be ``None`` for an open bound; at least one
+        must be set.
+    max_patterns : int, default 25
+        Cap on the number of returned patterns.
     non_blocking : bool, default False
         If ``True``, return a :class:`PatternTrackerJob` immediately;
-        otherwise block until the fit completes and return the populated
-        tracker.
-
-    All remaining keyword arguments mirror the server-side fit
-    hyperparameters; see ``outerproduct_reasoning.PatternTracker.fit``
-    for their semantics.
+        otherwise block until the fit completes.
     """
     from outerproduct_http_types import PatternTrackerFitRequest
 
     dataset_payload = dataset._to_dataset_payload()
     payload: dict[str, Any] = {
         "target_range": target_range,
-        "mode": mode,
         "max_patterns": max_patterns,
-        "coverage_target": coverage_target,
-        "min_pattern_support": min_pattern_support,
-        "min_precision": min_precision,
-        "max_pattern_size": max_pattern_size,
-        "threshold_n_bins": threshold_n_bins,
-        "ensure_coverage": ensure_coverage,
-        "min_wracc": min_wracc,
-        "diversity_threshold": diversity_threshold,
-        "drop_redundant": drop_redundant,
-        "child_overlap_threshold": child_overlap_threshold,
-        "explained_lift_threshold": explained_lift_threshold,
-        "rule_kwargs": rule_kwargs,
     }
     payload.update(dataset_payload)