process-improve 1.22.0__tar.gz → 1.22.2__tar.gz

{process_improve-1.22.0 → process_improve-1.22.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-improve
-Version: 1.22.0
+Version: 1.22.2
 Summary: Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis.
 Keywords: Designed Experiments,Latent Variables,PCA,PLS,Multivariate Data Analysis,Batch data analysis
 Author: Kevin Dunn

{process_improve-1.22.0 → process_improve-1.22.2}/process_improve/batch/features.py

@@ -448,12 +448,12 @@ def f_count(
     """
     Feature:    count.
 
-    The index number of the final value for each tag, for the given tags
+    The number of non-missing observations for each tag, for the given tags
     in ``tags``, for each unique batch in the ``batch_col`` indicator column,
     and within each unique phase, per batch, of the ``phase_col`` column.
 
-    Can be useful to get the 1-based index (it is a count!), and to then
-    use that index for other calculation purposes.
+    For data without internal gaps this count equals the 1-based index of the
+    final row, so it can also be used as that index for other calculations.
 
     See also: f_sum, f_last
     """
@@ -659,10 +659,10 @@ def f_elbow(  # noqa: PLR0913
                     elbow_index = np.nan
 
                 if only_index:
-                    output.loc[batch_id][tag] = elbow_index
+                    output.loc[batch_id, tag] = elbow_index
                 elif np.isnan(elbow_index):
-                    output.loc[batch_id][tag] = np.isnan
+                    output.loc[batch_id, tag] = np.nan
                 else:
-                    output.loc[batch_id][tag] = x_vals[elbow_index]
+                    output.loc[batch_id, tag] = x_vals[elbow_index]
 
     return output.rename(columns=dict(zip(tags, f_names, strict=False)))

{process_improve-1.22.0 → process_improve-1.22.2}/process_improve/batch/plotting.py

@@ -237,7 +237,7 @@ def colours_per_batch_id(
     Return a colour to use for each trace in the plot. A dictionary: keys are batch ids, and
     the value is a colour and line width setting for Plotly.
 
-    override_default_colour: bool
+    use_default_colour: bool
         If True, then the default colour is used (grey: 0.5, 0.5, 0.5)
     """
     if colour_map is None:
@@ -558,8 +558,8 @@ def plot_multitags(  # noqa: PLR0912, PLR0913, PLR0915
         method="animate",
         args=[
             # https://plotly.com/python/animations/
-            # Note the None is in a list!
-            [[None]],  # TODO: does not work at the moment.
+            # Note the None is in a list.
+            [None],
             dict(
                 frame=dict(duration=0, redraw=False),
                 transition=dict(duration=0),

{process_improve-1.22.0 → process_improve-1.22.2}/process_improve/batch/tools.py

@@ -53,7 +53,7 @@ _TIME_FEATURE_MAP = {
         "etc. for each batch and each measurement tag. "
         "The result is a feature matrix with one row per batch, suitable for multivariate "
         "analysis (e.g. PCA on batch data). "
-        "Available features: 'mean', 'median', 'std', 'iqr', 'mad', 'robust_mad', 'sum', "
+        "Available features: 'mean', 'median', 'std', 'iqr', 'sum', "
         "'min', 'max', 'last', 'count'. "
         "Time-dependent features (require time_column): 'area', 'slope'."
     ),
@@ -76,7 +76,7 @@ _TIME_FEATURE_MAP = {
                     "items": {
                         "type": "string",
                         "enum": [
-                            "mean", "median", "std", "iqr", "mad", "robust_mad",
+                            "mean", "median", "std", "iqr",
                             "sum", "min", "max", "last", "count", "area", "slope",
                         ],
                     },

{process_improve-1.22.0 → process_improve-1.22.2}/process_improve/bivariate/methods.py

@@ -16,13 +16,14 @@ def find_elbow_point(x: np.ndarray, y: np.ndarray, max_iter: int = 41) -> int |
     Find the elbow point when plotting numeric entries in `x` vs numeric values in list `y`.
 
     Return the index into the vectors `x` and `y` [the vectors must have the same length], where
-    the elbow point occurs.
+    the elbow point occurs. Returns -1 if every value in `x` or `y` is missing.
 
     Using a robust linear fit, sorts the samples in X (independent variable)
-    and takes sample 1:5 from the left, and samples (end-5):end and fits two
-    linear regressions, then computes the intersection of the two fitted lines.
-    Adds a point to each regression, so (1:6) and (end-6:end) and repeats,
-    accumulating one intersection point per iteration.
+    and takes the first 5 samples from the left, and the last 5 from the right,
+    then fits two linear regressions and computes the intersection of the two
+    fitted lines. The window size is then grown over `max_iter` (default 41)
+    evenly spaced steps, via `numpy.linspace`, up to roughly half the data,
+    accumulating one intersection point per step.
 
     The elbow is taken as the data point whose (x, y) location is closest to
     the median of the accumulated intersection points; the median location is

{process_improve-1.22.0 → process_improve-1.22.2}/process_improve/experiments/optimization.py

@@ -359,7 +359,9 @@ def _steepest_path(  # noqa: PLR0913
     step_size : float
         Step magnitude in coded units (default 0.5).
     n_steps : int
-        Number of steps to generate (default 10).
+        Number of steps to take away from the design centre (default 10).
+        The returned ``steps`` list has ``n_steps + 1`` entries because it
+        also includes step 0 at the centre.
     direction : str
         ``"ascent"`` or ``"descent"``.
     factor_ranges : dict or None

{process_improve-1.22.0 → process_improve-1.22.2}/process_improve/monitoring/control_charts.py

@@ -84,13 +84,17 @@ class ControlChart:
         """
         Find for a given vector `y`, the control chart target and limits.
 
-        Only for the Holt-Winters method, and only when there are more than
-            min(20, max(10, np.ceil(0.10 * N))))
+        Works for both the Holt-Winters ('hw') and 'xbar.no.subgroup' variants.
 
-        measurements, where N is the length of the input vector. In other words, the provided
-        target and standard deviation are only used if more than 10 to 20 measurements.
-        If `target` and `s` are numeric, then that target value and that standard deviation value
-        are used, otherwise these values are estimated.
+        For the Holt-Winters variant, when there are fewer than
+
+            min(20, max(10, np.ceil(0.10 * N)))
+
+        measurements (where N is the length of the input vector), the target and
+        standard deviation are estimated directly from the data and any provided
+        `target` / `s` are ignored for that small-sample case.
+        Otherwise, if `target` and `s` are numeric, those values are used;
+        if not, they are estimated.
         """
         self._given_target = target
         self._given_s = s
@@ -149,8 +153,8 @@ class ControlChart:
     def _xbar_no_subgroup_fit(self) -> None:
         """
         Fit the control chart from the data samples, assuming each sample is its own subgroup.
-        Variant = 'regulur' | 'robust' switchs how the average and standard deviation are
-        calculated.
+        The `style` attribute ('regular' | 'robust') switches how the average and standard
+        deviation are calculated.
 
         Control chart limits assume the data are normally distributed and independent. In
         particular, this last assumption can have consequences if not actually met. Limits may be

{process_improve-1.22.0 → process_improve-1.22.2}/process_improve/multivariate/methods.py

@@ -2972,17 +2972,22 @@ class TPLS(RegressorMixin, BaseEstimator):
     max_iter : int, optional
         The maximum number of iterations for the TPLS algorithm. Default is 500.
 
+    skip_f_matrix_preprocessing : bool, optional
+        If True, the F (formula) matrices are used as-is, skipping the internal
+        centering and scaling of the F block. Default is False.
+
     Notes
     -----
-    The input ``X`` is a dictionary with 4 keys:
+    The input ``X`` passed to :meth:`fit` and :meth:`predict` is a dictionary with 3 keys:
 
-    - ``D``: Database of DataFrames (properties in columns, materials in rows).
-      ``D = {"Group A": df_props_a, "Group B": df_props_b, ...}``
     - ``F``: Formula matrices (rows = blends, columns = materials).
       ``F = {"Group A": df_formulas_a, "Group B": df_formulas_b, ...}``
     - ``Z``: Process conditions - one row per blend, one column per condition.
     - ``Y``: Product quality indicators - one row per blend, one column per indicator.
 
+    The ``D`` matrix (database of material properties) is supplied once at
+    construction via the ``d_matrix`` argument; it is not part of ``X``.
+
     Attributes
     ----------
     n_samples : int
@@ -3014,8 +3019,8 @@ class TPLS(RegressorMixin, BaseEstimator):
     >>> }
     >>> process_conditions = {"Conditions": pd.DataFrame(rng.standard_normal((n_formulas, n_conditions)))}
     >>> quality_indicators = {"Quality":    pd.DataFrame(rng.standard_normal((n_formulas, n_outputs)))}
-    >>> all_data = {"Z": process_conditions, "D": properties, "F": formulas, "Y": quality_indicators}
-    >>> estimator = TPLS(n_components=4)
+    >>> all_data = {"Z": process_conditions, "F": formulas, "Y": quality_indicators}
+    >>> estimator = TPLS(n_components=4, d_matrix=properties)
     >>> estimator.fit(all_data)
     """
 
@@ -3063,7 +3068,7 @@ class TPLS(RegressorMixin, BaseEstimator):
 
         Parameters
         ----------
-        X : {dictionary of dataframes}, keys that must be present: "D", "F", "Z", and "Y"
+        X : {dictionary of dataframes}, keys that must be present: "F", "Z", and "Y"
             The training input samples. See documentation in the class definition for more information on each matrix.
 
         Returns
@@ -3238,7 +3243,7 @@ class TPLS(RegressorMixin, BaseEstimator):
 
         # Testing/inference phase:
         new_data = {"Z": ..., "F": ...}  # you need at least the F block for a new prediction. "Z" is optional.
-        predictions = estimator.predict(new_data_pp)
+        predictions = estimator.predict(new_data)
 
         Parameters
         ----------

{process_improve-1.22.0 → process_improve-1.22.2}/process_improve/multivariate/plots.py

@@ -29,7 +29,8 @@ def plot_pre_checks(model: BaseEstimator, pc_horiz: int, pc_vert: int, pc_depth:
         f"The model has {n_components} components. Ensure that 1 <= pc_vert<={n_components}."
     )
     assert -1 <= pc_depth <= n_components, (
-        f"The model has {n_components} components. Ensure that 1 <= pc_depth<={n_components}."
+        f"The model has {n_components} components. Ensure that pc_depth is -1 (no depth axis) "
+        f"or 1 <= pc_depth <= {n_components}."
     )
     assert len({pc_horiz, pc_vert, pc_depth}) == 3, "Specify distinct components for each axis"
 

{process_improve-1.22.0 → process_improve-1.22.2}/process_improve/regression/methods.py

@@ -85,17 +85,23 @@ def robust_regression(  # noqa: PLR0913, PLR0915
 
     Returns a dictionary of outputs with these keys::
 
-        coefficients:             a vector of K coefficients, one for each column in X
+        N:                        the number of observations used to fit the model
+        coefficients:             a length-1 list containing the regression slope
         intercept:                returned if fit_intercept==True, otherwise 0
-        standard_errors:          a vector of K standard errors, one per column in X
+        standard_errors:          a length-1 list containing the standard error of the slope
         standard_error_intercept: standard error for the intercept (np.nan if fit_intercept=False)
         R2:                       the R^2 value
         SE:                       the model's standard error
+        x_ssq:                    the sum of squares of (x - mean(x))
+        k:                        the number of model parameters (2 if fit_intercept else 1)
         fitted_values:            the N predicted values, one per row in y
         residuals:                the N residuals
         t_value:                  the t-values for the standard errors
         conf_intervals:           K rows x 2 columns (lower, upper) confidence intervals
+        conf_interval_intercept:  (lower, upper) confidence interval for the intercept
         pi_range:                 prediction intervals above and below, over the range of data
+        leverage:                 the hat-matrix diagonal (leverage) for each observation
+        influence:                Cook-style influence values for each observation
     """
 
     out: dict[str, Any] = {

{process_improve-1.22.0 → process_improve-1.22.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "process-improve"
-version = "1.22.0"
+version = "1.22.2"
 description = 'Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis.'
 readme = "README.md"
 license = "MIT"