Merge branch 'dev' into main

Author: mborn1

docs/source/_docs/analysis/example_scenarios.rst

@@ -326,7 +326,7 @@ Finally, we fit the SAMS model
 >>> regr = SamsRegressor(
 >>>     factors, Y2X,
 >>>     dependencies=dependencies, mode='weak',
->>>     forced_model=np.array([0], np.int_),
+>>>     forced_model=np.array([0], np.int64),
 >>>     model_size=6, nb_models=5000, skipn=1000,
 >>> )
 >>> regr.fit(data.drop(columns='Y'), data['Y'])

examples/analysis/sams/sams_generic.py

@@ -41,7 +41,7 @@
 regr = SamsRegressor(
     factors, Y2X,
     dependencies=dependencies, mode='weak',
-    forced_model=np.array([0], np.int_),
+    forced_model=np.array([0], np.int64),
     model_size=6, nb_models=5000, skipn=1000,
 )
 regr.fit(data.drop(columns='Y'), data['Y'])

examples/analysis/sams/sams_partial_rsm.py

@@ -41,7 +41,7 @@
 regr = SamsRegressor(
     factors, Y2X,
     dependencies=dependencies, mode='weak',
-    forced_model=np.array([0], np.int_),
+    forced_model=np.array([0], np.int64),
     model_size=6, nb_models=5000, skipn=1000,
     entropy_model_order=model_order
 )

src/pyoptex/__init__.py

@@ -1,2 +1,2 @@
 # Define the version number
-__version__ = "1.0.0-rc3"
+__version__ = "1.0.0-rc4"

src/pyoptex/analysis/estimators/sams/bnb/sams_bnb.py

