pystatistics 3.0.1__tar.gz → 3.2.0__tar.gz

pystatistics-3.2.0/.release/UNRELEASED.md

@@ -0,0 +1,42 @@
+# Unreleased Changes
+
+> This file tracks all changes since the last stable release.
+> Updated by whoever makes a change, on whatever machine.
+> Synced via git so all sessions (Mac, Linux, etc.) see the same state.
+>
+> When ready to release, run: `python .release/release.py --status`
+> and follow the manual release flow in the script docstring.
+
+## Changes
+
+- **Apple Silicon (MPS) GPU support for FP32-capable backends.** The
+  `multinom`, `polr`, `gam`, and `arima`/`arima_batch` (Whittle) GPU
+  backends now run on Apple Silicon GPUs via `backend='gpu'`, using FP32
+  (MPS has no float64). Every operation on these paths is a native Metal
+  kernel — no silent CPU fallback. Results are validated against the CPU
+  reference at the `GPU_FP32` tolerance tier. `DataSource.to('mps')` now
+  works (float64 arrays are downcast to float32 on transfer, since MPS
+  has no float64). The CUDA FP64 path and its R-validation are unchanged.
+- **`backend='auto'` never selects MPS.** On Apple Silicon, `'auto'`
+  routes to the CPU (FP64, R-validated) path; MPS is opt-in only via an
+  explicit `backend='gpu'`. This makes `multinom`/`polr`/`gam`/`arima`
+  consistent with the existing `regression` and `mvnmle` dispatch policy.
+  CUDA is still auto-selected.
+- **PCA GPU remains CUDA-only by design.** PCA is fundamentally an
+  SVD / symmetric-eigendecomposition problem, and neither `linalg.svd`
+  (the `method='svd'` path) nor the eigendecomposition of `X'X` (the
+  `method='gram'` path) has a Metal kernel — both silently fall back to
+  the CPU on MPS. Rather than advertise a GPU path that isn't one,
+  `pca(backend='gpu')` now raises an actionable error on Apple Silicon
+  (use `backend='cpu'`, or `backend='auto'` which selects CPU on MPS).
+- **MVN MLE GPU remains CUDA-only by design.** The EM algorithm's
+  iterative small-step + per-pattern scatter workload is far slower on
+  Metal than on the CPU, so `mlest(algorithm='em', backend='gpu')` now
+  raises an actionable error on Apple Silicon (use `backend='cpu'`, or
+  `backend='auto'` which routes to CPU). Direct (BFGS) GPU fitting is
+  unaffected.
+- **Whittle ARIMA GPU FP32 convergence.** On the FP32 GPU path, an
+  L-BFGS-B `ABNORMAL_TERMINATION_IN_LNSRCH` at a stationary point (the
+  line search hitting the FP32 noise floor) is now accepted rather than
+  raised, matching the CPU fit at the `GPU_FP32` tier. The AR-stationarity
+  check still rejects genuinely bad optima. FP64 behaviour is unchanged.

{pystatistics-3.0.1 → pystatistics-3.2.0}/CHANGELOG.md

@@ -1,5 +1,93 @@
 # Changelog
 
