lme-python 0.1.1__tar.gz → 0.1.2__tar.gz

{lme_python-0.1.1 → lme_python-0.1.2}/Cargo.lock

@@ -1528,7 +1528,7 @@ checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "lme-rs"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "anyhow",
  "argmin",

{lme_python-0.1.1 → lme_python-0.1.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lme-rs"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 authors = ["Martin Huck <x4g4p3x@users.noreply.github.com>"]
 description = "Rust port of R's lme4: linear mixed-effects models with 1:1 numerical compatibility"

{lme_python-0.1.1 → lme_python-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lme_python
-Version: 0.1.1
+Version: 0.1.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{lme_python-0.1.1 → lme_python-0.1.2}/benches/bench_math.rs

@@ -126,7 +126,7 @@ fn bench_deviance_evaluation(c: &mut Criterion) {
 }
 
 fn load_csv(path: &str) -> DataFrame {
-    let mut file = File::open(path).expect(&format!("Could not open {}", path));
+    let mut file = File::open(path).unwrap_or_else(|_| panic!("Could not open {}", path));
     CsvReadOptions::default()
         .with_has_header(true)
         .into_reader_with_file_handle(&mut file)

{lme_python-0.1.1 → lme_python-0.1.2}/python/Cargo.lock

@@ -1291,7 +1291,7 @@ checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "lme-rs"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "anyhow",
  "argmin",
@@ -1313,7 +1313,7 @@ dependencies = [
 
 [[package]]
 name = "lme_python"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "lme-rs",
  "polars",

{lme_python-0.1.1 → lme_python-0.1.2}/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lme_python"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 authors = ["Martin Huck <x4g4p3x@users.noreply.github.com>"]
 description = "Python bindings for lme-rs"

{lme_python-0.1.1 → lme_python-0.1.2}/python/PYTHON_GUIDE.md

@@ -166,14 +166,37 @@ df = pl.read_csv("tests/data/sleepstudy.csv")
 model = lme_python.lmer("Reaction ~ Days + (Days | Subject)", data=df)
 print(model)
 
-# Predict for new data
+# Population-level predictions (fixed effects only)
 newdata = pl.DataFrame({
     "Days": [0.0, 1.0, 5.0, 10.0],
     "Subject": ["308", "308", "308", "308"],
 })
-preds = model.predict(newdata)
-print(f"Predictions: {preds}")
+preds_pop = model.predict(newdata)
+print(f"Pop Predictions: {preds_pop}")
 # [251.405, 261.872, 303.742, 356.078]
+
+# Conditional predictions (fixed + random effects)
+# Set allow_new_levels=True if predicting for unseen groups
+preds_cond = model.predict_conditional(newdata, allow_new_levels=True)
+print(f"Cond Predictions: {preds_cond}")
+```
+
+### Confidence Intervals and Standard Errors
+
+```python
+import polars as pl
+import lme_python
+
+df = pl.read_csv("tests/data/sleepstudy.csv")
+model = lme_python.lmer("Reaction ~ Days + (Days | Subject)", data=df)
+
+# Standard errors for fixed effects
+print(f"Standard Errors: {model.std_errors}")
+
+# 95% Wald confidence intervals for fixed effects
+# Returns list of tuples: [(lower1, upper1), (lower2, upper2), ...]
+ci = model.confint(level=0.95)
+print(f"95% CI: {ci}")
 ```
 
 ### Intercept-Only Model
@@ -206,6 +229,17 @@ model = lme_python.glmer(
     family_name="binomial"
 )
 print(model)
+
+# For GLMMs, predict_response() returns probabilities (Binomial) or rates (Poisson)
+newdata = pl.DataFrame({
+    "period2": [1.0, 0.0],
+    "period3": [0.0, 1.0],
+    "period4": [0.0, 0.0],
+    "herd": ["1", "1"]
+})
+# Returns predictions on the response scale [0, 1]
+probs = model.predict_response(newdata)
+print(f"Probabilities: {probs}")
 ```
 
 ### Nested Random Effects

lme_python-0.1.2/python/tests/test_basic.py

@@ -0,0 +1,164 @@
+import pytest
+import polars as pl
+import lme_python
+import math
+
+def test_lmer_sleepstudy():
+    # Load identical data used in rust tests
+    df = pl.read_csv("../tests/data/sleepstudy.csv")
+    
+    # Fit model natively via rust
+    model = lme_python.lmer("Reaction ~ Days + (Days | Subject)", data=df, reml=True)
+    summary = model.summary()
+    
+    print("\n--- Model Summary ---")
+    print(summary)
+    
+    # Check that REML objective is embedded in the summary string
+    assert "1743.6" in summary
+    assert "611.9033" in summary  # Intercept variance
+    
+    # Check properties
+    assert model.converged is True
+    assert model.num_obs == 180
+    assert len(model.coefficients) == 2
+    assert model.fixed_names == ["(Intercept)", "Days"]
+    assert model.sigma2 is not None
+    assert abs(model.sigma2 - 654.94) < 0.1
+    assert model.log_likelihood is not None
+    assert model.aic is not None
+    assert model.bic is not None
+    assert model.deviance is not None
+
+    # Test confint
+    ci = model.confint(0.95)
+    assert len(ci) == 2
+    assert ci[0][0] < model.coefficients[0] < ci[0][1]
+    
+    # Test predictions
+    preds = model.predict(df)
+    assert len(preds) == 180
+    # First prediction for sleepstudy should match R output closely (population level)
+    assert abs(preds[0] - 251.405105) < 1e-4
+
+    # Test conditional predictions
+    cond_preds = model.predict_conditional(df, allow_new_levels=False)
+    assert len(cond_preds) == 180
+    assert abs(cond_preds[0] - preds[0]) > 0.1 # Subject level effect should make it differ from population
+
+    # Test residuals and fitted
+    assert len(model.residuals) == 180
+    assert len(model.fitted) == 180
+    
+def test_glmer_poisson():
+    df = pl.read_csv("../tests/data/grouseticks.csv")
+    # Ticks ~ Year + Height + (1|BROOD)
+    model = lme_python.glmer("TICKS ~ YEAR + HEIGHT + (1 | BROOD)", data=df, family_name="poisson")
+    
+    assert model.converged is True
+    assert model.sigma2 is None # Poisson has no dispersion
+    assert len(model.coefficients) == 3
+    
+    preds_link = model.predict(df)
+    preds_resp = model.predict_response(df)
+    
+    # Link scale (log) should be different from response scale
+    assert preds_link[0] != preds_resp[0]
+    assert abs(math.exp(preds_link[0]) - preds_resp[0]) < 1e-6
+    
+def test_glmer_binomial():
+    df = pl.read_csv("../tests/data/cbpp_binary.csv")
+    model = lme_python.glmer("y ~ period2 + period3 + period4 + (1 | herd)", data=df, family_name="binomial")
+    
+    assert model.converged is True
+    assert model.sigma2 is None # Binomial has no dispersion
+    assert len(model.coefficients) == 4
+    
+    preds_resp = model.predict_response(df)
+    # Binomial response predictions should be probabilities [0, 1]
+    assert all(0.0 <= p <= 1.0 for p in preds_resp)
+
+def test_invalid_family():
+    df = pl.read_csv("../tests/data/sleepstudy.csv")
+    with pytest.raises(ValueError, match="Unsupported or invalid family"):
+        lme_python.glmer("Reaction ~ Days + (Days | Subject)", data=df, family_name="invalid_family")
+
+def test_missing_column():
+    df = pl.read_csv("../tests/data/sleepstudy.csv")
+    with pytest.raises(ValueError):
+         # MissingCol is not in sleepstudy
+        lme_python.lmer("Reaction ~ MissingCol + (1 | Subject)", data=df)
+
+def test_lmer_ml_estimation():
+    df = pl.read_csv("../tests/data/sleepstudy.csv")
+    model = lme_python.lmer("Reaction ~ Days + (Days | Subject)", data=df, reml=False)
+    assert model.converged is True
+    # The REML objective is larger than ML objective for the same model
+    assert "REML criterion" not in model.summary()
+
+def test_glmer_gamma():
+    df = pl.read_csv("../tests/data/dyestuff.csv")
+    model = lme_python.glmer("Yield ~ 1 + (1 | Batch)", data=df, family_name="gamma")
+    assert model.converged is True
+    assert model.sigma2 is not None # Gamma has dispersion
+    assert len(model.coefficients) == 1
+
+def test_predictions_with_new_data():
+    df = pl.read_csv("../tests/data/sleepstudy.csv")
+    model = lme_python.lmer("Reaction ~ Days + (Days | Subject)", data=df, reml=True)
+    
+    # Subset to just 2 rows
+    subset_df = df.head(2)
+    preds = model.predict(subset_df)
+    assert len(preds) == 2
+    
+def test_conditional_predictions_unseen_levels():
+    df = pl.read_csv("../tests/data/sleepstudy.csv")
+    model = lme_python.lmer("Reaction ~ Days + (Days | Subject)", data=df, reml=True)
+    
+    # Create a dataframe with an entirely unseen subject level
+    new_level_df = pl.DataFrame({
+        "Reaction": [250.0],
+        "Days": [0],
+        "Subject": ["UNSEEN_SUBJECT_999"]
+    })
+    
+    # Should throw an error natively when allow_new_levels=False
+    with pytest.raises(ValueError):
+        model.predict_conditional(new_level_df, allow_new_levels=False)
+        
+    # Should fallback to population level securely when allow_new_levels=True
+    cond_preds = model.predict_conditional(new_level_df, allow_new_levels=True)
+    pop_preds = model.predict(new_level_df)
+    assert len(cond_preds) == 1
+    assert abs(cond_preds[0] - pop_preds[0]) < 1e-6
+    
+def test_predict_missing_columns():
+    df = pl.read_csv("../tests/data/sleepstudy.csv")
+    model = lme_python.lmer("Reaction ~ Days + (Days | Subject)", data=df, reml=True)
+    
+    bad_df = pl.DataFrame({"Reaction": [250.0], "Subject": ["308"]}) # Missing 'Days'
+    with pytest.raises(ValueError):
+        model.predict(bad_df)
+
+def test_std_errors():
+    df = pl.read_csv("../tests/data/sleepstudy.csv")
+    model = lme_python.lmer("Reaction ~ Days + (Days | Subject)", data=df, reml=True)
+    
+    se = model.std_errors
+    assert se is not None
+    assert len(se) == 2
+    assert se[0] > 0
+    assert se[1] > 0
+
+if __name__ == "__main__":
+    test_lmer_sleepstudy()
+    test_glmer_poisson()
+    test_glmer_binomial()
+    test_lmer_ml_estimation()
+    test_glmer_gamma()
+    test_predictions_with_new_data()
+    test_conditional_predictions_unseen_levels()
+    test_predict_missing_columns()
+    test_std_errors()
+    print("All tests passed natively")

{lme_python-0.1.1 → lme_python-0.1.2}/src/family.rs

@@ -286,6 +286,10 @@ impl GlmFamily for BinomialFamily {
         let mut d = Array1::zeros(n);
         for i in 0..n {
             let yi = y[i];
+            if !(0.0..=1.0).contains(&yi) {
+                d[i] = f64::NAN;
+                continue;
+            }
             let mi = mu[i].clamp(f64::EPSILON, 1.0 - f64::EPSILON);
             let wi = wt[i];
             let mut dev_i = 0.0;
@@ -351,6 +355,10 @@ impl GlmFamily for PoissonFamily {
         let mut d = Array1::zeros(n);
         for i in 0..n {
             let yi = y[i];
+            if yi < 0.0 {
+                d[i] = f64::NAN;
+                continue;
+            }
             let mi = mu[i].max(f64::EPSILON);
             let wi = wt[i];
             let mut dev_i = -(yi - mi);
@@ -467,10 +475,15 @@ impl GlmFamily for GammaFamily {
         let n = y.len();
         let mut d = Array1::zeros(n);
         for i in 0..n {
-            let yi = y[i].max(f64::EPSILON);
+            let yi = y[i];
+            if yi <= 0.0 {
+                d[i] = f64::NAN;
+                continue;
+            }
+            let yi_clamped = yi.max(f64::EPSILON);
             let mi = mu[i].max(f64::EPSILON);
             let wi = wt[i];
-            d[i] = 2.0 * wi * (-(yi / mi).ln() + (yi - mi) / mi);
+            d[i] = 2.0 * wi * (-(yi_clamped / mi).ln() + (yi_clamped - mi) / mi);
         }
         d
     }

{lme_python-0.1.1 → lme_python-0.1.2}/tests/test_coverage_edge_cases.rs

@@ -1,6 +1,4 @@
 use lme_rs::family::Family;
-use lme_rs::optimizer::{optimize_theta_glmm, optimize_theta_nd};
-use ndarray::{array, Array2};
 use polars::prelude::*;
 
 #[test]

{lme_python-0.1.1 → lme_python-0.1.2}/tests/test_robust.rs

@@ -1,5 +1,4 @@
 use lme_rs::lmer;
-use ndarray::Array1;
 use polars::prelude::*;
 use serde::Deserialize;
 

lme_python-0.1.1/python/tests/test_basic.py

@@ -1,27 +0,0 @@
-import pytest
-import polars as pl
-import lme_python
-
-def test_lmer_sleepstudy():
-    # Load identical data used in rust tests
-    df = pl.read_csv("../tests/data/sleepstudy.csv")
-    
-    # Fit model natively via rust
-    model = lme_python.lmer("Reaction ~ Days + (Days | Subject)", data=df, reml=True)
-    summary = model.summary()
-    
-    print("\n--- Model Summary ---")
-    print(summary)
-    
-    # Check that REML objective is embedded in the summary string
-    assert "1743.6" in summary
-    assert "611.9033" in summary  # Intercept variance
-    
-    # Test predictions
-    preds = model.predict(df)
-    assert len(preds) == 180
-    # First prediction for sleepstudy should match R output closely
-    assert abs(preds[0] - 251.405105) < 1e-4
-
-if __name__ == "__main__":
-    test_lmer_sleepstudy()