@@ -106,7 +106,7 @@ def __init__(self, model_size, models, nterms,
 
         # Default values
         if forced_model is None:
-            forced_model = np.zeros((0,), dtype=np.int_)
+            forced_model = np.zeros((0,), dtype=np.int64)
 
         # Store the variables
         self.model_size = model_size
@@ -137,8 +137,8 @@ def initialize(self, nfit):
             The corresponding scores.
         """
         # Initialize the best size 'nfit' models
-        top_models = np.zeros((nfit, self.model_size), dtype=np.int_)
-        top_frequencies = np.zeros(nfit, dtype=np.int_)
+        top_models = np.zeros((nfit, self.model_size), dtype=np.int64)
+        top_frequencies = np.zeros(nfit, dtype=np.int64)
 
         # Initialization procedure
         models = self.spm
@@ -214,7 +214,7 @@ def init_queue(self, top_results, top_scores):
 
         for i in options:
             # Create a node
-            node = np.zeros(self.model_size, dtype=np.int_)
+            node = np.zeros(self.model_size, dtype=np.int64)
             node[:self.forced_model.size] = self.forced_model
             node[self.forced_model.size] = i
             node[self.forced_model.size + 1:] = -1

src/pyoptex/analysis/estimators/sams/estimator.py

@@ -349,7 +349,7 @@ def _topn_selection(self, results, sizes, nterms, topn=4, timeout_sec=180):
         """
         # Initialize results
         models = list()
-        counts = np.zeros(len(sizes) * topn, dtype=np.int_)
+        counts = np.zeros(len(sizes) * topn, dtype=np.int64)
 
         # Compute BnB
         for i, size in tqdm(enumerate(sizes), total=len(sizes), disable=(not self.tqdm)):
@@ -537,7 +537,7 @@ def _fit(self, X, y):
 
             # Fit kmeans on selected number of clusters
             self.kmeans_ = KMeans(n_init='auto', n_clusters=ncluster).fit(results_cluster)
-            self.kmeans_.skips = np.zeros(ncluster, dtype=np.int_)
+            self.kmeans_.skips = np.zeros(ncluster, dtype=np.int64)
             self.kmeans_.dists = kmeans_dists
 
             # Perform model select on each cluster

src/pyoptex/analysis/estimators/sams/models/model.py

@@ -63,7 +63,7 @@ def __init__(self, X, y, forced=None, mode='weak', dep=None):
 
         # Create default forced
         if forced is None:
-            forced = np.array([], dtype=np.int_)
+            forced = np.array([], dtype=np.int64)
 
         # Store
         self.X = X 
@@ -288,11 +288,11 @@ def sample_model_dep_mcmc(dep, size, n_samples=1, forced=None, mode=None, skip=1
     m = Model(np.zeros((0, len(dep))), np.zeros((0,)), mode=mode, forced=forced, dep=dep)
 
     # Initialize a random model
-    model = np.zeros((size,), dtype=np.int_)
+    model = np.zeros((size,), dtype=np.int64)
     m.init(model)
 
     # Intialize the samples
-    samples = np.zeros((n_samples, size), dtype=np.int_)
+    samples = np.zeros((n_samples, size), dtype=np.int64)
 
     # Warmup phase
     for i in range(n_warmup):

src/pyoptex/analysis/estimators/sams/plot.py

@@ -55,7 +55,7 @@ def plot_raster(results, terms, skipn=0, metric_name='metric',
     # Check if we require kmeans plotting
     if kmeans is not None:
         # Initialize indices with first skipn
-        idx = np.zeros(len(results), dtype=np.int_)
+        idx = np.zeros(len(results), dtype=np.int64)
         idx[:skipn] = np.arange(skipn)
 
         # Initialize the array of skips and thresholds
@@ -64,7 +64,7 @@ def plot_raster(results, terms, skipn=0, metric_name='metric',
 
         # Add default skips
         if not hasattr(kmeans, 'skips'):
-            kmeans.skips = np.zeros(kmeans.n_clusters, dtype=np.int_)
+            kmeans.skips = np.zeros(kmeans.n_clusters, dtype=np.int64)
 
         # Loop over all clusters
         for i in range(kmeans.n_clusters):

src/pyoptex/analysis/estimators/sams/simulation.py

@@ -43,15 +43,15 @@ def simulate_sams(model, model_size, accept_fn=None, nb_models=10, minprob=0.01,
 
     # Initialize model storage
     rdtype = np.dtype([
-        ('model', np.int_, model_size), 
+        ('model', np.int64, model_size), 
         ('coeff', np.float64, model_size),
         ('metric', np.float64)
     ])   
     results = np.zeros(nb_models, dtype=rdtype)
-    models = np.zeros((nb_models, model_size), dtype=np.int_)
+    models = np.zeros((nb_models, model_size), dtype=np.int64)
 
     # Create initial model
-    m = np.zeros(model_size, dtype=np.int_)
+    m = np.zeros(model_size, dtype=np.int64)
     m = model.init(m)
 
     # Compute initial metric

src/pyoptex/analysis/mixins/conditional_mixin.py

@@ -75,7 +75,7 @@ def _regr_params(self, X, y):
 
             # Create the conditional model
             self._conditional_model = pd.DataFrame(
-                np.eye(len(self._conditional_factors) ,dtype=np.int_), 
+                np.eye(len(self._conditional_factors) ,dtype=np.int64), 
                 columns=[str(f.name) for f in self._conditional_factors]
             )
 

src/pyoptex/analysis/mixins/fit_mixin.py

@@ -284,7 +284,7 @@ def preprocess_fit(self, X, y):
         if len(self._re) == 0:
             # Define OLS fit
             self.fit_fn_ = lambda X, y, terms: fit_ols(X[:, terms], y)
-            self.Zs_ = np.empty((0, len(X)), dtype=np.int_)
+            self.Zs_ = np.empty((0, len(X)), dtype=np.int64)
 
         else:
             # Create list from the random effects

src/pyoptex/doe/cost_optimal/codex/insert.py

@@ -39,7 +39,7 @@ def groups_insert(Yn, Zs, pos, colstart):
     """
 
     # Initialization
-    a = np.zeros(len(Zs), dtype=np.int_)
+    a = np.zeros(len(Zs), dtype=np.int64)
     b = [() for _ in range(a.size)]
 
     # Loop over all factors

src/pyoptex/doe/cost_optimal/codex/optimization.py

@@ -342,15 +342,15 @@ def ce_struct_optimizer(state, params):
     for col in range(params.colstart.size - 1):
         # Detect blocks
         blocks = np.concatenate((
-            np.array([0], np.int_), 
+            np.array([0], np.int64), 
             np.where(numba_any_axis1(numba_diff_axis0(state.Y[:, params.colstart[col]:params.colstart[col+1]]) != 0))[0] + 1,
-            np.array([len(state.Y)], np.int_)
+            np.array([len(state.Y)], np.int64)
         ))
 
         # Extract blocks with no overlap in prior
         blocks = blocks[blocks >= nprior]
         if blocks[0] != nprior:
-            blocks = np.concatenate((np.array([nprior], np.int_), blocks))
+            blocks = np.concatenate((np.array([nprior], np.int64), blocks))
 
         for b in range(blocks.size - 1):
             # Rows from that block

src/pyoptex/doe/cost_optimal/codex/simulation.py

@@ -35,7 +35,7 @@ def simulate(params, nsims=100, validate=False):
     # Initialize stats
     params.stats['it'] = 0
     params.stats['rejections'] = 0
-    params.stats['insert_loc'] = -1 * np.ones(nsims, dtype=np.int_)
+    params.stats['insert_loc'] = -1 * np.ones(nsims, dtype=np.int64)
     params.stats['removed_insert'] = np.zeros(nsims, dtype=np.bool_)
     params.stats['metrics'] = np.zeros(nsims, dtype=np.float64)
 

src/pyoptex/doe/cost_optimal/cov.py

@@ -233,7 +233,7 @@ def _cov(Y, X, Zs, Vinv, costs, random=False):
         else:
             # Define blocks and ratios
             cum_cost = np.cumsum(costs[cost_index][0])
-            blocks = np.floor_divide(cum_cost, cost).astype(np.int_)
+            blocks = np.floor_divide(cum_cost, cost).astype(np.int64)
 
             # Update Zs, Vinv
             Zs = list(Zs)

src/pyoptex/doe/fixed_structure/init.py

@@ -174,8 +174,8 @@ def __correct_constraints(effect_types, effect_levels, grps, coords,
         for i in permitted_to_optimize:
             # Determine which runs belong to that group
             if level == 0:
-                runs = np.array([i], dtype=np.int_)
-                prev_runs = np.arange(i+1, dtype=np.int_)
+                runs = np.array([i], dtype=np.int64)
+                prev_runs = np.arange(i+1, dtype=np.int64)
             else:
                 runs = np.flatnonzero(Zs[level-1] == i)
                 prev_runs = np.flatnonzero(Zs[level-1] <= i)
@@ -188,8 +188,8 @@ def __correct_constraints(effect_types, effect_levels, grps, coords,
                         co 
                         for co in (np.unique(Zs[l-1][runs]) if l > 0 else runs)
                         if co in grps[k]
-                    ], dtype=np.int_)
-                    if l in zidx[j:] else np.empty((0,), dtype=np.int_) 
+                    ], dtype=np.int64)
+                    if l in zidx[j:] else np.empty((0,), dtype=np.int64) 
                     for k, l in enumerate(effect_levels)
                 ]
                 grps_ = List(grps_)

src/pyoptex/doe/fixed_structure/splitk_plot/init.py

@@ -175,11 +175,11 @@ def __correct_constraints(effect_types, effect_levels, grps, thetas, coords,
                 np.array([
                     g for g in grps[col] 
                     if g >= grp*jmp/thetas[l] and g < (grp+1)*jmp/thetas[l]
-                ], dtype=np.int_) 
+                ], dtype=np.int64) 
                 if l < level else (
-                    np.arange(grp, grp+1, dtype=np.int_) 
+                    np.arange(grp, grp+1, dtype=np.int64) 
                     if (l == level and grp in grps[col])
-                    else np.arange(0, dtype=np.int_)
+                    else np.arange(0, dtype=np.int64)
                 )
                 for col, l in enumerate(effect_levels)
             ]

src/pyoptex/doe/fixed_structure/splitk_plot/utils.py

@@ -211,7 +211,7 @@ def terms_per_plot_level(factors, model):
     # Initialize
     plot_levels = np.array([f.re.level for f in factors])
     max_split_level = np.max(plot_levels)
-    split_levels = np.zeros(max_split_level+1, np.int_)
+    split_levels = np.zeros(max_split_level+1, np.int64)
 
     # Compute amount of terms with only factors higher or equal to current split-level
     for i in range(max_split_level + 1):
@@ -270,7 +270,7 @@ def validate_plot_sizes(factors, model):
     """
     # Compute plot sizes
     nb_plots = max(f.re.level for f in factors) + 1
-    plot_sizes = np.zeros(nb_plots, dtype=np.int_)
+    plot_sizes = np.zeros(nb_plots, dtype=np.int64)
     for f in factors:
         plot_sizes[f.re.level] = f.re.size
 

src/pyoptex/doe/fixed_structure/splitk_plot/wrapper.py

@@ -132,7 +132,7 @@ def create_parameters(factors, fn, prior=None, grps=None, use_formulas=True):
 
     # Extract the plot sizes
     nb_plots = max(f.re.level for f in factors) + 1
-    plot_sizes = np.ones(nb_plots, dtype=np.int_) * -1
+    plot_sizes = np.ones(nb_plots, dtype=np.int64) * -1
     ratios = [None] * nb_plots
     for f in factors:
         # Fix plot sizes
@@ -209,7 +209,7 @@ def create_parameters(factors, fn, prior=None, grps=None, use_formulas=True):
 
         # Compute old plot sizes
         nb_old_plots = max(p.level for p in old_plots) + 1
-        old_plot_sizes = np.ones(nb_old_plots, dtype=np.int_) * -1
+        old_plot_sizes = np.ones(nb_old_plots, dtype=np.int64) * -1
         for p in old_plots:
             if old_plot_sizes[p.level] == -1:
                 old_plot_sizes[p.level] = p.size
@@ -241,8 +241,8 @@ def create_parameters(factors, fn, prior=None, grps=None, use_formulas=True):
         grps = List([lgrps[lvl] for lvl in effect_levels])
     else:
         grps = List([np.concatenate(
-            (grps[i].astype(np.int_), lgrps[effect_levels[i]]), 
-            dtype=np.int_
+            (grps[i].astype(np.int64), lgrps[effect_levels[i]]), 
+            dtype=np.int64
         ) for i in range(len(effect_levels))])
 
     # Create the parameters

src/pyoptex/doe/fixed_structure/wrapper.py

@@ -154,15 +154,15 @@ def create_parameters(factors, fn, nruns, block_effects=(), prior=None, grps=Non
 
     # Compute Zs and Vinv
     if len(re) > 0:
-        Zs = np.array([np.array(r.Z) for r in re], dtype=np.int_)
+        Zs = np.array([np.array(r.Z) for r in re], dtype=np.int64)
         V = np.array([obs_var_from_Zs(Zs, N=nruns, ratios=r) for r in ratios])
     else:
-        Zs = np.empty((0, 0), dtype=np.int_)
+        Zs = np.empty((0, 0), dtype=np.int64)
         V = np.expand_dims(np.eye(nruns), 0)
 
     # Augment V with the random blocking effects
     if len(block_effects) > 0:
-        beZs = np.array([np.array(be.Z) for be in block_effects], dtype=np.int_)
+        beZs = np.array([np.array(be.Z) for be in block_effects], dtype=np.int64)
         V += np.array([
             obs_var_from_Zs(beZs, N=nruns, ratios=r, include_error=False) 
             for r in be_ratios
@@ -172,7 +172,7 @@ def create_parameters(factors, fn, nruns, block_effects=(), prior=None, grps=Non
     Vinv = np.linalg.inv(V)
 
     # Define which groups to optimize
-    lgrps = [np.arange(nruns, dtype=np.int_)] + [np.arange(np.max(Z)+1) for Z in Zs]
+    lgrps = [np.arange(nruns, dtype=np.int64)] + [np.arange(np.max(Z)+1) for Z in Zs]
     grps = List([lgrps[lvl] for lvl in effect_levels])
 
     # Create the parameters

src/pyoptex/utils/design.py

@@ -184,7 +184,7 @@ def encode_design(Y, effect_types, coords=None):
                 eye = np.concatenate((np.eye(cols[i]), -np.ones((1, cols[i]))))
             else:
                 eye = coords[i]
-            Yenc[..., start:start+cols[i]] = numba_take_advanced(eye, Y[..., i].astype(np.int_))
+            Yenc[..., start:start+cols[i]] = numba_take_advanced(eye, Y[..., i].astype(np.int64))
             start += cols[i]
 
     return Yenc