+## 3.2.0
+
+Apple Silicon (MPS) GPU support for the FP32 backends, with honest,
+fail-fast boundaries where Metal can't deliver a real GPU path.
+
+- **GPU fitting now runs on Apple Silicon (MPS) for `multinom`, `polr`,
+  `gam`, and `arima` / `arima_batch` (Whittle).** Pass `backend='gpu'` on
+  a Mac with an Apple GPU to run these fits in FP32 on Metal. Every
+  operation on these paths is a native Metal kernel — there is no hidden
+  fallback to the CPU. Results match the CPU backend at the documented
+  GPU/FP32 tolerance tier. (MPS has no double precision, so `use_fp64=True`
+  is rejected on MPS; CUDA FP64 is unchanged.)
+- **`DataSource.to('mps')`** now transfers arrays to the Apple GPU,
+  downcasting float64 to float32 (MPS has no float64). This lets you pay
+  the host→device copy once and reuse a device-resident `DataSource`
+  across multiple GPU fits, as with CUDA.
+- **`backend='auto'` never selects MPS.** On Apple Silicon, `'auto'`
+  uses the CPU (double precision, the R-validated path); the Apple GPU is
+  opt-in only via an explicit `backend='gpu'`. CUDA continues to be
+  auto-selected. This matches how the regression and MVN MLE backends
+  already behaved.
+- **PCA and MVN MLE GPU remain CUDA-only.** `pca(backend='gpu')` and
+  `mlest(algorithm='em', backend='gpu')` now raise a clear error on Apple
+  Silicon instead of running silently on the CPU under a `gpu` label: PCA
+  needs an SVD / eigendecomposition that Metal does not implement, and the
+  EM algorithm's iterative, small-step pattern is far slower on Metal than
+  on the CPU. Use `backend='cpu'` (or `backend='auto'`, which selects the
+  CPU on MPS). CUDA is supported for both. MVN MLE *direct* (BFGS) GPU
+  fitting is unaffected and works on MPS.
+- **Whittle ARIMA GPU is more robust in FP32.** When the optimizer's line
+  search stalls at the FP32 noise floor on an already-converged fit, the
+  result is now accepted (it matches the CPU fit at the FP32 tier) instead
+  of raising a spurious convergence error. Non-stationary fits are still
+  rejected.
+
+## 3.1.0
+
+Categorical predictors and interaction terms in regression.
+
+- **Factor support in `fit()` and `coxph()`.** Regression models can now
+  include categorical predictors and interaction terms, alongside the
+  existing numeric-matrix path. Describe the model with a list of *terms*
+  passed to `Design.from_datasource(..., terms=...)`:
+
+  - a bare column name is a numeric main effect,
+  - `C(name, ref=...)` is a categorical predictor (treatment/dummy coded,
+    expanding a *k*-level factor into *k−1* indicator columns), with a
+    selectable reference (baseline) level — the first level in sorted order
+    by default,
+  - a tuple of those is an interaction (numeric×numeric, numeric×categorical,
+    and categorical×categorical are all supported).
+
+  This works for ordinary least squares, every GLM family, and Cox
+  proportional hazards (which remains intercept-free). Expanded columns are
+  labeled `sex[M]`, `treatment[B]:sex[M]`, and `coef`, `standard_errors`,
+  the test statistic, and `p_values` stay aligned to those labels. Interaction
+  columns follow R's `model.matrix` ordering (the first factor varies
+  fastest), and design matrices and fitted coefficients match R's
+  `lm`/`glm`/`survival::coxph` for factors and interactions.
+
+  ```python
+  from pystatistics import DataSource
+  from pystatistics.regression import Design, fit, C
+
+  ds = DataSource.from_dataframe(df)
+  design = Design.from_datasource(
+      ds, y="response",
+      terms=["age", C("sex", ref="F"), C("treatment", ref="A"),
+             (C("treatment", ref="A"), C("sex", ref="F"))],
+  )
+  result = fit(design)                       # family=… for GLMs
+  result.coef["treatment[B]:sex[M]"]
+  ```
+
+  New public symbol: `pystatistics.regression.C`.
+
+- **`DataSource.from_dataframe` preserves non-numeric columns.** Numeric
+  columns are still stored as float64; string/object/categorical columns are
+  now retained as-is instead of being force-cast (which previously raised on
+  string columns). These are the inputs encoded by `C(...)`.
+
+- **ETS now converges on (near-)perfectly-fit series.** The Gaussian
+  likelihood's variance floor is now relative to the data scale rather than a
+  fixed `1e-30`. On a noiseless or near-noiseless series the residual variance
+  no longer drives the objective toward an unbounded optimum, so the optimiser
+  reports convergence instead of an abnormal line-search termination. Fits on
+  ordinary (noisy) series are numerically unchanged.
+
 ## 3.0.1
 
 Metadata and documentation polish. No API changes.

