0.32.2

Author: bartzbeielstein

test/test_build_Psi_matrix.py

@@ -0,0 +1,130 @@
+import numpy as np
+import pytest
+from spotpython.surrogate.kriging import Kriging
+from numpy.linalg import LinAlgError
+
+def test_build_Psi_basic_properties():
+    """Test basic properties of the correlation matrix"""
+    # Setup
+    X = np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]])
+    y = np.array([0.0, 1.0, 2.0])
+    model = Kriging()
+    model.fit(X, y)
+    
+    # Get upper triangle of Psi
+    Psi_upper = model.build_Psi()
+    n = X.shape[0]
+    
+    # Test shape
+    assert Psi_upper.shape == (n, n)
+    
+    # Test that it's upper triangular (lower part is zero)
+    assert np.allclose(np.tril(Psi_upper, k=-1), 0)
+    
+    # Test values are between 0 and 1
+    assert np.all(Psi_upper >= 0)
+    assert np.all(Psi_upper <= 1)
+
+def test_build_Psi_symmetry():
+    """Test that the full correlation matrix is symmetric"""
+    X = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]])
+    y = np.array([0.0, 1.0, 1.0])
+    model = Kriging()
+    model.fit(X, y)
+    
+    Psi_upper = model.build_Psi()
+    # Construct full Psi (add upper triangle to its transpose)
+    Psi_full = Psi_upper + Psi_upper.T + np.eye(X.shape[0])
+    
+    # Test symmetry
+    assert np.allclose(Psi_full, Psi_full.T)
+
+def test_build_Psi_distance_correlation():
+    """Test that correlation decreases with distance"""
+    X = np.array([[0.0, 0.0], [0.1, 0.1], [1.0, 1.0]])
+    y = np.array([0.0, 0.1, 1.0])
+    model = Kriging()
+    model.fit(X, y)
+    
+    Psi_upper = model.build_Psi()
+    
+    # Points closer together should have higher correlation
+    # than points further apart
+    corr_close = Psi_upper[0, 1]  # correlation between [0,0] and [0.1,0.1]
+    corr_far = Psi_upper[0, 2]    # correlation between [0,0] and [1.0,1.0]
+    assert corr_close > corr_far
+
+def test_build_Psi_with_categorical():
+    """Test Psi correlation matrix construction with mixed numeric and categorical variables"""
+    # Create a simple dataset with clear categorical patterns
+    X = np.array([
+        [0.5, 0],  # First point, category 0
+        [0.6, 0],  # Close to first point, same category
+        [0.5, 1],  # Same as first point but different category
+    ])
+    y = np.array([0.0, 0.1, 1.0])
+    
+    # Initialize Kriging with explicit categorical specification
+    model = Kriging(
+        var_type=["num", "factor"],
+        theta0=[1.0, 1.0],  # Set initial theta values
+        nugget=1e-6         # Add small nugget for numerical stability
+    )
+    model.fit(X, y)
+    
+    Psi_upper = model.build_Psi()
+    
+    # Points 0 and 1: Similar x-values, same category
+    corr_same_cat = Psi_upper[0, 1]
+    # Points 0 and 2: Same x-value, different category
+    corr_diff_cat = Psi_upper[0, 2]
+    
+    print(f"Correlation for same category: {corr_same_cat}")
+    print(f"Correlation for different category: {corr_diff_cat}")
+    
+    # Use np.isclose with high relative tolerance for numerical stability
+    assert corr_same_cat > 0.1  # Should have meaningful correlation
+    assert corr_diff_cat < corr_same_cat  # Different category should have lower correlation
+
+def test_build_Psi_isotropic():
+    """Test Psi construction with isotropic model"""
+    X = np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]])
+    y = np.array([0.0, 1.0, 2.0])
+    model = Kriging(isotropic=True)
+    model.fit(X, y)
+    
+    Psi_upper = model.build_Psi()
+    
+    # For isotropic model, correlations should depend only on
+    # total distance, not direction
+    dist_01 = np.sqrt(2)  # distance between points 0 and 1
+    dist_12 = np.sqrt(2)  # distance between points 1 and 2
+    assert np.isclose(Psi_upper[0, 1], Psi_upper[1, 2])
+
+def test_build_Psi_numerical_stability():
+    """Test numerical stability with less extreme values"""
+    X = np.array([[0.0, 0.0], 
+                  [1e-5, 1e-5],  # Changed from 1e-10 
+                  [1.0, 1.0]])
+    y = np.array([0.0, 1e-5, 1.0])  # Changed from 1e-10
+    model = Kriging(nugget=1e-6)  # Add small nugget for stability
+    model.fit(X, y)
+    
+    Psi_upper = model.build_Psi()
+    
+    # Check that matrix is not ill-conditioned
+    assert not np.any(np.isnan(Psi_upper))
+    assert not np.any(np.isinf(Psi_upper))
+    assert model.cnd_Psi < 1e12  # Relaxed condition number threshold
+
+def test_build_Psi_errors():
+    """Test error handling"""
+    # Use empty arrays instead of single point
+    X = np.array([])  
+    y = np.array([])
+    model = Kriging()
+    
+    # Should raise error for empty arrays
+    with pytest.raises((ValueError, LinAlgError)):
+        model.fit(X, y)
+        model.build_Psi()

test/test_build_psi_vector.py

@@ -0,0 +1,108 @@
+import numpy as np
+import pytest
+from spotpython.surrogate.kriging import Kriging
+
+
+def test_build_psi_vec_basic():
+    """Test basic functionality of build_psi_vec"""
+    # Setup simple test case
+    X = np.array([[0.0, 0.0], [1.0, 1.0]])
+    y = np.array([0.0, 1.0])
+    
+    model = Kriging()
+    model.fit(X, y)
+    
+    # Test point
+    x_test = np.array([0.5, 0.5])
+    psi = model.build_psi_vec(x_test)
+    
+    # Check shape and basic properties
+    assert psi.shape == (2,)
+    assert np.all(psi >= 0) and np.all(psi <= 1)
+
+
+def test_build_psi_vec_isotropic():
+    """Test build_psi_vec with isotropic model"""
+    X = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]])
+    y = np.array([0.0, 1.0, 1.0])
+    
+    model = Kriging(isotropic=True)
+    model.fit(X, y)
+    
+    # Points with same distance should have same correlation
+    x_test1 = np.array([0.5, 0.0])  # Distance 0.5 from [0,0]
+    x_test2 = np.array([0.0, 0.5])  # Distance 0.5 from [0,0]
+    
+    psi1 = model.build_psi_vec(x_test1)
+    psi2 = model.build_psi_vec(x_test2)
+    
+    assert np.allclose(psi1, psi2)
+
+
+def test_build_psi_vec_with_categorical():
+    """Test build_psi_vec with mixed numeric and categorical variables"""
+    X = np.array([[0.0, 0], [1.0, 0], [0.0, 1]])
+    y = np.array([0.0, 1.0, 2.0])
+    
+    model = Kriging(var_type=["num", "factor"])
+    model.fit(X, y)
+    
+    # Test points with same/different categories
+    x_same_cat = np.array([0.5, 0])    # Same category as first point
+    x_diff_cat = np.array([0.5, 1])    # Different category
+    
+    psi_same = model.build_psi_vec(x_same_cat)
+    psi_diff = model.build_psi_vec(x_diff_cat)
+    
+    # Correlation should be higher for same category
+    assert psi_same[0] > psi_diff[0]
+
+
+def test_build_psi_vec_extreme_distances():
+    """Test build_psi_vec with extreme distances"""
+    X = np.array([[0.0, 0.0], [1.0, 1.0]])
+    y = np.array([0.0, 1.0])
+    
+    model = Kriging()
+    model.fit(X, y)
+    
+    # Test very close point
+    x_close = np.array([0.0, 0.0])  # Same as first training point
+    psi_close = model.build_psi_vec(x_close)
+    assert np.isclose(psi_close[0], 1.0, atol=1e-10)
+    
+    # Test very far point
+    x_far = np.array([100.0, 100.0])
+    psi_far = model.build_psi_vec(x_far)
+    assert np.all(psi_far < 0.1)  # Should have low correlation
+
+
+def test_build_psi_vec_numerical_stability():
+    """Test numerical stability of build_psi_vec"""
+    X = np.array([[0.0, 0.0], [1e-10, 1e-10]])
+    y = np.array([0.0, 1.0])
+    
+    model = Kriging(nugget=1e-10)
+    model.fit(X, y)
+    
+    # Test with very small distances
+    x_test = np.array([1e-20, 1e-20])
+    psi = model.build_psi_vec(x_test)
+    
+    assert not np.any(np.isnan(psi))
+    assert not np.any(np.isinf(psi))
+
+
+def test_build_psi_vec_different_scales():
+    """Test build_psi_vec with variables on different scales"""
+    X = np.array([[0.0, 0.0], [0.1, 1000.0]])
+    y = np.array([0.0, 1.0])
+    
+    model = Kriging()
+    model.fit(X, y)
+    
+    x_test = np.array([0.05, 500.0])
+    psi = model.build_psi_vec(x_test)
+    
+    assert not np.any(np.isnan(psi))
+    assert np.all(psi >= 0) and np.all(psi <= 1)