pyANOVAapprox 0.2.0__tar.gz → 0.2.2__tar.gz

{pyanovaapprox-0.2.0 → pyanovaapprox-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyANOVAapprox
-Version: 0.2.0
+Version: 0.2.2
 Summary: Approximation Package for High-Dimensional Functions
 Project-URL: Homepage, https://github.com/NFFT/pyGroupedTransforms
 Author-email: Felix Wirth <fwi012001@gmail.com>

{pyanovaapprox-0.2.0 → pyanovaapprox-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyANOVAapprox"
-version = "0.2.0"
+version = "0.2.2"
 authors = [
   { name="Felix Wirth", email="fwi012001@gmail.com" },
 ]

pyanovaapprox-0.2.2/simpleTest/exampleCheb.py

@@ -0,0 +1,202 @@
+# pip install pyANOVAapprox
+
+# Example for approximating an non periodic function
+
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import pyANOVAapprox as ANOVAapprox
+
+
+def TestFunction(x):
+    return x[0] * x[4] + 2 - np.exp(x[3]) + np.sqrt(x[5] + 3 + x[1])
+
+
+rng = np.random.default_rng(1234)
+
+##################################
+## Definition of the parameters ##
+##################################
+
+d = 6  # dimension
+
+M = 10000  # number of used evaluation points to train the model
+M_test = 100000  # number of used evaluation points to test the accuracity the model
+
+max_iter = 50  # maximum number of iterations
+
+# there are 3 possibilities with varying degree of freedom to define the number of used frequencies
+########### Variant 1:
+ds = 2  # superposition dimension
+num = np.sum([math.comb(6, k) for k in np.arange(1, 2 + 1)])  # number of used subsets
+b = M / (
+    math.log10(M) * num
+)  # number for the number of frequencies if we use logarithmic oversampling and distribute it evenly to all subsets
+bw = [
+    math.floor(b / 2) * 2,
+    math.floor(math.sqrt(b) / 2) * 2,
+]  # bandwidths (use even numbers)
+# Use all subsets up to ds and use bw[1] many frequences in the the subsets with one element, b[2]^2 many for subsets with two elements and so on
+#
+########### Variant 2:
+# used subsets:
+# U = [(), (0,), (1,), (2,), (3,), (4,), (5,),
+#      (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
+# Bandwidths for these subsets:
+# N = [0 ,  100,  100,  100,  100,  100,  100,
+#          10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10]
+# Use the subsets U with the bandwiths N. The bandwith N[i] corresponds to the subset U[i]. For subsets with more then one direction is the same bandwidth in all directions used
+#
+########### Variant 3:
+# used subsets:
+# U = [(),   (0,),   (1,),   (2,),   (3,),   (4,),   (5,),
+#        (0, 1),  (0, 2),  (0, 3),  (0, 4),  (0, 5),  (1, 2),  (1, 3),  (1, 4),  (1, 5),  (2, 3),  (2, 4),  (2, 5),  (3, 4),  (3, 5),  (4, 5)]
+# Bandwidths for these subsets:
+# N = [(), (100,), (100,), (100,), (100,), (100,), (100,),
+#      (10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,)]
+# Use the subsets U with the bandwiths N. The bandwith N[i] corresponds to the subset U[i]. The bandwidth N[i][j] corresponds to the direction U[i][j]
+
+lambdas = np.array([0.0, 1.0])  # used regularisation parameters λ
+
+############################
+## Generation of the data ##
+############################
+
+X = 2 * rng.random((M, d)) - 1  # construct the evaluation points for training
+X = np.sin(np.pi * (X - 0.5))
+y = np.array(
+    [TestFunction(X[i, :].T) for i in range(M)]
+)  # evaluate the function at these points
+X_test = 2 * rng.random((M_test, d)) - 1  #
+X_test = np.sin(np.pi * (X_test - 0.5))
+y_test = np.array(
+    [TestFunction(X_test[i, :].T) for i in range(M_test)]
+)  # the same for the test points
+
+##########################
+## Do the approximation ##
+##########################
+
+ads = ANOVAapprox.approx(X, y, ds=ds, basis="cheb", N=bw)
+ads.approximate(lam=lambdas, max_iter=max_iter, solver="lsqr")
+
+################################
+## get approximation accuracy ##
+################################
+
+# mse = ANOVAapprox.get_mse(ads) # get mse error at the given training points
+mse = ANOVAapprox.get_mse(ads, X_test, y_test)  # get mse error at the test points
+λ_min = min(
+    mse, key=mse.get
+)  # get the regularisation parameter which leads to the minimal error
+mse_min = mse[λ_min]
+
+print("mse = " + str(mse_min))
+
+###############################################
+## Analyze the model to improve the accuracy ##
+###############################################
+
+
+ar = ANOVAapprox.get_AttributeRanking(ads, λ_min)  # get the attrbute ranking
+
+plt.figure()
+(markers, stemlines, baseline) = plt.stem(
+    np.arange(1, d + 1),  # x-Werte (1:d)
+    ar,  # y-Werte (ar)
+    linefmt="C0-",  # Stil der Stiele
+    markerfmt="C0^",  # Stil der Markierung (C0 = erste Farbe, ^ = up-triangle)
+    basefmt="k:",  # Stil der Basislinie (optional)
+)
+plt.setp(markers, markersize=8)
+plt.yscale("log")
+y_min_calc = 10 ** (np.min(np.log10(ar)) - 0.5)
+plt.ylim(y_min_calc, 1)
+plt.title("Attribute Ranking")
+plt.xlabel("Attribut-Index")
+plt.xlim(0.5, d + 0.5)
+plt.grid(True, which="both", ls="--", linewidth=0.5)
+plt.show()  # plot the arrtibute ranking in an logplot
+print("active dimensions: " + str(ar[ar > 1e-2]))
+
+gsis = ANOVAapprox.get_GSI(ads, λ_min)
+label = list(ads.U[1:])
+l = len(label)
+plt.figure()
+x_values = np.arange(1, l + 1)
+(markers, stemlines, baseline) = plt.stem(
+    x_values,  # X-Werte: 1 bis l
+    gsis,  # Y-Werte: gsis
+    linefmt="C0-",  # Stil der Stiele
+    markerfmt="C0^",  # Stil der Markierung (^ = up-triangle)
+    basefmt="k:",  # Stil der Basislinie
+)
+plt.setp(markers, markersize=8)
+plt.xticks(x_values, label, rotation=45, ha="right")
+plt.xlabel("Input Dimension")
+plt.yscale("log")
+plt.ylim(y_min_calc, 1)
+plt.title("Global sensitivity indices")
+plt.grid(True, which="both", ls="--", linewidth=0.5)
+plt.tight_layout()  # Stellt sicher, dass die Labels sichtbar sind
+plt.show()
+print(
+    "important dimensional interactions: : "
+    + str([label[i] for i in np.arange(0, l)[gsis > 1e-2]])
+)
+
+################################################
+## Approximation with better suited index set ##
+################################################
+
+Umask = np.append(np.array([True]), gsis > 1e-2)
+U = [ads.U[i] for i in np.arange(0, len(Umask))[Umask]]  # get important subsets
+bws = M / (math.log10(M) * (len(U) - 1))  # calculate frequencies per subset
+N = [
+    math.floor(bws ** (1 / max(1, len(u))) / 2) * 2 for u in U
+]  # distribute the frequencies evenly and make them even
+N[0] = 0
+
+a = ANOVAapprox.approx(
+    X, y, U, N, "cheb"
+)  # generate the data structure for the approximation
+a.approximate(
+    lam=lambdas, max_iter=max_iter, solver="lsqr"
+)  # do the approximation for all specified regularisation parameters
+
+mse = ANOVAapprox.get_mse(a, X_test, y_test)  # get mse error at the test points
+λ_min = min(
+    mse, key=mse.get
+)  # get the regularisation parameter which leads to the minimal error
+mse_min = mse[λ_min]
+print("mse = " + str(mse_min))
+
+########################
+## Evaluate the model ##
+########################
+
+# y_approx = a.evaluate(lam=λ_min) # evaluate the approximation at the training points for the regularisation λ_min
+# y_approx = a.evaluate(X=X_test, lam=λ_min) # evaluate the approximation at the points X_test for the regularisation λ_min
+
+# In the following we plot the real and the approximated anova term for the subset u=[3]
+
+y_eval_anova = a.evaluateANOVAterms(
+    X=X_test, lam=λ_min
+)  # evaluate all of the ANOVA terms
+pos = a.U.index((3,))  # find the index for the subset u=[3]
+y_eval_anova_3 = y_eval_anova.T[pos]
+
+perm = np.argsort(X_test.T[3])
+X_plot = X_test.T[3][perm]
+y_eval_anova_3_plot = np.real(y_eval_anova_3[perm])
+y_anova_3_plot = -np.exp(X_plot) + 1.2660446775548282
+
+plt.figure()
+plt.plot(X_plot, y_eval_anova_3_plot, label="approximation")
+plt.plot(X_plot, y_anova_3_plot, label="ANOVA term")  # ... "ANOVA term"]
+plt.title("Approximation of the ANOVA term 4")  # title = "..."
+plt.legend()  # Zeigt die Labels/Legende an
+plt.grid(True, linestyle="--", alpha=0.7)
+plt.show()

pyanovaapprox-0.2.2/simpleTest/exampleClassification.py

@@ -0,0 +1,190 @@
+# pip install pyANOVAapprox
+
+# Example for classification into two sets
+
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import pyANOVAapprox as ANOVAapprox
+
+
+def TestFunction(x):
+    e = (
+        abs(x[1] + 1.0j * x[2]) + (np.angle(x[1] + 1.0j * x[2]) / (math.pi * 8))
+    ) % 0.25 > 0.125
+    return e * 2 - 1
+
+
+rng = np.random.default_rng(1234)
+
+##################################
+## Definition of the parameters ##
+##################################
+
+d = 3  # dimension
+
+M = 10000  # number of used evaluation points to train the model
+M_test = 10000  # number of used evaluation points to test the accuracity the model
+
+max_iter = 50  # maximum number of iterations
+
+# there are 3 possibilities with varying degree of freedom to define the number of used frequencies
+########### Variant 1:
+ds = 2  # superposition dimension
+num = np.sum([math.comb(6, k) for k in np.arange(1, 2 + 1)])  # number of used subsets
+b = M / (
+    math.log10(M) * num
+)  # number for the number of frequencies if we use logarithmic oversampling and distribute it evenly to all subsets
+bw = [
+    math.floor(b / 2) * 2,
+    math.floor(math.sqrt(b) / 2) * 2,
+]  # bandwidths (use even numbers)
+# Use all subsets up to ds and use bw[1] many frequences in the the subsets with one element, b[2]^2 many for subsets with two elements and so on
+#
+########### Variant 2:
+# used subsets:
+# U = [(), (0,), (1,), (2,), (3,), (4,), (5,),
+#      (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
+# Bandwidths for these subsets:
+# N = [0 ,  100,  100,  100,  100,  100,  100,
+#          10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10]
+# Use the subsets U with the bandwiths N. The bandwith N[i] corresponds to the subset U[i]. For subsets with more then one direction is the same bandwidth in all directions used
+#
+########### Variant 3:
+# used subsets:
+# U = [(),   (0,),   (1,),   (2,),   (3,),   (4,),   (5,),
+#        (0, 1),  (0, 2),  (0, 3),  (0, 4),  (0, 5),  (1, 2),  (1, 3),  (1, 4),  (1, 5),  (2, 3),  (2, 4),  (2, 5),  (3, 4),  (3, 5),  (4, 5)]
+# Bandwidths for these subsets:
+# N = [(), (100,), (100,), (100,), (100,), (100,), (100,),
+#      (10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,)]
+# Use the subsets U with the bandwiths N. The bandwith N[i] corresponds to the subset U[i]. The bandwidth N[i][j] corresponds to the direction U[i][j]
+
+lambdas = np.array([0.0])  # used regularisation parameters λ
+
+############################
+## Generation of the data ##
+############################
+
+X = rng.random((M, d)) - 0.5  # construct the evaluation points for training
+y = np.array(
+    [TestFunction(X[i, :].T) for i in range(M)], dtype=float
+)  # evaluate the function at these points
+X = X + 0.5
+X_test = rng.random((M_test, d)) - 0.5  #
+y_test = np.array(
+    [TestFunction(X_test[i, :].T) for i in range(M_test)], dtype=float
+)  # the same for the test points
+X_test = X_test + 0.5
+
+###########################
+## Do the classification ##
+###########################
+
+ads = ANOVAapprox.approx(X, y, ds=ds, basis="cos", N=bw, classification=True)
+ads.approximate(max_iter=max_iter, lam=lambdas)
+
+#################################
+## get classification accuracy ##
+#################################
+
+y_approx = ads.evaluate(X=X_test, lam=0.0)  # evaluate the classification
+acc = sum(np.sign(y_approx) == y_test) / M_test  # calculate the accuracity
+print("accuracity = " + str(acc))
+
+###############################################
+## Analyze the model to improve the accuracy ##
+###############################################
+
+ar = ANOVAapprox.get_AttributeRanking(ads, 0.0)  # get the attrbute ranking
+
+plt.figure()
+(markers, stemlines, baseline) = plt.stem(
+    np.arange(1, d + 1),  # x-Werte (1:d)
+    ar,  # y-Werte (ar)
+    linefmt="C0-",  # Stil der Stiele
+    markerfmt="C0^",  # Stil der Markierung (C0 = erste Farbe, ^ = up-triangle)
+    basefmt="k:",  # Stil der Basislinie (optional)
+)
+plt.setp(markers, markersize=8)
+plt.yscale("log")
+y_min_calc = 10 ** (np.min(np.log10(ar)) - 0.5)
+plt.ylim(y_min_calc, 1)
+plt.title("Attribute Ranking")
+plt.xlabel("Attribut-Index")
+plt.xlim(0.5, d + 0.5)
+plt.grid(True, which="both", ls="--", linewidth=0.5)
+plt.show()  # plot the arrtibute ranking in an logplot
+print("active dimensions: " + str(ar[ar > 1e-2]))
+
+gsis = ANOVAapprox.get_GSI(ads, 0.0)
+label = list(ads.U[1:])
+l = len(label)
+plt.figure()
+x_values = np.arange(1, l + 1)
+(markers, stemlines, baseline) = plt.stem(
+    x_values,  # X-Werte: 1 bis l
+    gsis,  # Y-Werte: gsis
+    linefmt="C0-",  # Stil der Stiele
+    markerfmt="C0^",  # Stil der Markierung (^ = up-triangle)
+    basefmt="k:",  # Stil der Basislinie
+)
+plt.setp(markers, markersize=8)
+plt.xticks(x_values, label, rotation=45, ha="right")
+plt.xlabel("Input Dimension")
+plt.yscale("log")
+plt.ylim(y_min_calc, 1)
+plt.title("Global sensitivity indices")
+plt.grid(True, which="both", ls="--", linewidth=0.5)
+plt.tight_layout()  # Stellt sicher, dass die Labels sichtbar sind
+plt.show()
+print(
+    "important dimensional interactions: : "
+    + str([label[i] for i in np.arange(0, l)[gsis > 1e-2]])
+)
+
+#################################################
+## Classification with better suited index set ##
+#################################################
+
+Umask = np.append(np.array([True]), gsis > 1e-2)
+U = [ads.U[i] for i in np.arange(0, len(Umask))[Umask]]  # get important subsets
+bws = M / (math.log10(M) * (len(U) - 1))  # calculate frequencies per subset
+N = [
+    math.floor(bws ** (1 / max(1, len(u))) / 2) * 2 for u in U
+]  # distribute the frequencies evenly and make them even
+N[0] = 0
+
+a = ANOVAapprox.approx(
+    X, y, U, N, "cos", classification=True
+)  # generate the data structure for the classification
+a.approximate(
+    lam=lambdas, max_iter=max_iter
+)  # do the approximation for all specified regularisation parameters
+
+y_approx = a.evaluate(X=X_test, lam=0.0)  # evaluate the classification
+acc = sum(np.sign(y_approx) == y_test) / M_test  # calculate the accuracity
+print("accuracity = " + str(acc))
+
+########################
+## Evaluate the model ##
+########################
+
+# y_approx = a.evaluate(X=X_test) # evaluate the classification at the training points for the regularisation λ_min
+y_approx = a.evaluate(
+    X=X_test, lam=0.0
+)  # evaluate the classification at the points X_test for the regularisation λ_min
+
+plt.figure()
+scatter = plt.scatter(
+    X_test[:, 1],
+    X_test[:, 2],
+    c=np.sign(y_approx),
+    cmap="winter",
+    s=100,
+    alpha=0.8,
+    edgecolors="black",
+    linewidths=0.5,
+)
+plt.show()

pyanovaapprox-0.2.2/simpleTest/exampleNonPeriodic.py

@@ -0,0 +1,200 @@
+# pip install pyANOVAapprox
+
+# Example for approximating an non periodic function
+
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import pyANOVAapprox as ANOVAapprox
+
+
+def TestFunction(x):
+    return x[0] * x[4] + 2 - np.exp(x[3]) + np.sqrt(x[5] + 3 + x[1])
+
+
+rng = np.random.default_rng(1234)
+
+##################################
+## Definition of the parameters ##
+##################################
+
+d = 6  # dimension
+
+M = 10000  # number of used evaluation points to train the model
+M_test = 100000  # number of used evaluation points to test the accuracity the model
+
+max_iter = 50  # maximum number of iterations
+
+# there are 3 possibilities with varying degree of freedom to define the number of used frequencies
+########### Variant 1:
+ds = 2  # superposition dimension
+num = np.sum([math.comb(6, k) for k in np.arange(1, 2 + 1)])  # number of used subsets
+b = M / (
+    math.log10(M) * num
+)  # number for the number of frequencies if we use logarithmic oversampling and distribute it evenly to all subsets
+bw = [
+    math.floor(b / 2) * 2,
+    math.floor(math.sqrt(b) / 2) * 2,
+]  # bandwidths (use even numbers)
+# Use all subsets up to ds and use bw[1] many frequences in the the subsets with one element, b[2]^2 many for subsets with two elements and so on
+#
+########### Variant 2:
+# used subsets:
+# U = [(), (0,), (1,), (2,), (3,), (4,), (5,),
+#      (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
+# Bandwidths for these subsets:
+# N = [0 ,  100,  100,  100,  100,  100,  100,
+#          10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10]
+# Use the subsets U with the bandwiths N. The bandwith N[i] corresponds to the subset U[i]. For subsets with more then one direction is the same bandwidth in all directions used
+#
+########### Variant 3:
+# used subsets:
+# U = [(),   (0,),   (1,),   (2,),   (3,),   (4,),   (5,),
+#        (0, 1),  (0, 2),  (0, 3),  (0, 4),  (0, 5),  (1, 2),  (1, 3),  (1, 4),  (1, 5),  (2, 3),  (2, 4),  (2, 5),  (3, 4),  (3, 5),  (4, 5)]
+# Bandwidths for these subsets:
+# N = [(), (100,), (100,), (100,), (100,), (100,), (100,),
+#      (10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,)]
+# Use the subsets U with the bandwiths N. The bandwith N[i] corresponds to the subset U[i]. The bandwidth N[i][j] corresponds to the direction U[i][j]
+
+lambdas = np.array([0.0, 1.0])  # used regularisation parameters λ
+
+############################
+## Generation of the data ##
+############################
+
+X = rng.random((M, d))  # construct the evaluation points for training
+y = np.array(
+    [TestFunction(X[i, :].T) for i in range(M)]
+)  # evaluate the function at these points
+X_test = rng.random((M_test, d))  #
+y_test = np.array(
+    [TestFunction(X_test[i, :].T) for i in range(M_test)]
+)  # the same for the test points
+
+##########################
+## Do the approximation ##
+##########################
+
+ads = ANOVAapprox.approx(X, y, ds=ds, basis="cos", N=bw)
+ads.approximate(lam=lambdas, max_iter=max_iter, solver="lsqr")
+
+################################
+## get approximation accuracy ##
+################################
+
+# mse = ANOVAapprox.get_mse(ads) # get mse error at the given training points
+mse = ANOVAapprox.get_mse(ads, X_test, y_test)  # get mse error at the test points
+λ_min = min(
+    mse, key=mse.get
+)  # get the regularisation parameter which leads to the minimal error
+mse_min = mse[λ_min]
+
+print("mse = " + str(mse_min))
+
+###############################################
+## Analyze the model to improve the accuracy ##
+###############################################
+
+
+ar = ANOVAapprox.get_AttributeRanking(ads, λ_min)  # get the attrbute ranking
+
+plt.figure()
+(markers, stemlines, baseline) = plt.stem(
+    np.arange(1, d + 1),  # x-Werte (1:d)
+    ar,  # y-Werte (ar)
+    linefmt="C0-",  # Stil der Stiele
+    markerfmt="C0^",  # Stil der Markierung (C0 = erste Farbe, ^ = up-triangle)
+    basefmt="k:",  # Stil der Basislinie (optional)
+)
+plt.setp(markers, markersize=8)
+plt.yscale("log")
+y_min_calc = 10 ** (np.min(np.log10(ar)) - 0.5)
+plt.ylim(y_min_calc, 1)
+plt.title("Attribute Ranking")
+plt.xlabel("Attribut-Index")
+plt.xlim(0.5, d + 0.5)
+plt.grid(True, which="both", ls="--", linewidth=0.5)
+plt.show()  # plot the arrtibute ranking in an logplot
+print("active dimensions: " + str(ar[ar > 1e-2]))
+
+gsis = ANOVAapprox.get_GSI(ads, λ_min)
+label = list(ads.U[1:])
+l = len(label)
+plt.figure()
+x_values = np.arange(1, l + 1)
+(markers, stemlines, baseline) = plt.stem(
+    x_values,  # X-Werte: 1 bis l
+    gsis,  # Y-Werte: gsis
+    linefmt="C0-",  # Stil der Stiele
+    markerfmt="C0^",  # Stil der Markierung (^ = up-triangle)
+    basefmt="k:",  # Stil der Basislinie
+)
+plt.setp(markers, markersize=8)
+plt.xticks(x_values, label, rotation=45, ha="right")
+plt.xlabel("Input Dimension")
+plt.yscale("log")
+plt.ylim(y_min_calc, 1)
+plt.title("Global sensitivity indices")
+plt.grid(True, which="both", ls="--", linewidth=0.5)
+plt.tight_layout()  # Stellt sicher, dass die Labels sichtbar sind
+plt.show()
+print(
+    "important dimensional interactions: : "
+    + str([label[i] for i in np.arange(0, l)[gsis > 1e-2]])
+)
+
+################################################
+## Approximation with better suited index set ##
+################################################
+
+Umask = np.append(np.array([True]), gsis > 1e-2)
+U = [ads.U[i] for i in np.arange(0, len(Umask))[Umask]]  # get important subsets
+bws = M / (math.log10(M) * (len(U) - 1))  # calculate frequencies per subset
+N = [
+    math.floor(bws ** (1 / max(1, len(u))) / 2) * 2 for u in U
+]  # distribute the frequencies evenly and make them even
+N[0] = 0
+
+a = ANOVAapprox.approx(
+    X, y, U, N, "cos"
+)  # generate the data structure for the approximation
+a.approximate(
+    lam=lambdas, max_iter=max_iter, solver="lsqr"
+)  # do the approximation for all specified regularisation parameters
+
+mse = ANOVAapprox.get_mse(a, X_test, y_test)  # get mse error at the test points
+λ_min = min(
+    mse, key=mse.get
+)  # get the regularisation parameter which leads to the minimal error
+mse_min = mse[λ_min]
+print("mse = " + str(mse_min))
+
+########################
+## Evaluate the model ##
+########################
+
+# y_approx = a.evaluate(lam=λ_min) # evaluate the approximation at the training points for the regularisation λ_min
+# y_approx = a.evaluate(X=X_test, lam=λ_min) # evaluate the approximation at the points X_test for the regularisation λ_min
+
+# In the following we plot the real and the approximated anova term for the subset u=[3]
+
+y_eval_anova = a.evaluateANOVAterms(
+    X=X_test, lam=λ_min
+)  # evaluate all of the ANOVA terms
+pos = a.U.index((3,))  # find the index for the subset u=[3]
+y_eval_anova_3 = y_eval_anova.T[pos]
+
+perm = np.argsort(X_test.T[3])
+X_plot = X_test.T[3][perm]
+y_eval_anova_3_plot = np.real(y_eval_anova_3[perm])
+y_anova_3_plot = -np.exp(X_plot) + np.exp(1) - 1
+
+plt.figure()
+plt.plot(X_plot, y_eval_anova_3_plot, label="approximation")
+plt.plot(X_plot, y_anova_3_plot, label="ANOVA term")  # ... "ANOVA term"]
+plt.title("Approximation of the ANOVA term 4")  # title = "..."
+plt.legend()  # Zeigt die Labels/Legende an
+plt.grid(True, linestyle="--", alpha=0.7)
+plt.show()

{pyanovaapprox-0.2.0 → pyanovaapprox-0.2.2}/simpleTest/examplePeriodic.py

@@ -39,27 +39,28 @@ num = np.sum([math.comb(6, k) for k in np.arange(1, 2 + 1)])  # number of used s
 b = M / (
     math.log10(M) * num
 )  # number for the number of frequencies if we use logarithmic oversampling and distribute it evenly to all subsets
-bw = np.array(
-    [math.floor(b / 2) * 2, math.floor(math.sqrt(b) / 2) * 2]
-)  # bandwidths (use even numbers)
+bw = [
+    math.floor(b / 2) * 2,
+    math.floor(math.sqrt(b) / 2) * 2,
+]  # bandwidths (use even numbers)
 # Use all subsets up to ds and use bw[1] many frequences in the the subsets with one element, b[2]^2 many for subsets with two elements and so on
 #
 ########### Variant 2:
 # used subsets:
-# U = [Int[], [1], [2], [3], [4], [5], [6],
-#     [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [2, 3], [2, 4], [2, 5], [2, 6], [3, 4], [3, 5], [3, 6], [4, 5], [4, 6], [5, 6]]
+# U = [(), (0,), (1,), (2,), (3,), (4,), (5,),
+#      (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
 # Bandwidths for these subsets:
-# N = [[0]  , 100, 100, 100, 100, 100, 100,
-#         10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10]
+# N = [0 ,  100,  100,  100,  100,  100,  100,
+#          10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10,     10]
 # Use the subsets U with the bandwiths N. The bandwith N[i] corresponds to the subset U[i]. For subsets with more then one direction is the same bandwidth in all directions used
 #
 ########### Variant 3:
 # used subsets:
-# U = [Int[],   [1],   [2],   [3],   [4],   [5],   [6],
-#      [ 1, 2],[ 1, 3],[ 1, 4],[ 1, 5],[ 1, 6],[ 2, 3],[ 2, 4],[ 2, 5],[ 2, 6],[ 3, 4],[ 3, 5],[ 3, 6],[ 4, 5],[ 4, 6],[ 5, 6]]
+# U = [(),   (0,),   (1,),   (2,),   (3,),   (4,),   (5,),
+#        (0, 1),  (0, 2),  (0, 3),  (0, 4),  (0, 5),  (1, 2),  (1, 3),  (1, 4),  (1, 5),  (2, 3),  (2, 4),  (2, 5),  (3, 4),  (3, 5),  (4, 5)]
 # Bandwidths for these subsets:
-# N = [Int[], [100], [100], [100], [100], [100], [100],
-#      [10,10],[10,10],[10,10],[10,10],[10,10],[10,10],[10,10],[10,10],[10,10],[10,10],[10,10],[10,10],[10,10],[10,10],[10,10]]
+# N = [(), (100,), (100,), (100,), (100,), (100,), (100,),
+#      (10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,),(10,10,)]
 # Use the subsets U with the bandwiths N. The bandwith N[i] corresponds to the subset U[i]. The bandwidth N[i][j] corresponds to the direction U[i][j]
 
 lambdas = np.array([0.0, 1.0])  # used regularisation parameters λ
@@ -67,6 +68,7 @@ lambdas = np.array([0.0, 1.0])  # used regularisation parameters λ
 ############################
 ## Generation of the data ##
 ############################
+
 X = rng.random((M, d)) - 0.5  # construct the evaluation points for training
 y = np.array(
     [TestFunction(X[i, :].T) for i in range(M)], dtype=complex
@@ -81,7 +83,7 @@ y_test = np.array(
 ##########################
 
 ads = ANOVAapprox.approx(X, y, ds=ds, basis="per", N=bw)
-ads.approximate(lam=lambdas, solver="lsqr")
+ads.approximate(lam=lambdas, max_iter=max_iter, solver="lsqr")
 
 ################################
 ## get approximation accuracy ##
@@ -155,16 +157,16 @@ print(
 Umask = np.append(np.array([True]), gsis > 1e-2)
 U = [ads.U[i] for i in np.arange(0, len(Umask))[Umask]]  # get important subsets
 bws = M / (math.log10(M) * (len(U) - 1))  # calculate frequencies per subset
-N = np.array(
-    [math.floor(bws ** (1 / max(1, len(u))) / 2) * 2 for u in U]
-)  # distribute the frequencies evenly and make them even
+N = [
+    math.floor(bws ** (1 / max(1, len(u))) / 2) * 2 for u in U
+]  # distribute the frequencies evenly and make them even
 N[0] = 0
 
 a = ANOVAapprox.approx(
     X, y, U, N, "per"
 )  # generate the data structure for the approximation
 a.approximate(
-    lam=lambdas, solver="lsqr"
+    lam=lambdas, max_iter=max_iter, solver="lsqr"
 )  # do the approximation for all specified regularisation parameters
 
 mse = ANOVAapprox.get_mse(a, X_test, y_test)  # get mse error at the test points
@@ -183,27 +185,21 @@ print("mse = " + str(mse_min))
 
 # In the following we plot the real and the approximated anova term for the subset u=[3]
 
-y_eval_anova = a.evaluateANOVAterms(X=X_test, lam=λ_min) # evaluate all of the ANOVA terms 
-pos = a.U.index((3,)) # find the index for the subset u=[3]
+y_eval_anova = a.evaluateANOVAterms(
+    X=X_test, lam=λ_min
+)  # evaluate all of the ANOVA terms
+pos = a.U.index((3,))  # find the index for the subset u=[3]
 y_eval_anova_3 = y_eval_anova.T[pos]
 
 perm = np.argsort(X_test.T[3])
 X_plot = X_test.T[3][perm]
 y_eval_anova_3_plot = np.real(y_eval_anova_3[perm])
-y_anova_3_plot = -np.exp(np.sin(2*np.pi*X_plot))+1.26607
+y_anova_3_plot = -np.exp(np.sin(2 * np.pi * X_plot)) + 1.26607
 
 plt.figure()
-plt.plot(
-    X_plot,
-    y_eval_anova_3_plot,
-    label="approximation"
-)
-plt.plot(
-    X_plot,
-    y_anova_3_plot,
-    label="ANOVA term" # ... "ANOVA term"]
-)
-plt.title("Approximation of the ANOVA term 4") # title = "..."
-plt.legend() # Zeigt die Labels/Legende an
-plt.grid(True, linestyle='--', alpha=0.7)
+plt.plot(X_plot, y_eval_anova_3_plot, label="approximation")
+plt.plot(X_plot, y_anova_3_plot, label="ANOVA term")  # ... "ANOVA term"]
+plt.title("Approximation of the ANOVA term 4")  # title = "..."
+plt.legend()  # Zeigt die Labels/Legende an
+plt.grid(True, linestyle="--", alpha=0.7)
 plt.show()

pyanovaapprox-0.2.2/simpleTest/exampleWavelet.py

@@ -0,0 +1,134 @@
+# pip install pyANOVAapprox
+
+# Example for approximating an non periodic function
+
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import pyANOVAapprox as ANOVAapprox
+
+basis = "chui3"
+# for 'cos' the samples have to be in [0,1]^d
+# for a periodic function use 'per' or wavelets  'chui2', 'chui3', 'chui4' (samples have to be in [-0.5,0.5]^d here, 'chuim' are the Chui-Wang wavelets of order m)
+
+
+def TestFunction(x):  # this function is of the form f_0 + f_1 + f_2 + f_3 + f_4 + f_2,3
+    return 2 * abs(x[0]) + abs(math.sin(math.pi * x[1] * x[2])) + np.cos(3 + x[3])
+
+
+rng = np.random.default_rng(1234)
+
+##################################
+## Definition of the parameters ##
+##################################
+
+d = 8  # dimension
+q = 2  # superposition dimension
+M = 10000  # number of used evaluation points to train the model
+M_test = 10000  # number of used evaluation points to test the accuracity the model
+N = [5, 2]  # number of parameters, should be vector of length q:
+# for wavelets the total number of parameters scales exponentially, i.e.:
+# for q = 1 and N = [N1] the total number of parameters scales like ~O(d*2^N1)
+# for q = 2 and N = [N1 , N2] the total number of parameters scales like ~O(d*2^N1) + O(d^2 * N2*2^N2)
+
+lambdas = np.array([0.0])  # used regularisation parameters λ
+
+############################
+## Generation of the data ##
+############################
+
+if basis == "chui2" or basis == "chui3" or basis == "chui4" or basis == "per":
+    X = (
+        rng.random((M, d)) - 0.5
+    )  # for perioidic approximation samples have to be in [-0.5,0.5]^d
+elif basis == "cos":
+    X = rng.random((M, d))
+y = np.array(
+    [TestFunction(X[i, :].T) for i in range(M)]
+)  # evaluate the function at these points
+
+if (
+    basis == "chui1"
+    or basis == "chui2"
+    or basis == "chui3"
+    or basis == "chui4"
+    or basis == "per"
+):
+    X_test = (
+        rng.random((M_test, d)) - 0.5
+    )  # for perioidic approximation samples have to be in [-0.5,0.5]^d
+elif basis == "cos":
+    X_test = rng.random((M_test, d))
+y_test = np.array(
+    [TestFunction(X_test[i, :].T) for i in range(M_test)]
+)  # the same for the test points
+
+##########################
+## Do the approximation ##
+##########################
+
+####  construct model for ANOVAapprox ####
+anova_model = ANOVAapprox.approx(X, y, ds=q, basis=basis, N=N)
+
+####  Do approximation by least-squares ###
+anova_model.approximate(lam=lambdas, solver="lsqr")
+print("Total number of used parameters = " + str(len(anova_model.fc[lambdas[0]].vec())))
+
+#######################
+## Analyze the model ##
+#######################
+
+### Do sensitivity analysis ####
+gsis = ANOVAapprox.get_GSI(
+    anova_model, 0.0
+)  # calculates indices for importance of terms (gsis is vector, with indices belonging to terms in anova_model.U)
+# gsis_as_dict = ANOVAapprox.get_GSI(anova_model,0.0,dict=true)
+
+y_min_calc = 10 ** (np.min(np.log10(gsis)) - 0.5)
+label = list(anova_model.U[1:])
+l = len(label)
+plt.figure()
+x_values = np.arange(1, l + 1)
+(markers, stemlines, baseline) = plt.stem(
+    x_values,  # X-Werte: 1 bis l
+    gsis,  # Y-Werte: gsis
+    linefmt="C0-",  # Stil der Stiele
+    markerfmt="C0^",  # Stil der Markierung (^ = up-triangle)
+    basefmt="k:",  # Stil der Basislinie
+)
+plt.setp(markers, markersize=8)
+plt.xticks(x_values, label, rotation=45, ha="right")
+plt.xlabel("Input Dimension")
+plt.yscale("log")
+plt.ylim(y_min_calc, 1)
+plt.title("Global sensitivity indices")
+plt.grid(True, which="both", ls="--", linewidth=0.5)
+plt.tight_layout()  # Stellt sicher, dass die Labels sichtbar sind
+plt.show()
+
+################################
+## get approximation accuracy ##
+################################
+
+### error analysis ###
+mse_train = ANOVAapprox.get_mse(anova_model, lam=0.0)
+mse_test = ANOVAapprox.get_mse(anova_model, X_test, y_test, lam=0.0)
+
+print("MSE on test points: " + str(mse_test))
+
+################################################
+## Approximation with better suited index set ##
+################################################
+
+U = ANOVAapprox.get_ActiveSet(anova_model, [0.01, 0.01], lam=0.0)
+print("Found index-set U: " + str(U))
+anova_model = ANOVAapprox.approx(
+    X, y, U=U, N=[i + 2 for i in N], basis=basis
+)  # increase number of paramers in N for the important terms
+anova_model.approximate(lam=lambdas)
+print("Total number of used parameters = " + str(len(anova_model.fc[lambdas[0]].vec())))
+mse_train = ANOVAapprox.get_mse(anova_model, lam=0.0)
+mse_test = ANOVAapprox.get_mse(anova_model, X_test, y_test, lam=0.0)
+print("MSE on test points after ANOVA truncation: " + str(mse_test))

{pyanovaapprox-0.2.0 → pyanovaapprox-0.2.2}/src/pyANOVAapprox/analysis.py

@@ -47,7 +47,7 @@ def _GSI(a, lam, Dict):  # helpfunction for get_GSI
 
     if Dict:
         if a.basis.startswith("chui"):
-            variances = np.square(a.fc[lam].norms(Dict=True, m=int(a.basis[-1])))
+            variances = a.fc[lam].norms(Dict=True, m=int(a.basis[-1]))
         else:
             variances = a.fc[lam].norms(Dict=True)
         return {u: (variances[u] ** 2) / variance_f for u in list(variances)}
@@ -129,7 +129,7 @@ def lam_ActiveSet(a, eps, lam):  # helpfunction for get_ActiveSet
             n += 1
 
     U_active = [None] * (n + 1)
-    U_active[0] = []
+    U_active[0] = ()
 
     idx = 1
     for i in range(len(gsi)):

{pyanovaapprox-0.2.0 → pyanovaapprox-0.2.2}/src/pyANOVAapprox/approx.py

@@ -1,4 +1,4 @@
-from pyGroupedTransforms.GroupedTransform import *  # TODO: Kann wahrscheinlich weg sobald in pyGroupedTransform GreoupedTransform exportiert wird
+# from pyGroupedTransforms.GroupedTransform import *  # TODO: Kann wahrscheinlich weg sobald in pyGroupedTransform GreoupedTransform exportiert wird
 
 from pyANOVAapprox import *
 from pyANOVAapprox.fista import *
@@ -83,10 +83,11 @@ class approx:
         classification=False,
         basis_vect=[],
         fastmult=None,
+        parallel=True,
         ds=None,
     ):
 
-        if (N == None or len(N) == 0):
+        if N == None or len(N) == 0:
             ValueError("please define N")
 
         if (
@@ -94,8 +95,8 @@ class approx:
         ):  # setting U   #approx(X::Matrix{Float64}, y::Union{Vector{ComplexF64},Vector{Float64}}, ds::Int, N::Vector{Int}, basis::String = "cos"; classification::Bool = false, basis_vect::Vector{String} = Vector{String}([]), fastmult::Bool = classification ? true : false,)
             U = get_superposition_set(X.shape[1], ds)
 
-        if (
-            not isinstance(N[0], list)
+        if not isinstance(
+            N[0], tuple
         ):  # setting N    #approx( X::Matrix{Float64}, y::Union{Vector{ComplexF64},Vector{Float64}}, U::Vector{Vector{Int}}, N::Vector{Int}, basis::String = "cos"; classification::Bool = false, basis_vect::Vector{String} = Vector{String}([]), fastmult::Bool = classification ? true : false,)
             ds = max(len(u) for u in U)
 
@@ -116,9 +117,9 @@ class approx:
                     bws[i] = np.array([bw[i]] * len(u), np.int32)
 
             N = bws
-        
+
         else:
-            N = [np.array(u, dtype = np.int32) for u in N]
+            N = [np.array(u, dtype=np.int32) for u in N]
 
         if basis_vect is None:
             basis_vect = []
@@ -185,6 +186,7 @@ class approx:
             N=N,
             X=Xt,
             fastmult=fastmult,
+            parallel=parallel,
             basis_vect=basis_vect,
         )
 
@@ -198,6 +200,7 @@ class approx:
         self.classification = classification
         self.basis_vect = basis_vect
         self.fastmult = fastmult
+        self.parallel = parallel
 
     def Approximate(
         self, lam, max_iter=50, weights=None, verbose=False, solver=None, tol=1e-8

{pyanovaapprox-0.2.0 → pyanovaapprox-0.2.2}/src/pyANOVAapprox/fista.py

@@ -1,4 +1,4 @@
-from pyGroupedTransforms.GroupedCoefficients import *  # TODO: Kann wahrscheinlich weg sobald in pyGroupedTransform GreoupedTransform exportiert wird
+# from pyGroupedTransforms.GroupedCoefficients import *  # TODO: Kann wahrscheinlich weg sobald in pyGroupedTransform GreoupedTransform exportiert wird
 
 from pyANOVAapprox import *
 

{pyanovaapprox-0.2.0 → pyanovaapprox-0.2.2}/tests/run_tests.py

@@ -12,7 +12,7 @@ import sys
 # Script to run all tests and return any failures
 def run_tests():
     test_files = [
-        #        "tests/wav_lsqr.py",
+        "tests/wav_lsqr.py",
         "tests/cheb_fista.py",
         "tests/cheb_lsqr.py",
         "tests/per_fista.py",

pyanovaapprox-0.2.2/tests/wav_lsqr.py

@@ -0,0 +1,50 @@
+import os
+import sys
+
+src_aa = os.path.abspath(os.path.join(os.getcwd(), "src"))
+sys.path.insert(0, src_aa)
+
+import numpy as np
+from pyGroupedTransforms import *
+from TestFunctionPeriodic import *
+
+import pyANOVAapprox as ANOVAapprox
+
+d = 6
+ds = 2
+M = 10000
+max_iter = 50
+bw = [4, 4]
+lambdas = np.array([0.0, 1.0])
+
+rng = np.random.default_rng()
+X = rng.random((M, d)) - 0.5
+y = np.array([f(X[i, :].T) for i in range(M)])
+X_test = rng.random((M, d)) - 0.5
+y_test = np.array([f(X_test[i, :].T) for i in range(M)])
+
+ads = ANOVAapprox.approx(X, y, ds=ds, N=bw, basis="chui2")
+ads.approximate(lam=lambdas, solver="lsqr")
+
+print("AR: " + str(sum(ANOVAapprox.get_AttributeRanking(ads, 0.0))))
+assert abs(sum(ANOVAapprox.get_AttributeRanking(ads, 0.0)) - 1) < 0.0001
+
+bw = ANOVAapprox.get_orderDependentBW(AS, [4, 4])
+aU = ANOVAapprox.approx(X, y, U=AS, N=bw, basis="chui2")
+aU.approximate(lam=lambdas, solver="lsqr")
+
+err_l2_ds = ANOVAapprox.get_l2_error(ads)[0.0]
+err_l2_U = ANOVAapprox.get_l2_error(aU)[0.0]
+err_l2_rand_ds = ANOVAapprox.get_l2_error(ads, X_test, y_test)[0.0]
+err_l2_rand_U = ANOVAapprox.get_l2_error(aU, X_test, y_test)[0.0]
+
+print("== WAVELET LSQR ==")
+print("l2 ds: ", err_l2_ds)
+print("l2 U: ", err_l2_U)
+print("l2 rand ds: ", err_l2_rand_ds)
+print("l2 rand U: ", err_l2_rand_U)
+
+assert err_l2_ds < 0.01
+assert err_l2_U < 0.01  # maybe restrict to 0.005
+assert err_l2_rand_ds < 0.01
+assert err_l2_rand_U < 0.01

pyanovaapprox-0.2.0/tests/wav_lsqr.py

@@ -1 +0,0 @@
-# hier bin ich unverhofft auf probleme gestoßen, deswegen erstmal ein dummyfile nur...