{pystatistics-3.0.1 → pystatistics-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pystatistics
-Version: 3.0.1
+Version: 3.2.0
 Summary: GPU-accelerated statistical computing for Python
 Project-URL: Homepage, https://sgcx.org/technology/pystatistics/
 Project-URL: Documentation, https://sgcx.org/docs/pystatistics/
@@ -208,6 +208,27 @@ y_binary = (X @ [1, -1, 0.5, 0, 0] + np.random.randn(1000) > 0).astype(float)
 result = fit(X, y_binary, family='binomial')
 print(result.summary())
 
+# --- Categorical predictors & interactions ---
+# Describe a model as a list of terms (no R-style formula strings):
+#   "name"          -> numeric main effect
+#   C(name, ref=…)  -> categorical, treatment-coded with a chosen baseline
+#   (a, b)          -> interaction (numeric and/or categorical)
+from pystatistics import DataSource
+from pystatistics.regression import Design, fit, C
+
+ds = DataSource.from_dataframe(df)   # df has age, sex, treatment, response
+design = Design.from_datasource(
+    ds, y='response',
+    terms=['age', C('sex', ref='F'), C('treatment', ref='A'),
+           (C('treatment', ref='A'), C('sex', ref='F'))],
+)
+result = fit(design)                       # also works with family=… for GLMs
+print(result.coef['treatment[B]:sex[M]'])  # interaction coefficient
+
+# Cox PH takes the same spec (no intercept):
+from pystatistics.survival import coxph
+cox = coxph(time, event, ds, terms=['age', C('sex', ref='F')])
+
 # GPU acceleration (any model)
 result = fit(X, y, backend='gpu')
 
@@ -370,6 +391,39 @@ pip install pystatistics[dev]
 
 ## What's New
 
+### 3.2.0 — Apple Silicon (MPS) GPU support
+
+- `multinom`, `polr`, `gam`, and `arima` / `arima_batch` (Whittle) now run
+  on Apple Silicon GPUs with `backend='gpu'`, in FP32 and entirely on
+  native Metal kernels (no hidden CPU fallback). Results match the CPU
+  backend at the GPU/FP32 tolerance tier.
+- `DataSource.to('mps')` transfers data to the Apple GPU (float64 →
+  float32), so you can pay the host→device copy once and reuse it across
+  fits.
+- `backend='auto'` uses the CPU on Apple Silicon; the Apple GPU is opt-in
+  via an explicit `backend='gpu'`. CUDA is still auto-selected.
+- `pca` and MVN MLE `em` GPU paths remain CUDA-only and now raise a clear
+  error on Apple Silicon rather than silently running on the CPU — PCA's
+  SVD/eigendecomposition and the EM scatter/iteration pattern have no
+  efficient Metal equivalent. Use `backend='cpu'` or `'auto'` on a Mac.
+  (MVN MLE *direct* GPU fitting works on MPS.)
+- Whittle ARIMA GPU fits no longer raise a spurious convergence error when
+  the FP32 line search stalls at an already-converged optimum.
+
+### 3.1.0 — Categorical predictors & interaction terms
+
+- Regression now supports categorical predictors and interactions via a
+  `terms=` spec on `Design.from_datasource`: bare names are numeric main
+  effects, `C(name, ref=...)` marks a categorical predictor with a selectable
+  baseline level, and tuples express interactions (numeric and/or
+  categorical). Works for OLS, all GLM families, and Cox PH (no intercept).
+- Expanded columns are labeled `sex[M]`, `treatment[B]:sex[M]`, with `coef`
+  and inference outputs aligned to those labels. Design matrices match R's
+  `model.matrix` for factors and interactions.
+- `DataSource.from_dataframe` now keeps non-numeric columns as-is (previously
+  force-cast to float), so categorical columns can feed `C(...)`.
+- New public symbol: `pystatistics.regression.C`.
+
 ### 3.0.1 — Metadata and documentation polish
 
 - Development Status classifier bumped from Alpha to Production/Stable.

{pystatistics-3.0.1 → pystatistics-3.2.0}/README.md

@@ -161,6 +161,27 @@ y_binary = (X @ [1, -1, 0.5, 0, 0] + np.random.randn(1000) > 0).astype(float)
 result = fit(X, y_binary, family='binomial')
 print(result.summary())
 
+# --- Categorical predictors & interactions ---
+# Describe a model as a list of terms (no R-style formula strings):
+#   "name"          -> numeric main effect
+#   C(name, ref=…)  -> categorical, treatment-coded with a chosen baseline
+#   (a, b)          -> interaction (numeric and/or categorical)
+from pystatistics import DataSource
+from pystatistics.regression import Design, fit, C
+
+ds = DataSource.from_dataframe(df)   # df has age, sex, treatment, response
+design = Design.from_datasource(
+    ds, y='response',
+    terms=['age', C('sex', ref='F'), C('treatment', ref='A'),
+           (C('treatment', ref='A'), C('sex', ref='F'))],
+)
+result = fit(design)                       # also works with family=… for GLMs
+print(result.coef['treatment[B]:sex[M]'])  # interaction coefficient
+
+# Cox PH takes the same spec (no intercept):
+from pystatistics.survival import coxph
+cox = coxph(time, event, ds, terms=['age', C('sex', ref='F')])
+
 # GPU acceleration (any model)
 result = fit(X, y, backend='gpu')
 
@@ -323,6 +344,39 @@ pip install pystatistics[dev]
 
 ## What's New
 
+### 3.2.0 — Apple Silicon (MPS) GPU support
+
+- `multinom`, `polr`, `gam`, and `arima` / `arima_batch` (Whittle) now run
+  on Apple Silicon GPUs with `backend='gpu'`, in FP32 and entirely on
+  native Metal kernels (no hidden CPU fallback). Results match the CPU
+  backend at the GPU/FP32 tolerance tier.
+- `DataSource.to('mps')` transfers data to the Apple GPU (float64 →
+  float32), so you can pay the host→device copy once and reuse it across
+  fits.
+- `backend='auto'` uses the CPU on Apple Silicon; the Apple GPU is opt-in
+  via an explicit `backend='gpu'`. CUDA is still auto-selected.
+- `pca` and MVN MLE `em` GPU paths remain CUDA-only and now raise a clear
+  error on Apple Silicon rather than silently running on the CPU — PCA's
+  SVD/eigendecomposition and the EM scatter/iteration pattern have no
+  efficient Metal equivalent. Use `backend='cpu'` or `'auto'` on a Mac.
+  (MVN MLE *direct* GPU fitting works on MPS.)
+- Whittle ARIMA GPU fits no longer raise a spurious convergence error when
+  the FP32 line search stalls at an already-converged optimum.
+
+### 3.1.0 — Categorical predictors & interaction terms
+
+- Regression now supports categorical predictors and interactions via a
+  `terms=` spec on `Design.from_datasource`: bare names are numeric main
+  effects, `C(name, ref=...)` marks a categorical predictor with a selectable
+  baseline level, and tuples express interactions (numeric and/or
+  categorical). Works for OLS, all GLM families, and Cox PH (no intercept).
+- Expanded columns are labeled `sex[M]`, `treatment[B]:sex[M]`, with `coef`
+  and inference outputs aligned to those labels. Design matrices match R's
+  `model.matrix` for factors and interactions.
+- `DataSource.from_dataframe` now keeps non-numeric columns as-is (previously
+  force-cast to float), so categorical columns can feed `C(...)`.
+- New public symbol: `pystatistics.regression.C`.
+
 ### 3.0.1 — Metadata and documentation polish
 
 - Development Status classifier bumped from Alpha to Production/Stable.

{pystatistics-3.0.1 → pystatistics-3.2.0}/docs/ROADMAP.md

@@ -114,6 +114,25 @@ Shared infrastructure lives in `core/`: DataSource, Result[P], device detection,
 - **GPU applicability**: MODERATE — depends on specific methods; Kalman filtering has sequential dependencies but spectral analysis parallelizes well
 - **R validation**: `arima()`, `forecast` package
 
+#### Demand-driven primitives (pulled in when a domain vertical needs them)
+
+These are genuinely general-purpose primitives identified while scoping the
+`pystats[domain]` libraries (clinical / genomic / finance / insurance). They
+belong here rather than in any single domain library because **≥2 separate
+domains share the exact same underlying mechanic** (the promotion rule). But
+they are specialized enough that they are **not worth implementing in isolation**
+— we implement each one *when the first domain vertical actually needs it*, then
+that domain pegs the new `pystatistics` version. Until then they stay on this
+list as candidates, not commitments.
+
+- [ ] **Parametric distribution fitting (`fitdist`)** — MLE fit of common
+  parametric distributions (lognormal, gamma, Pareto, Weibull, …) with
+  goodness-of-fit. *Shared by:* insurance severity modeling, finance
+  parametric return/loss distributions. **Priority**: ON-DEMAND.
+- [ ] **Extreme-value theory / peaks-over-threshold (GPD)** — generalized Pareto
+  tail fitting and tail-quantile estimation. *Shared by:* finance tail risk,
+  insurance large-loss modeling. **Priority**: ON-DEMAND.
+
 ---
 
 ## Implementation Priority

pystatistics-3.2.0/docs/gam.rst

@@ -0,0 +1,9 @@
+Generalized Additive Models
+============================
+
+Penalized regression spline GAMs via P-IRLS matching R's ``mgcv::gam()``.
+
+.. automodule:: pystatistics.gam
+   :members:
+   :undoc-members:
+   :show-inheritance:

{pystatistics-3.0.1 → pystatistics-3.2.0}/docs/index.rst

@@ -8,6 +8,11 @@ GPU-accelerated statistical computing for Python. Validated against R to machine
    :caption: Modules
 
    regression
+   ordinal
+   multinomial
+   multivariate
+   timeseries
+   gam
    descriptive
    hypothesis
    montecarlo

pystatistics-3.2.0/docs/multinomial.rst

@@ -0,0 +1,9 @@
+Multinomial Regression
+======================
+
+Multinomial logit (softmax) regression matching R's ``nnet::multinom()``.
+
+.. automodule:: pystatistics.multinomial
+   :members:
+   :undoc-members:
+   :show-inheritance:

pystatistics-3.2.0/docs/multivariate.rst

@@ -0,0 +1,9 @@
+Multivariate Analysis
+=====================
+
+Principal component analysis and maximum likelihood factor analysis with varimax and promax rotations.
+
+.. automodule:: pystatistics.multivariate
+   :members:
+   :undoc-members:
+   :show-inheritance:

pystatistics-3.2.0/docs/ordinal.rst

@@ -0,0 +1,9 @@
+Ordinal Regression
+==================
+
+Proportional odds (cumulative link) models matching R's ``MASS::polr()``. Supports logistic, probit, and complementary log-log links.
+
+.. automodule:: pystatistics.ordinal
+   :members:
+   :undoc-members:
+   :show-inheritance:

pystatistics-3.2.0/docs/timeseries.rst

@@ -0,0 +1,9 @@
+Time Series
+===========
+
+Complete time series analysis: ACF/PACF, stationarity tests, ETS, ARIMA/SARIMA, automatic model selection, and decomposition.
+
+.. automodule:: pystatistics.timeseries
+   :members:
+   :undoc-members:
+   :show-inheritance:

{pystatistics-3.0.1 → pystatistics-3.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pystatistics"
-version = "3.0.1"
+version = "3.2.0"
 description = "GPU-accelerated statistical computing for Python"
 readme = "README.md"
 license = "MIT"

{pystatistics-3.0.1 → pystatistics-3.2.0}/pystatistics/__init__.py

@@ -16,7 +16,7 @@ Usage:
     result = fit(design)
 """
 
-__version__ = "3.0.1"
+__version__ = "3.2.0"
 __author__ = "Hai-Shuo"
 __email__ = "contact@sgcx.org"
 

pystatistics-3.2.0/pystatistics/anova/_contrasts.py

@@ -0,0 +1,28 @@
+"""
+ANOVA contrast coding — re-export shim.
+
+The categorical-encoding engine is shared library-wide and lives in
+``pystatistics.core.encoding`` (used by both ANOVA and regression). ANOVA
+historically refers to these operations with R's "contrast" vocabulary, so
+this module re-exports the engine under the legacy ANOVA-facing names:
+
+    encode_treatment   -> encode_dummy
+    build_model_matrix -> build_design_matrix
+    ModelMatrix        -> DesignMatrix
+"""
+
+from pystatistics.core.encoding import (
+    DesignMatrix as ModelMatrix,
+    build_design_matrix as build_model_matrix,
+    encode_deviation,
+    encode_dummy as encode_treatment,
+    interaction_columns,
+)
+
+__all__ = [
+    "ModelMatrix",
+    "build_model_matrix",
+    "encode_deviation",
+    "encode_treatment",
+    "interaction_columns",
+]

{pystatistics-3.0.1 → pystatistics-3.2.0}/pystatistics/core/compute/device.py

@@ -118,12 +118,23 @@ def select_device(prefer: Literal['cpu', 'gpu', 'auto'] = 'auto') -> DeviceInfo:
             - 'cpu': Always use CPU
             - 'gpu': Require GPU (raises if unavailable)
             - 'auto': Use GPU if available, else CPU
-            
+
     Returns:
         DeviceInfo for selected device
-        
+
     Raises:
         RuntimeError: If 'gpu' requested but no GPU available
+
+    Note:
+        This is a hardware *detector*: with ``prefer='auto'`` it returns
+        the best available GPU, which includes Apple Silicon MPS. It does
+        NOT encode the project's dispatch policy. The fitting functions
+        deliberately do NOT auto-select MPS (it is FP32-only and not the
+        R-validated default); they treat ``'auto'`` as "GPU only if
+        ``device_type == 'cuda'``, else CPU", and run on MPS only when the
+        caller passes ``backend='gpu'`` explicitly. Keep that check in the
+        caller, not here, so ``select_device`` stays a pure capability
+        query.
     """
     if prefer == 'cpu':
         return get_cpu_info()

{pystatistics-3.0.1 → pystatistics-3.2.0}/pystatistics/core/compute/linalg/batched.py

@@ -145,9 +145,16 @@ def _batched_ols_gpu(X: NDArray, Y: NDArray, device: str) -> NDArray:
             L.T, Z, upper=True,
         )
     except torch._C._LinAlgError:
-        # Fallback: lstsq
-        result = torch.linalg.lstsq(X_t, Y_t)
-        B = result.solution
+        # Fallback for rank-deficient X: lstsq. MPS has no lstsq, and
+        # the normal-equations Cholesky we just tried is exactly what
+        # failed, so route the rank-revealing solve through CPU LAPACK
+        # (the matrices are small here and this path is rare).
+        if torch_device.type == 'mps':
+            result = torch.linalg.lstsq(X_t.cpu(), Y_t.cpu())
+            B = result.solution.to(torch_device)
+        else:
+            result = torch.linalg.lstsq(X_t, Y_t)
+            B = result.solution
 
     # Transfer back to CPU
     return B.cpu().numpy().astype(np.float64)

pystatistics-3.2.0/pystatistics/core/compute/torch_interop.py

@@ -0,0 +1,48 @@
+"""Host/device transfer helpers for the PyTorch GPU backends.
+
+One job: move tensors off a compute device into host numpy arrays
+correctly across CUDA and Apple Silicon (MPS).
+
+The single invariant this module exists to enforce:
+
+    Cast to float64 only AFTER moving the tensor to the host.
+
+MPS has no float64 dtype, so an on-device ``tensor.to(torch.float64)``
+raises ``TypeError: Cannot convert a MPS Tensor to float64``. The
+download must therefore be ``.cpu().to(torch.float64)``, never
+``.to(torch.float64).cpu()``. Centralising it here means no backend
+can reintroduce the device-side cast by accident (Coding Bible: make
+the wrong thing hard to do accidentally).
+
+This is also correct and lossless on CUDA: for a float64-on-device
+tensor the host-side cast is a no-op; for a float32 tensor the
+resulting float64 values are identical regardless of cast order.
+
+``torch`` is imported lazily inside each function so that importing
+this module never pulls torch into a CPU-only install.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+def to_host_f64(tensor: Any) -> NDArray[np.float64]:
+    """Download a torch tensor to a contiguous float64 numpy array.
+
+    Detaches from autograd, moves to the host, then casts to float64
+    (in that order — see the module docstring for why the order is
+    load-bearing on MPS). Safe on CUDA, MPS, and CPU tensors.
+
+    Args:
+        tensor: A ``torch.Tensor`` on any device.
+
+    Returns:
+        A float64 ``numpy.ndarray`` with the tensor's values.
+    """
+    import torch
+
+    return tensor.detach().cpu().to(torch.float64).numpy()

{pystatistics-3.0.1 → pystatistics-3.2.0}/pystatistics/core/datasource.py

@@ -197,11 +197,24 @@ class DataSource:
     
     @classmethod
     def from_dataframe(cls, df: 'pd.DataFrame', *, source_path: str | None = None) -> DataSource:
-        """Construct from pandas DataFrame."""
+        """Construct from pandas DataFrame.
+
+        Numeric columns are stored as float64. Non-numeric columns (strings,
+        objects, pandas categoricals) are preserved as-is rather than being
+        force-cast — they are the raw material for categorical predictors,
+        which the regression term builder encodes via C(...). Force-casting
+        them to float would either crash or silently corrupt the data.
+        """
+        import pandas as pd
+
         storage: dict[str, Any] = {}
-        
+
         for col in df.columns:
-            storage[col] = df[col].to_numpy(dtype=np.float64)
+            series = df[col]
+            if pd.api.types.is_numeric_dtype(series):
+                storage[col] = series.to_numpy(dtype=np.float64)
+            else:
+                storage[col] = series.to_numpy()
         
         metadata = {
             'n_observations': len(df),
@@ -372,11 +385,19 @@ class DataSource:
             else:
                 # Coerce numpy→torch on device; move torch to device.
                 if isinstance(value, torch.Tensor):
-                    new_storage[key] = value.to(target)
+                    tensor = value
                 elif isinstance(value, np.ndarray):
-                    new_storage[key] = torch.as_tensor(value).to(target)
+                    tensor = torch.as_tensor(value)
                 else:
                     new_storage[key] = value
+                    continue
+                # MPS has no float64. Downcast double tensors to float32
+                # before transfer so the device-resident path works on
+                # Apple Silicon; CUDA keeps the source dtype (FP64 is the
+                # R-validated path there).
+                if target.type == "mps" and tensor.dtype == torch.float64:
+                    tensor = tensor.to(torch.float32)
+                new_storage[key] = tensor.to(target)
 
         capabilities = {CAPABILITY_MATERIALIZED, CAPABILITY_REPEATABLE}
         if target_is_gpu: