Version - 0.0.24

IngeoML/__init__.py

@@ -11,8 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-__version__ = '0.0.23'
+__version__ = '0.0.24'
 
-from IngeoML.bootstrap import CI, SE, StatisticSamples
 from IngeoML.feature_selection import SelectFromModelCV
-from IngeoML.optimizer import classifier, regression
+from IngeoML.optimizer import classifier, regression
+from IngeoML.analysis import feature_importance, predict_shuffle_inputs

IngeoML/analysis.py

@@ -0,0 +1,51 @@
+# Copyright 2024 Mario Graff Guerrero
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from sklearn.metrics import f1_score
+from joblib import Parallel, delayed
+import numpy as np
+from IngeoML.utils import progress_bar
+
+
+def feature_importance(model, X, y, predictions,
+                       score=None, n_jobs: int=1):
+    """Estimate the feature importance of the model"""
+    def compute_score(y, i):
+        return [score(y, j) for j in i]
+
+    if score is None:
+        score = lambda y, hy: f1_score(y, hy, average='macro')
+    base = score(y, model.predict(X))
+    hy = Parallel(n_jobs=n_jobs)(delayed(compute_score)(y, i)
+                                 for i in progress_bar(predictions))
+    hy = np.array(hy)
+    return base - hy
+
+
+def predict_shuffle_inputs(model, X, times: int=100, n_jobs: int=1):
+    """Predict X by shuffling all the inputs"""
+    def predict(model, X, rng, i):
+        inner = []
+        for _ in range(times):
+            rng.shuffle(X[:, i])
+            inner.append(model.predict(X))
+        return np.vstack(inner)
+
+    X_origin = X.copy()
+    rng = np.random.default_rng()
+    output = []
+    output = Parallel(n_jobs=n_jobs,
+                      max_nbytes=None)(delayed(predict)(model, X, rng, i)
+                                       for i in progress_bar(range(X.shape[1]),
+                                                             total=X.shape[1]))
+    return np.array(output)

IngeoML/optimizer.py

@@ -265,15 +265,20 @@ def encode(y, validation):
                 _ = validation[1]
                 validation[1] = encoder.transform(_.reshape(-1, 1))
         return y_enc
-    
+
     def create_batches(batches):
         if batches is None:
             batches = Batches(size=512 if X.shape[0] >= 2048 else 256,
                               random_state=0)
         batches_ = []
-        if classifier and class_weight == 'balanced':
+        if classifier:
             splits = batches.split(y=y)
-            balance = balance_class_weights
+            if class_weight == 'balanced':
+                balance = balance_class_weights
+            elif callable(class_weight):
+                balance = class_weight
+            else:
+                raise NotImplementedError()
         else:
             splits = batches.split(X)
             balance = lambda x: jnp.ones(x.shape[0]) / x.shape[0]